/* 20190612-01 RP  
 *  USB0
 *  Testversion ESP8266
 *  
 *  
 *  https://developers.google.com/chart/interactive/docs/quick_start
 *  
 *  
 *  
 *  
*/
/* ESP32 Programmable Thermostat IoT

   Version 1.0  1/7/2017  Version 1.0   Damon Borgnino
*
 * Auf ESP32 übertragen von von Achim Birkner. OvGU MAgdeburg
 * 
  */
#include <ROBISYS.h>
  
//#include <WiFi.h>
#include <ESP8266WiFi.h>      // Include the Wi-Fi library
#include <WiFiClient.h>
   // #include <WebServer.h>

#include <WiFiServer.h>
#include <ESP8266WebServer.h>   
#include <FS.h> // FOR SPIFFS
// #include <SPIFFS.h>
#include <ctype.h> // for isNumber check
//#include <DHTesp.h>

//Definition pins
#define markiseSenkoeffnenpin 23
#define markiseSenkschliessenpin 22
#define markiseHorizoeffnenpin 21
#define markiseHorizschliessenpin 19
#define fensterDachoeffnenpin 18
#define fensterDachschliessenpin 5
#define fensterKlappoeffnenpin 17
#define fensterKlappschliessenpin 16

//Definition der Sensoreingänge
#define windsensorpin 2
#define solarsensorpin 15
//# define regensensorpin XX
//Definition von Pins zum Handbetrieb und zur Notfall-Erkennung
#define handbetriebpin 9
#define notfallpin 8 //brauchen wir diese Funktion per Handsteuerung? Als Zusatzinfo?


//   Stationsmode (STA mode)
#ifndef STASSID
#define STASSID "TeamBringit"
#define STAPSK  "12345678"
#endif


// DHTesp dht;
/** Task handle for the light value read task */
//TaskHandle_t tempTaskHandle = NULL;
/** Pin-Nummer für DHT11 data pin */
int DHTPIN = 4;


const char* ssid = STASSID;
const char* password = STAPSK;

 //WebServer server(80); 
 ESP8266WebServer server(80);
 /*Globale Variablen und Konstanten für WLAN, Temperatur     */

bool notfallbedingung = false;
int zuwarm= 24;
int zukalt = 17;
float regenNotfall = 1.0;
float windNotfall = 1.1;

float regenWert = 0.5;
float windWert = 0.2;;
float sonneWert = 2 ;
String markiseSenkzustand = "Markise geschlossen";
String markiseHorizzustand = "Markise geschlossen";
String fensterDachzustand = "Dachfenster geschlossen";
String fensterKlappzustand = "Seitenfenster geschlossen";
const static String fName = "prop.txt";
const static String dfName = "data.txt";
int dataLines = 0; //Datenreihen
int maxFileData = 20; //Wieviele Werte im Diagramm dargestellt werden sollen

bool markise1= true;   // Markise1 geschlossen/geoefnnet
bool markise2= true;   // Markise1 geschlossen
bool fenster1= true;   // Fenster1 geschlossen
bool fenster2= true;   // Fenster2 geschlossen

bool usegoogle = true;    //google Charts anutzen

// fuer printLocalTime
const char* ntpServer = "pool.ntp.org";
const long  gmtOffset_sec = 0;
const int   daylightOffset_sec = 3600;

char buffer[80];


// Initialize DHT sensor

// This is for the ESP8266 processor on ESP-01
//dht.setup(DHTPIN, DHTesp::DHT11);// 11 works fine for ESP8266; Gestrichen von Achim Birkner 

float humidity = 50;  // Variablendefinition für Temperatur und Luftfeucht. vom Sensor 
float temp_f =20;
String webString = "";   // String to display
String webMessage = "";
// Generally, you should use "unsigned long" for variables that hold time to handle rollover
unsigned long previousMillis = 0;        // will store last temp was read
long interval = 20000;              // interval at which to read sensor

int tempw= 10 ;
int humiw = 40;


void printLocalTime()
{
  //Serial.println("printLocalTime");
  //String Printloctime ;
  time_t rawtime;
  struct tm * timeinfo;

  time (&rawtime);
  timeinfo = localtime (&rawtime);

  strftime (buffer,80," %d %B %Y %H:%M:%S ",timeinfo);
  //struct tm timeinfo;
  //time_t now = time(nullptr);
  Serial.println(buffer);
  //Serial.print(ctime(&now));
  //Serial.print(&timeinfo, " %d %B %Y %H:%M:%S ");
  //Printloctime = buffer ; 

  //return Printloctime;
  //delay(1000);
}

String loglTime()
{
  //Serial.println("printLocalTime");
  
  String strbuffer;
  time_t rawtime;
  struct tm * timeinfo;

  time (&rawtime);
  timeinfo = localtime (&rawtime);

  strftime (buffer,80," %d %B %Y %H:%M:%S ",timeinfo);
  //struct tm timeinfo;
  //time_t now = time(nullptr);
  strbuffer = buffer;
  return strbuffer ;
 
}



///////////////////////////////////////////////////////////////////////////////////
// Öffnen und Schließprozeduren
// Da wir Optokoppler haben, reicht ein normales "LOW" um das Relais zu schließen
// 
// 
///////////////////////////////////////////////////////////////////////////////////
void istNotfall() //Dienemann "Wir brauchen keinen Durchschnittwert, weil die Spitzen entscheidend sind".
{
	if ((windWert >= windNotfall) || (regenWert >= regenNotfall)) //Ab wann wird der notfallwert zurück gesetzt (30 Min?)
{
notfallbedingung = true; 
}	
}

/*void regenEinfahren()//haben wir erstmal weggelassen
{
//digitalWrite (markiseSenkschliessenpin, LOW); Bewusst weggelassen, weil sie es abkann
digitalWrite (markiseHorizschliessenpin, LOW);
digitalWrite (fensterDachschliessenpin, LOW);
digitalWrite (fensterKlappschliessenpin, LOW);
delay (60000);//Wert passt (zeitlich)
markiseSenkzustand = "Markise geschlossen";
markiseHorizzustand = "Markise geschlossen";
}
*/




void Werte() {
 if (markise1) {
 //digitalRead(markiseSenkoeffnenpin) == LOW
 }
}


void notfall()
{
	digitalWrite (markiseSenkschliessenpin, LOW); 
	digitalWrite (markiseHorizschliessenpin, LOW);
	digitalWrite (fensterDachschliessenpin, LOW);
	digitalWrite (fensterKlappschliessenpin, LOW);
    //delay (60000);//Wert passt (zeitlich)
    markiseSenkzustand = "Markise geschlossen";
    markiseHorizzustand = "Markise geschlossen";
  }

void zuWarm()
{
	digitalWrite (markiseSenkschliessenpin, LOW); 
	digitalWrite (markiseHorizschliessenpin, LOW);
	digitalWrite (fensterDachschliessenpin, LOW);
	digitalWrite (fensterKlappschliessenpin, LOW);
    //delay (60000);
    markiseSenkzustand = "geschlossen";
    markiseHorizzustand = "geschlossen";
    fensterDachzustand = "geoeffnet";
	fensterKlappzustand = "geoeffnet";
	//Wollen wir abwarten (15 Min), ob wir uns entschließen, die Fenster auch zu schließen oder nicht?
	//Flag einbauen, damit wir die Funktion nur einmal ausführen!
  }

void zuKalt()
{
    digitalWrite(markiseSenkoeffnenpin, LOW);
	digitalWrite(markiseHorizoeffnenpin, LOW);
	digitalWrite(fensterDachschliessenpin, LOW);
	digitalWrite(fensterKlappschliessenpin, LOW);
	//delay(60000);//Müsste ohne Delay geschehen. Herr Vehmeier hat Lösung vorgeschlagen. 
	markiseSenkzustand = "geoeffnet"; // String müssen wir zu integer o. byte ändern, um auf ihn später reagieren zu können. Gilt auch für Webansicht.
    markiseHorizzustand = "geoeffnet";
	fensterDachzustand = "geschlossen";
	fensterKlappzustand = "geschlossen";
	//Flag definieren.
  }

void zuwarmVormittags() //Weil vormittags nur eine Markise angesteuert werden
{
    digitalWrite(markiseSenkschliessenpin, LOW);
	digitalWrite(markiseHorizoeffnenpin, LOW);
	digitalWrite(fensterDachoeffnenpin, LOW);
	digitalWrite(fensterKlappoeffnenpin, LOW);
	//delay(60000);
	markiseSenkzustand = "geschlossen";
    markiseHorizzustand = "geoeffnet";
	fensterDachzustand = "geoeffnet";
	fensterKlappzustand = "geoeffnet";
  }

// void zuwarmNachmittags ()
//{
// if (temp_f >= zuwarm && notfallbedingung == false && nachmittags == true)
//}
//}
//


// reads the temp and humidity from the DHT sensor and sets the global variables for both
// liest die Temperatur und Luftfeuchtigkeit vom DHT11 Sensor kommend und legt sie in den Variablen ab

float TgetHumidity(){
  // Read humidity (percent); Luftfeuchtigkeitswert einlesen
  float humi= 40;
  humi =humiw;
  return humi;
}

 float TgetTemperature() {
   float temp=20;
    temp  =tempw;
   return temp;
  }  



void gettemperature() {
  Serial.println("-- gettemperature Start:");
  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (it's a very slow sensor)

 // humidity = dht.getHumidity();          // Read humidity (percent); Luftfeuchtigkeitswert einlesen
 // temp_f = dht.getTemperature();     // Read temperature as Fahrenheit; Temperatur in Fahrenheit einlesen

  //humidity = TgetHumidity();          // Read humidity (percent); Luftfeuchtigkeitswert einlesen
  //temp_f = TgetTemperature();  
  
  humidity = humiw;
  temp_f =tempw;
  
  // Check if any reads failed and exit; Checken, ob Lesen gescheitert ist und dann beenden
  if (isnan(humidity) || isnan(temp_f)) {
    Serial.println("Sensordaten konnten nicht gelesen werden");
    return;
  }

   if (notfallbedingung )
  {
  	notfall();
    Serial.println( "Notfall eingetreten");
  }
  else if ((temp_f > zuwarm) && (notfallbedingung == false)) /* && flag == xxx*/
  {
  	zuWarm();
    Serial.println( "zuWarm(); ");
  } 
    else if ((temp_f < zukalt) && (notfallbedingung == false))
  {
  	zuKalt();
     Serial.println( "zuKalt(); ");
  } 
  else if (temp_f >= zuwarm && notfallbedingung == false /*&& vormittags == true*/)
  {
  	zuwarmVormittags();
    Serial.println( "zuwarmVormittags(); ");
  }
  else if (regenWert >= 1)
  {
  	zuwarmVormittags();
     Serial.println( " zuwarmVormittags()");
  }

//if (temp_f >= zuwarm && notfallbedingung == false && nachmittags == true)
//}
//}

/*
if (temp_f >= zuwarm){
  markise1 = true; Serial.println( "Markise1 zu");
  fenster1 = false;Serial.println( "Fenster1 auf");
  markise2 = true; Serial.println( "Markise2 zu");
  fenster2 = false;Serial.println( "Fenster2 auf");
}

if (temp_f <= zukalt){
  markise1 = false;Serial.println( "Markise1 auf");
  fenster1 = true; Serial.println( "Fenster1 zu");
  markise2 = false;Serial.println( "Markise2 auf");
  fenster2 = true; Serial.println( "Fenster2 zu");
}

*/
 if (markise1)
    Serial.println( "Markise1 ist zu");
  else
   Serial.println( "Markise1 offen");
 if (markise2)
   Serial.println( "Markise2 ist zu");
  else
   Serial.println( "Markise2 offen");
  
 if (fenster1)
   Serial.println( "Fenster1 ist zu");
  else
   Serial.println( "Fenster1 auf");
  
 if (fenster2)
    Serial.println( "Fenster2 ist zu");
  else
   Serial.println( "Fenster2  auf");   



 //Serial.println(tempw);
 Serial.println(temp_f);
 //Serial.println(humiw); 
 Serial.println(humidity);
 Serial.println("-- end gettemperature ");
 }
	

/////////////////////////////////////////////////

void clearDataFile() // Alle gespeicherten Messdaten löschen
{
  File f = SPIFFS.open("/"+dfName, "w");
  if (!f) {
    Serial.println("Datei mit den Messdaten klonnte nicht zum Löschen geöffnet werden");
  }
  else
  {
    Serial.println("-- Datei mit Messdaten gelöscht =========");
    f.close();
  }
}

///////////////////////////////////////////////////////////////////////////////////
// removes the first line of a file by writing all data except the first line
// to a new file. The old file is deleted and new file is renamed.
// Löscht die erste Zeile einer Datei, indem all die Daten außer die erste Zeile in 
// eine neue Datei geschrieben werden. Die alte Datei wird gelöscht und die neue umbenannt.
///////////////////////////////////////////////////////////////////////////////////

void removeFileLine(String fi)
{
  File original = SPIFFS.open("/"+fi, "r");
  if (!original) {

    Serial.println("original data file open failed");
  }

  File temp = SPIFFS.open("/tempfile.txt", "w");
  if (!temp) {

    Serial.println("temp data file open failed");
  }

  Serial.println("------ Removing Data Lines ------");

  //Lets read line by line from the file
  for (int i = 0; i < maxFileData; i++) {

    String str = original.readStringUntil('\n'); // read a line
    if (i > 0) { // skip writing first line to the temp file

      temp.println(str);
       // Serial.println(str); // uncomment to view the file data in the serial console
    }
  }

  int origSize = original.size();
  int tempSize = temp.size();
  temp.close();
  original.close();

  Serial.print("size orig: "); Serial.print(origSize); Serial.println(" bytes");
  Serial.print("size temp: "); Serial.print(tempSize); Serial.println(" bytes");

  if (! SPIFFS.remove(dfName))
    Serial.println("Remove file failed");


  if (! SPIFFS.rename("tempfile.txt", dfName))
    Serial.println("Rename file failed");
  // dataLines--;
}

//////////////////////////////////////////////////////////////////////
// writes the most recent variable values to the data file 
// Schreibt die letzten Messwerte in die Datendatei
//////////////////////////////////////////////////////////////////////

void updateDataFile()
{
  Serial.println("dataLines: ");
  Serial.println(dataLines);
  if (dataLines >= maxFileData)
  {
    removeFileLine(dfName);
  }
  ///////
  File f = SPIFFS.open("/"+dfName, "a");
  if (!f) {

    Serial.println("data file open failed");
  }
  else
  {
    Serial.println("====== Writing to data file =========");
    //
    Serial.print("Data:");
    Serial.print(markiseSenkzustand);  Serial.print(":");
    Serial.print(temp_f);  Serial.print( ",");  Serial.println(humidity);

    f.print(markiseSenkzustand); f.print(":");
    f.print(temp_f); f.print( ","); f.println(humidity);
   // Serial.println("Data file updated");
    f.close();
  }
/*
  Serial.print("millis: ");
  Serial.println(millis());
*/
}

//////////////////////////////////////////////////////////////////////////////
// reads the data and formats it so that it can be used by google charts    
// Liest die Daten aus der Datei und bereitet sie für google charts auf.
//////////////////////////////////////////////////////////////////////////////

String readDataFile()
{
  String returnStr = "";
  File f = SPIFFS.open("/"+dfName, "r");

  if (!f)
  {
    Serial.println("Data File Open for read failed.");

  }
  else
  {
    Serial.println("----Reading Data File-----");
    dataLines = 0;

    while (f.available()) {

      //Lets read line by line from the file
      dataLines++;
      String str = f.readStringUntil('\n');
      String switchState =  str.substring(0, str.indexOf(":")  );
      /*
          String tempF = str.substring(str.indexOf(":") + 1, str.indexOf(",")  );
        //  String humid = str.substring(str.indexOf(",") + 1 );
        //    String milliSecs = str.substring(str.indexOf("~") + 1 , str.indexOf("~"));
        //   Serial.println(tempF);
        //   Serial.println(humid);
        //  Serial.println(str);
      */

      returnStr += ",['" + switchState + "'," + str.substring(str.indexOf(":") + 1) + "]";
    }
    f.close();
  }
  
  return returnStr;

}

////////////////////////////////////////////////////////////////////////////////////
//      creates the HTML string to be sent to the client                          
//      Hier wird die HTML Datei generiert, die dann über den Browser anzeigbar ist.
////////////////////////////////////////////////////////////////////////////////////

void setHTML()
{
 String swebString;
  Serial.println("setHTML: ");
     
  webString = "<html><head>\n";
  webString += "<meta charset=\"utf-8\"> \n";
  webString += "<meta http-equiv=\"refresh\" content=\"60;url=http://" + WiFi.localIP().toString() + "\"> \n";
  webString += "<title>Wintergarten </title> \n";
  ///////////// google charts script
  if (usegoogle) {
 
  webString += "<script type=\"text/javascript\" src=\"https://www.gstatic.com/charts/loader.js\"></script> \n";
  webString += "   <script type=\"text/javascript\"> \n";
  webString += "    google.charts.load('current', {'packages':['corechart','gauge']}); \n";
  webString += "    google.charts.setOnLoadCallback(drawTempChart); \n";
  webString += "    google.charts.setOnLoadCallback(drawHumidChart); \n";
  webString += "    google.charts.setOnLoadCallback(drawChart); \n ";

  // draw temp guage
  webString += "   function drawTempChart() { \n";
  webString += "      var data = google.visualization.arrayToDataTable([ \n";
  webString += "        ['Label', 'Value'], ";
  webString += "        ['Temp',  ";
  webString += temp_f;
   Serial.println(tempw);
  webString += " ], ";
  webString += "       ]); \n";
  // setup the google chart options here
  webString += "    var options = {";
  webString += "      width: 250, height: 150,";
  webString += "      min: -10, max: 120,";
  webString += "      greenFrom: -10, greenTo: " + String(zuwarm) + ",";
  webString += "      yellowFrom: " + String(zuwarm) + ", yellowTo: " + String(zukalt) + ",";
  webString += "      redFrom: " + String(zukalt) + ", redTo: 120,";
  webString += "       minorTicks: 5";
  webString += "    }; \n";
  webString += "   var chart = new google.visualization.Gauge(document.getElementById('chart_divTemp')); \n";
  webString += "  chart.draw(data, options); \n";
  webString += "  } \n";

  // draw humidity guage
  webString += "   function drawHumidChart() { \n";
  webString += "      var data = google.visualization.arrayToDataTable([ \n";
  webString += "        ['Label', 'Value'], ";
  webString += "        ['Humidity',  ";
  webString += humidity;
  Serial.println(humidity);
  webString += " ], ";
  webString += "       ]); \n";
  // setup the google chart options here
  webString += "    var options = {";
  webString += "      width: 250, height: 150,";
  webString += "      min: 0, max: 100,";
  webString += "      greenFrom: 0, greenTo: 25,";
  webString += "      yellowFrom: 25, yellowTo: 75,";
  webString += "      redFrom: 75, redTo: 100,";
  webString += "       minorTicks: 5";
  webString += "    }; \n";
  webString += "   var chart = new google.visualization.Gauge(document.getElementById('chart_divHumid')); \n";
  webString += "  chart.draw(data, options); \n";
  webString += "  } \n";


  // draw main graph
  webString += "    function drawChart() { \n";

  webString += "     var data = google.visualization.arrayToDataTable([ \n";
  webString += "       ['Hit', 'Temp. C', 'Luftfeuchtigkeit'] ";

  swebString = readDataFile();
  Serial.println(swebString);
  
  webString += readDataFile();
  // open file for reading

  webString += "     ]); \n";
  webString += "     var options = { \n";
  webString += "        title: 'Temperatur/Luftfeuchtigkeit Entwicklung', ";
  webString += "        curveType: 'function', \n";

  webString += "  series: { \n";
  webString += "         0: {targetAxisIndex: 0}, \n";
  webString += "         1: {targetAxisIndex: 1} \n";
  webString += "       }, \n";

  webString += "  vAxes: { \n";
  webString += "         // Adds titles to each axis. \n";
  webString += "         0: {title: 'Temp. in Celsius'}, \n";
  webString += "         1: {title: 'Luftfeuchtigkeit %'} \n";
  webString += "       }, \n";

  webString += "  hAxes: { \n";
  webString += "         // Adds titles to each axis. \n";
  webString += "         0: {title: 'Marikise oeffnen/Markise schliessen'}, \n";
  webString += "         1: {title: ''} \n";
  webString += "       }, \n";

  webString += "         legend: { position: 'bottom' } \n";
  webString += "       }; \n";

  webString += "       var chart = new google.visualization.LineChart(document.getElementById('curve_chart')); \n";

  webString += "       chart.draw(data, options); \n";
  webString += "      } \n";

  ////////////
  webString += "    </script> \n";

  }
  webString += "</head><body>\n";

  webString += "<h1>Wintergartensteuerung</h1>\n";
  webString += "<p>Studieren ab 50 </p>";
 
  webString +=  loglTime();
  
  webString += "<form action=\"http://" + WiFi.localIP().toString() + "/submit\" method=\"POST\">";
  //webString += "<div style=\"color:red\">" + webMessage + "</div>\n";
  webString += "<table style=\"width:800px;\"><tr><td>";
  //webString += "<div>Markise oeffnen ab: &le; " + String((int)zuwarm) + "&deg; C</div>\n";
  //webString += "<div>Markise schliessen ab: &ge; " + String((int)zukalt) + "&deg; C</div>\n";
  webString += "</td><td style=\"text-align:right\">";
  webString += "Markise oeffnen ab (Innentemperatur): &le; <input type='text' value='" + String((int)zuwarm) + "' name='zuwarm' maxlength='3' size='2'><br>\n";
  webString += "Markise schliessen ab (Innentemperatur): &ge; <input type='text' value='" + String((int)zukalt) + "' name='zukalt' maxlength='3' size='2'><br>\n";
  
  webString += "</td><td style=\"text-align:right\">";
  webString += "Spannung Solarpanel (fuer ???): &le; <input type='text' value='0.4' name='markise-oeffnen' maxlength='3' size='2'><br>\n";

  webString += "</td><td style=\"text-align:right\">";
  webString += "Spannung Windsensor (fuer Notfall): &le; <input type='text' value='1.1' name='windNotfall' maxlength='3' size='2'><br>\n";
  
  webString += "</td><td style=\"text-align:right\">";
  //webString += "Abfragerate (Sekunden): <input type='text' value='" +           String((long)interval / 1000) + "' name='sRate' maxlength='3' size='2'><br>\n";
  //webString += "Anzahl der Messwerte im Diagramm: <input type='text' value='" + String((long)maxFileData) + "' name='maxData' maxlength='3' size='2'><br>\n";

  webString += "Abfragerate: <input type='text' value='" +    String((long)interval / 1000) + "' name='sRate' maxlength='3' size='2'><br>\n";
  webString += "Anzahl der werte: <input type='text' value='" + String((long)maxFileData) + "' name='maxData' maxlength='3' size='2'><br>\n";

  webString += "</td><td>";
  webString += "<input type='submit' value='Submit' >";
  webString += "</td></tr></table>\n";
  webString += "</form>\n";
  webString += "<div><a href=\"/\">Refresh</a></div>  ";
  webString += "<div><a href=\"/clear\">Clear Data</a></div> \n";
  
   // Eingabe Meswerte
  webString += "<form action=\"/submdat\" method=\"POST\">";
  webString += "<div style=\"color:red\">" + webMessage + "</div>\n";
  webString += "Messwerte: ";
  webString += "Temperatur: <input type='text' value='"  + String((int)tempw)  + "' name='tempw' maxlength='3' size='2'>\n";
  webString += "Luftfeuchte: <input type='text' value='" + String((int) humiw) + "' name='humiw' maxlength='3' size='2'> \n";
  //webString += "Spannung Solarpanel (fuer ???): &le; <input type='text' value='0.4' name='markise-oeffnen' maxlength='3' size='2'><br>\n";
  //webString += "Spannung Windsensor (fuer Notfall): &le; <input type='text' value='1.1' name='windNotfall' maxlength='3' size='2'><br>\n";
  webString += "<input type='submit' value='Senden' >";
  webString += "</form>\n";
  // ende Eingabe Messwerte
  
  //Anzeige der Messwerte
  webString += "<table style=\"width:800px;\"> <tr><td>";
  webString += "<div style=\"width:300px\"><b>Status: </b></div>\n";
 // webString += "<div>Temperatur: " + String(temp_f, 2) + "&deg; C</div>\n";
  webString += "<div>Temperatur: " + String((int)tempw) + "&deg; C</div>\n";
  webString += "<div>Luftfeuchtigkeit: " + String((int)humidity) + "%</div> \n";

  // Anpassen und bessere Abfrage überlegen, ob Markise offen oder geschlossen
  if (markise1)
    webString += "<div>Markise1 ist zu</div>";
  else
    webString += "<div>Markise1 offen</div>";
   if (markise2)
    webString += "<div>Markise2 ist zu</div>";
  else
    webString += "<div>Markise2 offen</div>";
  if (fenster1)
    webString += "<div>Fenster1 ist zu</div>";
  else
    webString += "<div>Fenster1 auf</div>";
     if (fenster2)
    webString += "<div>Fenster2 ist zu</div>";
  else
    webString += "<div>Fenster2  auf</div>";     

// Google Graphik
 if (usegoogle) {

  webString += "<div>Data Lines: " + String((int)dataLines) + "</div> \n";
  //  webString += "<div>Total On Time: " + String( ((onCount * interval) / 1000) / 60 ) + " minutes</div> \n";
  //webString += "<div>Sample Rate: " + String(interval / 1000) + " seconds</div> \n";
  webString += "</td>";
  
   webString += "<td><div id=\"chart_divTemp\" style=\"width: 250px;\"></div>\n";
  webString += "</td><td>";
  webString += "<div id=\"chart_divHumid\" style=\"width: 250px;\"></div>\n";
  webString += "</td></tr></table>\n";
 
  webString += "<div id=\"curve_chart\" style=\"width: 1000px; height: 500px\"></div> \n";
 
 }
 
  webString += "</body></html>\n";
}

//////////////////////////////////
///  used for error checking   
///  Fehlersuche (Funktion unklar, A.B.) 
//////////////////////////////////

boolean isValidNumber(String str) {
  for (byte i = 0; i < str.length(); i++)
  {
    if (isDigit(str.charAt(i))) return true;
  }
  return false;
}

////////////////////////////////////////////////////////////////////
// handler for web server request: http://IpAddress/submit
// Prozedur für Submit Variablenübertrag per http
////////////////////////////////////////////////////////////////////






 void handle_submdat() {
 Serial.println("submdat: ");
  webMessage = "";
   
  if (server.args() > 0 ) {
    for ( uint8_t i = 0; i < server.args(); i++ ) {

      if (server.argName(i) == "tempw") {

        if (server.arg(i) != "")
        {
          if (isValidNumber(server.arg(i)) ){
            tempw = server.arg(i).toInt();
             Serial.print("tempw: ");Serial.println(tempw);
          }else
            webMessage += "";
        }
        else
          webMessage += "";
      }
      if (server.argName(i) == "humiw") {

        if (server.arg(i) != "")
        {
          if (isValidNumber(server.arg(i)) ){
            humiw = server.arg(i).toInt();
            Serial.print("humiw: ");Serial.println(humiw);
          }else
            webMessage += "";

        }
        else
          webMessage += "";
      }


          
      }
   
     
  }  
   
  istNotfall();
    gettemperature();
    Serial.print("Temp: ");
    Serial.println(temp_f);
    Serial.print("Humidity: ");
    Serial.println(humidity);

    updateDataFile();
    readDataFile();
      
  //gettemperature();
  setHTML();
  server.send(200, "text/html", webString);            // send to someones browser when asked

  //delay(100);
}
//  Ende submdat 


 void handle_submit() {
 Serial.println("submit: ");
  webMessage = "";
  int zukaltWeb = 0;
  int zuwarmWeb = 0;
  long sRate = 0;
  int maxData = 0;

  if (server.args() > 0 ) {
    for ( uint8_t i = 0; i < server.args(); i++ ) {

      if (server.argName(i) == "zuwarm") {

        if (server.arg(i) != "")
        {
          if (isValidNumber(server.arg(i)) ){
            zukaltWeb = server.arg(i).toInt();
             Serial.print("zukaltWeb: ");Serial.println(zukaltWeb);
          }else
            webMessage += "Der Wert zum Markise-Öffnen muss ein numerischer Wert sein<br>";
        }
        else
          webMessage += "Ein Wert zum Markise-Öffnen MUSS angegeben werden<br>";
      }

      if (server.argName(i) == "zukalt") {

        if (server.arg(i) != "")
        {
          if (isValidNumber(server.arg(i)) ){
            zuwarmWeb = server.arg(i).toInt();
            Serial.print("zuwarmWeb: ");Serial.println(zuwarmWeb);
          }else
            webMessage += "Der Wert zum Markise-Schliessen muss ein numerischer Wert sein<br>";

        }
        else
          webMessage += "Ein Wert zum Markise-Schliessen MUSS angegeben werden<br>";
      }


      if (server.argName(i) == "sRate") {

        if (server.arg(i) != "")
        {
          if (isValidNumber(server.arg(i)) ){ 
            sRate = server.arg(i).toInt();
            Serial.print("sRate: ");Serial.println(sRate);
           }else
            webMessage += "Sample Rate muss ein numerischer Wert sein<br>";
        }
        else
          webMessage += "Sample Rate MUSS angegeben werden<br>";
      }

      if (server.argName(i) == "maxData") {

        if (server.arg(i) != "")
        {
          if (isValidNumber(server.arg(i)) ) {
            maxData = server.arg(i).toInt();
            Serial.print("maxData: ");Serial.println(maxData);
          }else
            webMessage += "Maximale Datenreihen muss ein numerischer Wert sein<br>";
        }
        else
          webMessage += "Maximale Datenreihen MUSS angeben werden<br>";
      }

    }
   
   // if (zuwarmWeb <= zukaltWeb)
    if ( zukaltWeb  <=  zuwarmWeb  )
      webMessage += "Der Wert zum Markise-Oeffnen muss NIEDRIGER sein als der Wert zum Markise-Schliessen<br>  (zuwarmWeb <= zukaltWeb)";
   
    if (sRate < 10)
      webMessage += "Sample Rate groesser oder gleich 10 sein<br>";

    if (maxData < 10 || maxData > 300)
      webMessage += "Max Datenreihen muss zwischen 10 und 300 sein<br>";
   
    if (webMessage == "")
    {
      zuwarm= zuwarmWeb;
      zukalt = zukaltWeb;
      interval = sRate * 1000;
      maxFileData = maxData;
  /*
      ///////
      File f = SPIFFS.open("/"+fName, "w");
      if (!f) {

        Serial.println("file open for properties failed");
      }
      else
      {
        Serial.println("====== Writing to config file =========");

        f.print(zuwarm); f.print( ","); f.print(zukalt);
        f.print("~"); f.print(sRate);
        f.print(":"); f.println(maxData);
        Serial.println("Properties file updated");
        f.close();
      }
    */
       Serial.print("Daten: ");  
       Serial.print(zuwarm); Serial.print( ","); Serial.print(zukalt);
       Serial.print("~"); Serial.print(sRate);
       Serial.print(":");Serial.println(maxData);


    
    }
   
  }
 

  if (webMessage == "") {
    webMessage = "Settings Updated";
  }


  gettemperature();

  setHTML();
  server.send(200, "text/html", webString);            // send to someones browser when asked

  //delay(100);
}
//  Ende submit    für Wintergarten 

void handle_google() {
   Serial.println("change usegoogle: ");  
  if(usegoogle) {
    usegoogle = false; 
  } else {
    usegoogle = true;
  }
 
  webMessage = "";
  setHTML();
  server.send(200, "text/html", webString);            // send to someones browser when asked

  delay(100);
}


////////////////////////////////////////////////////////////
// handler for web server request: http://IpAddress/      
// Prozedur für Anfrage an web server per http 
////////////////////////////////////////////////////////////

void handle_root() {
  printLocalTime();
  gettemperature();       // read sensor
  webMessage = "";
  setHTML();
  server.send(200, "text/html", webString);            // send to someones browser when asked

  delay(100);
}

void handle_clear()  {
    // handler for http://iPaddress/clear

    // deletes all the stored data for temp and humidity
    clearDataFile();

    webMessage = "Data Cleared";

    // read the DHT and use new values to start new file data
    gettemperature();
    updateDataFile();
    setHTML(); // this will set the webString varialbe with HTML
    server.send(200, "text/html", webString);            // send to someones browser when asked
    delay(100);

  }
  
void EAInit() {
  Serial.println("EAInit Start:");
  //  dht.setup(DHTPIN, DHTesp::DHT11);
  
  //hier müsste ich Aus und Eingänge defieren. Relayshield braucht MASSE zum Schließen
  digitalWrite (markiseSenkoeffnenpin, HIGH);
  digitalWrite (markiseSenkschliessenpin, LOW); 
  digitalWrite (markiseHorizoeffnenpin, HIGH);
  digitalWrite (markiseHorizschliessenpin, LOW);
  digitalWrite (fensterDachoeffnenpin, HIGH);
  digitalWrite (fensterDachschliessenpin, LOW);
  digitalWrite (fensterKlappoeffnenpin, HIGH);
  digitalWrite (fensterKlappschliessenpin, LOW);
  
  Serial.println ("Mache gerade alles zu."); //auch auf Display ausgeben.
  //delay (90000); //"Das kann MÄCHTIG VERWIRREN"!!!! MAN MUSS BESCHEID SAGEN!!!
  
  //delay(10);
  ///////////////////
  // SPIFFS.format(); // uncomment to completely clear data; Bleibt auskommentiert.
  //SPIFFS.begin(true);
 
  if(SPIFFS.begin())
  {
    Serial.println("SPIFFS Initialisierung....OK");
  }
  else
  {
    Serial.println("SPIFFS Initialisierung...Fehler!");
  }
  File f = SPIFFS.open("/"+fName, "r");

  if (!f) {
    // no file exists so lets format and create a properties file
    Serial.println("Please wait 30 secs for SPIFFS to be formatted");

    SPIFFS.format(); 

    Serial.println("Spiffs formatted");

    f = SPIFFS.open("/"+fName, "w");
    if (!f) {

      Serial.println("properties file open failed"); //FEHLER AB HIER 
    }
    else
    {
      // write the defaults to the properties file
      Serial.println("====== Writing to properties file =========");

      f.print(zuwarm); f.print( ","); f.print(zukalt);
      f.print("~"); f.print(interval / 1000);
      f.print(":"); f.println(maxFileData);
      Serial.println("Properties file created");
      dataLines = 1;
      f.close();
    }

  }
  else
  {
    // if the properties file exists on startup,  read it and set the defaults
    Serial.println("Properties file exists. Reading.");

    while (f.available()) {

      //Lets read line by line from the file
      String str = f.readStringUntil('\n');

      String loSet = str.substring(0, str.indexOf(",")  );
      String hiSet = str.substring(str.indexOf(",") + 1, str.indexOf("~") );
      String sampleRate = str.substring(str.indexOf("~") + 1, str.indexOf(":") );
      String maxData = str.substring(str.indexOf(":") + 1 );

      Serial.println(loSet);
      Serial.println(hiSet);
      Serial.println(sampleRate);
      Serial.println(maxData);

      zuwarm= loSet.toInt();
      zukalt = hiSet.toInt();
      interval = sampleRate.toInt() * 1000;
      maxFileData = maxData.toInt();
    }

    f.close();
  }
  
  }

///////////////////////////////////////
// first funtion to run at power up 
// Setup. Passiert als erstes nach Start des ESP32
//////////////////////////////////////

void setup(void)
{

  // You can open the Arduino IDE Serial Monitor window to see what the code is doing
  Serial.begin(9600);  // Serial connection from ESP-01 via 3.3v console cable

//Zeit Korektur

configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
   delay(1000);
printLocalTime();



  EAInit();
  
  // Connect to WiFi network
   WiFi.begin(ssid, password);
  //WiFi.config(IPAddress(192, 168, 1, 8), IPAddress(192, 168, 1, 1), IPAddress(255, 255, 255, 0));
  Serial.print("\n\r \n\rWorking to connect");
  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("DHT Server");
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());

  //dht.begin();           // initialize temperature sensor; Gestrichen von A.B.
  delay(10);

  // now lets read the data file mainly to set the number of lines
  readDataFile();
  // now read the DHT and set the temp and humidity variables
  gettemperature();
  // update the datafile to start a new session
  updateDataFile();

  // web client handlers
  server.on("/", handle_root);
  server.on("/submit", handle_submit);
  server.on("/submdat", handle_submdat);
  server.on("/clear", handle_clear);
  server.on("/google", handle_google);

    // start the web server
  server.begin();
  Serial.println("HTTP server started");

}

////////////////////////////////////////////////////////////////////////////////

void loop(void)
{
/*
  // check timer to see if it's time to update the data file with another DHT reading
  // Timer checken, ob es Zeit ist, die Datendatei mit neuen Messdaten zu aktualisieren.
  unsigned long currentMillis = millis();

  // cast to unsigned long to handle rollover
  if ((unsigned long)(currentMillis - previousMillis) >= interval )
  {
    // save the last time you read the sensor
    previousMillis = currentMillis;
	istNotfall();
    gettemperature();
    Serial.print("Temp: ");
    Serial.println(temp_f);
    Serial.print("Humidity: ");
    Serial.println(humidity);

    updateDataFile();
    readDataFile();
  }
*/
  server.handleClient();

}