Automatic Transfer Switch (ATS) with Web Server

void setup() {
  while (!Serial) { }       // wait for serial port to connect. Needed for native USB port only
  Serial.begin(9600);
  PgmPrintln("ATS Version ");
  Serial.println(version);

  // LCD Initalisieren
  lcd.begin(LCD_Cols, LCD_Rows);
  delay(2);
  LCD_Head();
  LCD_Status(Status);

  // Initalisieren der drei Power Meter
  while (!Serial1) { }
  pzem1 = new PZEM004T(&Serial1);
  pzem1->setAddress(pip1);
  while (!Serial2) { }
  pzem2 = new PZEM004T(&Serial2);
  pzem2->setAddress(pip2);
  while (!Serial3) { }
  pzem3 = new PZEM004T(&Serial3);
  pzem3->setAddress(pip3);

  // Digital-Eingnge
  pinMode(PIN_BUTTON, INPUT_PULLUP);    // Menbutton
  attachInterrupt(digitalPinToInterrupt(PIN_BUTTON), InterruptButton, LOW);
  pinMode(PIN_PHASE_NETZ, INPUT_PULLUP);// Phasenkontrolle Netzversorger
  pinMode(PIN_PHASE_GEN, INPUT_PULLUP); // Phasenkontrolle Generator
  pinMode(PIN_OEL, INPUT);              // Digital-Eingang Kontrolle ldruck LED grn

  // Analog-Eingnge
  pinMode(BAT_INPUT, INPUT);            // Batteriespannungsmessung (Spannungsteiler (10K - 100k)
  pinMode(ZUENDSCHLOSS, INPUT);         // Spannungsmessung Zndschloss (Off / Standby) (10K - 100k)

  // Digital Ausgnge
  pinMode(PIN_BUZZER, OUTPUT);          // Digitalausgang Pieper
  pinMode(SD_SELECT, OUTPUT);
  digitalWrite(SD_SELECT, HIGH);        // disable SD card
  pinMode(ETHERNET_SELECT, OUTPUT);
  digitalWrite(ETHERNET_SELECT, HIGH);  // disable Ethernet
  pinMode(10, OUTPUT);                  // set the SS pin as an output (necessary!)
  digitalWrite(10, HIGH);               // but turn off the W5100 chip!

  // Umschalt Relais sind LOW-Active!
  pinMode(REL_NETZ, OUTPUT);            // Relais Netzversorger
  digitalWrite(REL_NETZ, HIGH);
  pinMode(REL_GEN, OUTPUT);             // Relais Generator
  digitalWrite(REL_GEN, HIGH);

  // Generator Relais sind HIGH-Active!
  pinMode(PIN_Z_EIN, OUTPUT);           // Zndschloss "Ein"
  digitalWrite(PIN_Z_EIN, LOW);
  pinMode(PIN_Z_START, OUTPUT);         // Zndschloss "Start"
  digitalWrite(PIN_Z_START, LOW);

  SPI.begin();

  if (!SD.begin(SD_SELECT)) {
    while (1) {
      PgmPrintln("SD.begin() failed");
      LCD_Status(11); // "SD-Card Fehler"
    }
  }
  delay(1);

  // INI-File von SD-Card einlesen und Variabeln setzen.
  ReadIniFile();

  // Start the I2C interface
  Wire.begin();
  delay(1);

  // Start the Ethernet connection and the server:
  Ethernet.begin(mac, ip, dns, gateway, subnet);
  server.begin();
  delay(1000); // Ethernet Start abwarten.
  // Check for Ethernet hardware present
  PgmPrintln("Waiting for Network");

  if (Ethernet.hardwareStatus() == EthernetNoHardware) {
    PgmPrintln("Ethernet shield was not found.  Sorry, can't run without hardware. :(");
    while (true) {
      LCD_Status(7); // "Kein Netzwerk"
      delay(1); // do nothing, no point running without Ethernet hardware
    }
  }

  // Teste Ethernet Kabel Verbindung
  testLink();
  while (!etherStatus) {
    LCD_Status(7); // Kein Netzwerk
    testLink();
  }

  // verbinde zum MQTT Brooker
  if (MQTTenable) {
    MQTT.begin(MQTTServer, MQTTnet);
    MQTT.onMessage(MQTTmessageReceived);
    // Last will and testament
    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[21])));   // /get/status
    char topic[bufferLen] = ""; strcat(topic, MQTTTopic); strcat(topic, buffer);
    MQTT.setWill(topic, "Offline", true, 0);
    MQTTconnect();
  }
  
  LCD_Status(10);  // LCD-Status: Initalisierung

  // Webserver starten
  PgmPrintln("Webserver starting at: ");
  Serial.print(Ethernet.localIP());
  PgmPrintln(":80");

  // NTP-Eintrag aus INI-Datei in IP-Adresse auflsen (Egal ob IP oder Hostname)
  DNSClient dns;
  dns.begin(Ethernet.dnsServerIP());
  dns.getHostByName(ntp, timeServer);

  // Zeit mit Internetzeit Synchronisieren
  Udp.begin(localPort);
  PgmPrintln("Waiting for Timesync...");
  delay(1000); // Ethernet Start abwarten.
  syncTime();
  Serial.println(showDate());
  Serial.println(showTime());
  
  // set date time callback function
  SdFile::dateTimeCallback(dateTime);
  
  // Freien RAM ermitteln
  // ram = (String) FreeRam();
  ram = FreeRam();
  Serial.print(ram);
  PgmPrintln(" Bytes RAM free");

  // Auf Netzbetrieb schalten
  digitalWrite(REL_GEN, HIGH);
  digitalWrite(REL_NETZ, LOW);
  delay(switchdelay * 1000);
  digitalWrite(REL_NETZ, HIGH);
  page = 1;

  // Zndung an?
  int value = 0;
  value = analogRead(ZUENDSCHLOSS);
  if (value > 0) {
    zuendung = true;
  } else {
    zuendung = false;
  }
  
  if (HCenable) { Serial.println(F("Home-Controll: aktive")); } else { Serial.println(F("Home-Controll: not aktive")); }
  if (VZenable) { Serial.println(F("Volkzaehler: aktive")); } else { Serial.println(F("Volkzaehler: not aktive")); }
  if (MQTTenable) { Serial.println(F("MQTT: aktive")); } else { Serial.println(F("MQTT: not aktive")); }
  
  CheckState();
  Webserver();
  sendEmail(13);
  piep();
  Status = 0;
  PgmPrintln("READY");
}

void CheckState() {
  unsigned long currentMillis = millis();
  noInterrupts();

  // Freien Speicher berechnen
  ram = FreeRam();
  
  // Temepraturwerte holen
  GetTemp(&t_data);

  // Stromwerte holen
  GetCurrent(&p_data);
  Leistung = p_data.L1_Leistung + p_data.L2_Leistung + p_data.L3_Leistung;


  // Zum VZ puschen
  unsigned long interval = 1000;  // 1sec "delay"
  if (millis() - VZTime > interval )  {
    PushVZ(VZServer, VZRequest, UUID, Leistung);
    VZTime = millis(); 
  }

  if (Leistung > 999) {
    Leistung = Leistung / 1000;
    StrLeistung = form(String(Leistung, 2) + " KW", 6);
  } else {
    StrLeistung = form(String(Leistung, 0) + " W", 6);
  }
  
  // zum MQTT Broker pushen
  if (MQTTenable) {  
    // mqtt_table[0-3] = subsriber Topics
    
    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[4])));
    MQTT.publish(String(MQTTTopic) + (String) buffer, StrLeistung);
    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[5])));
    MQTT.publish(String(MQTTTopic) + (String) buffer, String(Status));
    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[6])));
    MQTT.publish(String(MQTTTopic) + (String) buffer, String(ram));
    
    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[7])));
    MQTT.publish(String(MQTTTopic) + (String) buffer, String(p_data.L1_Leistung));
    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[8])));
    MQTT.publish(String(MQTTTopic) + (String) buffer, String(p_data.L1_Strom));
    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[9])));
    MQTT.publish(String(MQTTTopic) + (String) buffer, String(p_data.L1_Spannung));

    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[10])));
    MQTT.publish(String(MQTTTopic) + (String) buffer, String(p_data.L2_Leistung));
    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[11])));
    MQTT.publish(String(MQTTTopic) + (String) buffer, String(p_data.L2_Strom));
    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[12])));
    MQTT.publish(String(MQTTTopic) + (String) buffer, String(p_data.L2_Spannung));

    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[13])));
    MQTT.publish(String(MQTTTopic) + (String) buffer, String(p_data.L3_Leistung));
    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[14])));
    MQTT.publish(String(MQTTTopic) + (String) buffer, String(p_data.L3_Strom));
    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[15])));
    MQTT.publish(String(MQTTTopic) + (String) buffer, String(p_data.L3_Spannung));
    
    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[16])));
    MQTT.publish(String(MQTTTopic) + (String) buffer, String(t_data.SysTemperatur));
    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[17])));
    MQTT.publish(String(MQTTTopic) + (String) buffer, String(t_data.MotorTemperatur));
    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[18])));
    MQTT.publish(String(MQTTTopic) + (String) buffer, String(t_data.AussenTemperatur));

    
    // Netzbetrieb
    if (Status==0) { 
      strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[19])));   // /get/betrieb
      MQTT.publish(String(MQTTTopic) + (String) buffer, "netz");
    }
    
    // Generatorbetrieb
    if (Status==1) { 
      strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[19])));   // /get/betrieb
      MQTT.publish(String(MQTTTopic) + (String) buffer, "generator");
    }
    
    // Generator luft
    if (Status==1) { // Generatorbetrieb
      strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[20])));   // /get/generator
      MQTT.publish(String(MQTTTopic) + (String) buffer, F("start"));
    }
    if (Status==18) { // Generator luft
      strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[20])));   // /get/generator
      MQTT.publish(String(MQTTTopic) + (String) buffer, F("start"));
    }

    // Generator luft nicht
    if (Status==0) {  // Netzbetrieb
      strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[20])));   // /get/generator
      MQTT.publish(String(MQTTTopic) + (String) buffer, F("stop"));
    }
    if (Status==3) {  // Strung Generator
      strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[20])));   // /get/generator
      MQTT.publish(String(MQTTTopic) + (String) buffer, F("stop"));
    }
    if (Status==4) {  // Strung Manuell
      strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[20])));   // /get/generator
      MQTT.publish(String(MQTTTopic) + (String) buffer, F("stop"));
    }

    for (int i=0; i<=MaxStatus; i++) {
      if (i==Status) {
        strcpy_P(buffer, (char *)pgm_read_word(&(status_table[i])));   // Lesbaren Status pushen
        MQTT.publish(String(MQTTTopic) + F("/get/status"), (String) buffer);
      }
    }

    if (zuendung) {
      if (Status == 1 || Status == 18) {
        MQTT.publish(String(MQTTTopic) + F("/get/generator"), F("Ein"));
      } else {
        MQTT.publish(String(MQTTTopic) + F("/get/generator"), F("Standby"));
      }
    } else {
      MQTT.publish(String(MQTTTopic) + F("/get/generator"), F("Aus"));
    }

    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[22])));   // /get/version
    MQTT.publish(String(MQTTTopic) + (String) buffer, version);

    strcpy_P(buffer, (char *)pgm_read_word(&(mqtt_table[23])));   // /get/batterie
    MQTT.publish(String(MQTTTopic) + (String) buffer, ConvSeperator(GeneratorBatterie));

  }

  // Sende keine E-Mail whrend der Initalisierung
  // Zndung an?

  int value = 0;
  value = analogRead(ZUENDSCHLOSS);
  if (value > 0) {
    if (!zuendung) {
      zuendung = true;
      sendEmail(17);
    }
  } else {
    if (zuendung) {
      zuendung = false;
      sendEmail(18);
    }
  }

  //Batteriespannung holen
  genbat = GetBatteryVoltage();
  GeneratorBatterie = String(genbat, 1);
  if (genbat < minbatvoltage) {
    if (!batlow) {
      sendEmail(15);
    }
    batlow = true;
  } else {
    batlow = false;
  }

  // Alles LOW-Active!
  // HIGH = Strom ausgefallen

  // Netzwiederkehr bevor Timeout Netzausfall
  if (!digitalRead(PIN_PHASE_NETZ) && Status == 8) {
    piep();
    page = 1;
    Status = 0; //  "Netzbetrieb"
    timeout = 0;
    LCD_Status(Status);
    previousMillis = 0;
    sendEmail(9);
    PgmPrintln("Netzwiederkehr bevor Timeout Netzausfall");
  }

  // Netzausfall bevor Timeout Netzwiederkehr
  if (digitalRead(PIN_PHASE_NETZ) && Status == 9) {
    piep();
    page = 1;
    Status = 1; // "Generatorbetrieb"
    timeout = 0;
    LCD_Status(Status);
    previousMillis = 0;
    sendEmail(8);
    PgmPrintln("Netzausfall bevor Timeout Netzwiederkehr");
  }

  // Netzausfall im Status "Netzbetrieb" oder "Netztrennung in..."
  if (digitalRead(PIN_PHASE_NETZ) && (Status == 0 || Status == 8)) {
    if (previousMillis == 0) previousMillis = currentMillis;
    if (Status == 0) {
      page = 1;
      Status = 8; // "Netztrennung"
      sendEmail(Status);
      Alert(HCServer, HCRequest, HCLoss);
      PgmPrintln("Netzausfall im Status Netzbetrieb, Countdown gestartet.");
      piep();
    }
    timeout = lostmain * 60 - ((currentMillis - previousMillis) / 1000);
    LCD_Status(Status);

    if (timeout <= 0) {
      previousMillis = 0;
      piep();
      PgmPrintln("Netzausfall!");
      Alert(HCServer, HCRequest, HCStart);
      if (Generator(ON)) {      // Wenn Generator gestartet...
        if (!digitalRead(PIN_PHASE_GEN)) {  // ...und alle drei Phasen vorhanden...
          Status = 1; // "Generatorbetrieb"
          LCD_Status(Status);
          SwitchGeneratorbetrieb(); // ...dann Umschalten auf Generatorbetrieb.
          sendEmail(10);
          PgmPrintln("Generator gestartet, Umschalten auf Generatorbetrieb.");
        } else { // Generator liefert keine Spannungen
          Status = 3; // "Strung Generator"
          Alert(HCServer, HCRequest, HCError);
          LCD_Status(Status);
          Generator(OFF); // Generator ausschalten
          sendEmail(12);
          PgmPrintln("Generator gestartet, aber Phasen liefern keine Spannung!");
        }
      } else { // Generator konnte nicht gestartet werden
        Status = 3; //  "Strung Generator"
        Alert(HCServer, HCRequest, HCError);
        LCD_Status(Status);
        Generator(OFF);
        sendEmail(12);
        PgmPrintln("Generator konnte nicht gestartet werden!");
      }
    }
  }

  // Netzwiederkehr im Status "Generatorbetrieb" und "Netzwiederkehr in..."
  if (!digitalRead(PIN_PHASE_NETZ) && (Status == 1 || Status == 9)) {
    if (previousMillis == 0) previousMillis = currentMillis;
    if (Status == 1) {
      page = 1;
      Status = 9; // "Netzwiederkehr"
      Alert(HCServer, HCRequest, HCBack);
      PgmPrintln("Netzwiederkehr im Status Generatorbetrieb, Countdown gestartet.");
      sendEmail(Status);
      piep();
    }
    timeout = (backmain * 60) - ((currentMillis - previousMillis) / 1000);
    LCD_Status(Status);

    if (timeout <= 0) {
      previousMillis = 0;
      PgmPrintln("Netzwiederkehr im Status Generatorbetrieb");
      Status = 0; //  "Netzbetrieb"
      Alert(HCServer, HCRequest, HCStop);
      piep();
      Generator(OFF);
      LCD_Status(Status);
      SwitchNetzbetrieb(); // Umschalten auf Netzbetrieb
      sendEmail(11);
    }
  }

  // Netzwiederkehr im Status "Strung Generator"
  if (!digitalRead(PIN_PHASE_NETZ) && Status == 3) {
    PgmPrintln("Netzwiederkehr im Status Strung");
    page = 1;
    Status = 0;  // "Netzbetrieb";
    Alert(HCServer, HCRequest, HCBack);
    piep();
    Generator(OFF);
    LCD_Status(Status);
    SwitchNetzbetrieb();
    sendEmail(9);
  }

  // Generatorwiederkehr im Status "Strung Generator"
  if (!digitalRead(PIN_PHASE_GEN) && Status == 3) {
    PgmPrintln("Generatorwiederkehr im Status Strung Generator");
    page = 1;
    Status = 1; // "Generatorbetrieb"
    piep();
    //Generator(ON);
    LCD_Status(Status);
    SwitchGeneratorbetrieb(); // Umschalten auf Generatorbetrieb
    sendEmail(10);
  }

  // Generatorausfall im Status "Generatorbetrieb"
  if (digitalRead(PIN_PHASE_GEN) && Status == 1) {
    PgmPrintln("Generatorausfall im Status Generatorbetrieb");
    Generator(OFF);
    SwitchNetzbetrieb(); // Umschalten auf Netzbetrieb und hoffen, dass der Strom bald wieder kommt!
    page = 1;
    Status = 3; // "Strung Generator"
    Alert(HCServer, HCRequest, HCError);
    piep();
    LCD_Status(Status);
    sendEmail(12);
  }

  // Generatorausfall im Status "Manueller Betrieb"
  if (digitalRead(PIN_PHASE_GEN) && Status == 2) {
    PgmPrintln("Generatorausfall im Status Manuellerbetrieb");
    Generator(OFF);
    page = 1;
    Status = 4; // "Strung Manuell"
    Alert(HCServer, HCRequest, HCError);
    piep();
    LCD_Status(Status);
    sendEmail(12);
  }

  // Generatorwiederkehr im Status "Strung Manuell"
  if (!digitalRead(PIN_PHASE_GEN) && Status == 4) {
    PgmPrintln("Generatorwiederkehr im Status Strung Manuell");
    page = 1;
    Status = 2; // "Manueller Betrieb"
    piep();
    Generator(ON);
    LCD_Status(Status);
    // SwitchGeneratorbetrieb(); // Umschalten auf Generatorbetrieb
    sendEmail(10);
  }

  interrupts();
}

void Webserver() {
  String readString = "";
  char c;
  char br[5] = "<br>";
  char dp[3] = ": ";

  EthernetClient client = server.available();
  if (client) {


    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    while (client.connected()) {

      if (client.available()) {
        c = client.read();

        readString += c;

        if (c == '\n' && currentLineIsBlank) {

          // Datei Upload
          if (readString.indexOf("multipart/form-data;") > 0) {

            readString = "";
            currentLineIsBlank = true;
            while (client.connected()) {

              if (client.available()) {
                char w = client.read();
                readString += w;

                if (w == '\n' && currentLineIsBlank) {
                  // Dateiname extrahieren, Datei anlegen
                  int a = readString.indexOf("filename=") + 10;
                  readString = readString.substring(a);
                  a = readString.indexOf("\"");
                  readString.remove(a);
                  if (SD.exists(readString)) {
                    Serial.print(F("Upload: ")); Serial.print(readString); Serial.println(F(" ist bereits vorhanden, wird berschrieben."));
                    SD.remove(readString);
                  }
                  sdFile = SD.open(readString, FILE_WRITE);
                  int i = 0;

                  // stay in this loop until the file has been received
                  while (client.connected()) {

                    if (client.available()) {
                      w = client.read();  // get file byte

                      if (w == 0x2D) { // 1.
                        w = client.read();
                        if (w == 0x2D) {  // 2.
                          w = client.read();
                          if (w == 0x2D) {  // 3.
                            w = client.read();
                            if (w == 0x2D) {  // 4.
                              w = client.read();
                              if (w == 0x2D) {  // 5.
                                w = client.read();
                                if (w == 0x2D) {  // 6.
                                  sdFile.close();
                                  if (SD.exists(readString)) {
                                    Serial.print(F("Upload: "));
                                    Serial.print(readString);
                                    Serial.println(F(" OK"));
                                  } else {
                                    Serial.print(F("Upload: "));
                                    Serial.print(readString);
                                    Serial.println(F(" Fehlgeschlagen"));
                                  }
                                  goto Configuration;
                                  //client.stop();
                                  //break;
                                } else {
                                  sdFile.print("-");
                                  sdFile.print("-");
                                  sdFile.print("-");
                                  sdFile.print("-");
                                  sdFile.print("-");
                                  sdFile.print(w);
                                }
                              } else {
                                sdFile.print("-");
                                sdFile.print("-");
                                sdFile.print("-");
                                sdFile.print("-");
                                sdFile.print(w);
                              }
                            } else {
                              sdFile.print("-");
                              sdFile.print("-");
                              sdFile.print("-");
                              sdFile.print(w);
                            }
                          } else {
                            sdFile.print("-");
                            sdFile.print("-");
                            sdFile.print(w);
                          }
                        } else {
                          sdFile.print("-");
                          sdFile.print(w);
                        }
                      } else {
                        sdFile.print(w);
                      }
                    }
                  }
                }
                // detect the end of the incoming HTTP header
                if (w == '\n') {
                  // starting a new line
                  currentLineIsBlank = true;
                }
                else if (w != '\r') {
                  // got a character on the current line
                  currentLineIsBlank = false;
                }
              }
            }
          }


          // Download von Dateien von der SD-Karte
          if (readString.indexOf("?download") > 0 ) {
            int a = readString.indexOf("?download") + 10;
            int b = readString.indexOf(" HTTP/");
            readString = readString.substring(a, b);
            client.println(F("HTTP/1.1 200 OK"));
            client.println(F("Content-Type: text/html"));
            client.println();
            client.println(F("<!DOCTYPE html>"));
            client.println(F("<html>"));
            client.println(F("<head>"));
            client.print(F("<title>ATS-Konfiguration (")); client.print(readString); client.println(F(")</title>"));
            client.println(F("<meta name=\"referrer\" content=\"no-referrer\" />"));
            client.println(F("</head><body><pre>"));
            readString.toUpperCase();
            sdFile = SD.open(readString);
            if (!sdFile) {
              client.println(F("<h1>File not Found!</h1>"));
              Serial.println(F("Download: ")); Serial.print(readString); Serial.println(F(" nicht gefunden!"));
              client.stop();
              break;
            } else {
              Serial.print(F("Download: ")); Serial.println(readString);
              while (sdFile.available())   {
                int x = sdFile.read();
                if (x == 60) client.print("&lt;");
                if (x == 62) client.print("&gt;");
                if (x != 60 && x != 62) client.print(char(x));
              }
              sdFile.close();
            }
            client.println(F("</pre></body></html>"));
            client.stop();
            break;
          }

          // Reboot Arduino
          if (readString.indexOf("?reset") > 0 ) {
            PgmPrintln("Anforderung per Webfrontend zum Reset.");
            sendEmail(16);
            client.println(F("HTTP/1.1 200 OK"));
            client.println(F("Content-Type: text/html"));
            client.println();
            client.print(F("<!DOCTYPE html><html><head><title>ATS</title><meta http-equiv=\"refresh\" content=\"10; URL=http://"));
            client.print(host); client.print(F(".")); client.print(domain);
            client.print(F("\"><meta name=\"referrer\" content=\"no-referrer\" /></head><body><h1>Rebooting...</h1></body></html>"));
            delay(1);
            client.stop();
            delay(2000);
            softReset();
            break;
          }

          // Datei von SD-Karte lschen
          if (readString.indexOf("?deletefile") > 0 ) {
            //Serial.print(readString);
            int a = readString.indexOf("?deletefile") + 12;
            int b = readString.indexOf("&");
            int c = readString.indexOf(" HTTP");
            String filename = readString.substring(a, b);

            if (readString.substring(b + 1, c) == "delete=OK") {
              filename.toUpperCase();
              if (filename != "CONFIG.INI") {
                if (SD.exists(filename)) {
                  SD.remove(filename);
                  if (!SD.exists(filename)) {
                    Serial.print(F("Delete: ")); Serial.print(filename); Serial.println(F(" OK"));
                  } else {
                    Serial.print(F("Delete: ")); Serial.print(filename); Serial.println(F(" Fehlgeschlagen"));
                  }
                } else {
                  Serial.println(F("Delete: ")); Serial.print(filename); Serial.println(F(" nicht gefunden!"));
                }
              } else {
                Serial.println(F("Delete: config.ini darf nicht gelscht werden!"));
              }
            }
            goto Configuration;
            break;
          }

          // Datei lschen / Sicherheitsabfrage
          if (readString.indexOf("?askdelete") > 0 ) {
            int a = readString.indexOf("?askdelete") + 11;
            int b = readString.indexOf(" HTTP/");
            readString = readString.substring(a, b);
            client.println(F("HTTP/1.1 200 OK"));
            client.println(F("Content-Type: text/html"));
            client.println();
            client.print(F("<!DOCTYPE html><html><head><title>ATS-Konfiguration</title>"));
            client.print(F("<meta name=\"referrer\" content=\"no-referrer\" /></head><style>"));
            client.print(F("table {background-color: #D8D8D8;border-collapse: collapse;border: none;}"));
            client.print(F("thead {background-color: #DF0101;}"));
            client.print(F("input[type=submit] { padding:15px 15px; background:#ccc; border:0 none; cursor:pointer; -webkit-border-radius: 5px; border-radius: 5px; }"));
            client.print(F("td, th {text-align: center;padding: 0.5em 1em;}</style><body>"));
            client.print(F("<form method=\"get\" name=\"ats\">"));
            client.print(F("<input type=\"hidden\" name=\"deletefile\" value=\""));
            client.print(readString);
            client.print(F("\">"));
            client.print(F("<table>"));
            client.print(F("<thead><tr><th colspan=\"2\"><h1><font face=\"verdana\" color=\"white\">Achtung!</font></h1></th><thead></tr>"));
            client.print(F("<tbody><tr><td colspan=\"2\"><h2><font face=\"verdana\">Soll ")); client.print(readString); client.print(F(" wirklich gel&ouml;scht werden?</font></h2></td></tr></tbody>"));
            client.print(F("<tbody><tr>"));
            client.print(F("<td><input type=\"submit\" name=\"delete\" value=\"OK\"></td>"));
            client.print(F("<td><input type=\"submit\" name=\"delete\" value=\"Cancel\"></td>"));
            client.print(F("</tr></tbody></table></form>"));
            client.print(F("</body></html>"));
            delay(1);
            client.stop();
            break;
          }

          // Konfiguration anzeigen
          if (readString.indexOf("?config") > 0 ) {
Configuration:
            client.println(F("HTTP/1.1 200 OK"));
            client.println(F("Content-Type: text/html"));
            client.println();
            client.println(F("<!DOCTYPE html>"));
            client.println(F("<style>"));
            DeliverContent(&client, CSS_File);
            client.println(F("</style>"));
            ParseContent(&client, Config_File);
            break;
          }

          // Notfall Formular um Dateien hoch zu laden
          if (readString.indexOf("?upload") > 0 ) {
            client.println(F("HTTP/1.1 200 OK"));
            client.println(F("Content-Type: text/html"));
            client.println();
            client.print(F("<!DOCTYPE html><html><head><title>ATS</title><meta name=\"referrer\" content=\"no-referrer\" /></head><body><h1>Datei auf SD-Karte speichern</h1></body></html>"));
            client.print(F("<form method=\"post\" enctype=\"multipart/form-data\">"));
            client.print(F("<input type=\"button\" value=\"Zur&uuml;ck\" onclick=\"window.location.href='http://"));
            client.print(host); client.print(F(".")); client.print(domain);
            client.print(F("'\" />&nbsp;&nbsp;"));
            client.print(F("<input type=\"file\" name=\"datei\" accept=\"text/*\"><input class=\"button\" type=\"submit\" value=\"Upload\">&nbsp;&nbsp;"));
            client.print(F("<input type=\"button\" value=\"Reboot\" onclick=\"window.location.href='http://"));
            client.print(host); client.print(F(".")); client.print(domain);
            client.print(F("/?reset'\" />&nbsp;&nbsp;"));
            client.print(F("</form></body></html>"));
            delay(1);
            client.stop();
            break;
          }

          if (readString.indexOf("?power") > 0 ) { // Abfrage der aktuellen Leistung
            client.println(F("HTTP/1.1 200 OK"));
            client.println(F("Content-Type: text/plain"));
            client.println();
            client.println(ConvSeperator(StrLeistung));
            delay(1);
            client.stop();
            break;
          }

          if (readString.indexOf("?mainbet") > 0 ) { // Netzbetrieb
            PgmPrintln("Anforderung per Webfrontend zum Netzbetrieb");
            Status = 0; // "Netzbetrieb"
            Alert(HCServer, HCRequest, HCStop);
            if (!Generator(OFF)) {
              SwitchNetzbetrieb();
              sendEmail(2);
            } else {
              Status = 4; // "Strung Manuell"
              sendEmail(3);
            }
            Print_Status[Status];
          }

          if (readString.indexOf("?genbet") > 0 ) { // Generatorbetrieb, Stromausfall simulieren
            PgmPrintln("Anforderung per Webfrontend zum Generatorbetrieb");
            Status = 2; // Manueller Betrieb
            Alert(HCServer, HCRequest, HCStart);
            if (Generator(ON)) {
              SwitchGeneratorbetrieb();
              sendEmail(0);
            } else {
              Status = 4; // "Strung Manuell"
              Alert(HCServer, HCRequest, HCError);
              sendEmail(1);
            }
            Print_Status[Status];
          }

          if (readString.indexOf("?genstart") > 0 ) { // Generator starten
            PgmPrintln("Anforderung per Webfrontend zum Generatorstart");
            Alert(HCServer, HCRequest, HCStart);
            if (Generator(ON)) {
              Status = 18; // "Generator luft"
              sendEmail(4);
            } else {
              Status = 4; // "Strung Manuell"
              Alert(HCServer, HCRequest, HCError);
              sendEmail(5);
            }
            Print_Status[Status];
          }

          if (readString.indexOf("?genstop") > 0 ) { // Generator stoppen
            PgmPrintln("Anforderung per Webfrontend zum Generatorstopp");
            Alert(HCServer, HCRequest, HCStop);
            if (!Generator(OFF)) {
              Status = 0; // "Netzbetrieb"
              sendEmail(6);
            } else {
              Status = 4; // Strung Manuell
              sendEmail(7);
            }
            Print_Status[Status];
          }

          if (readString.indexOf("?sendmail") > 0 ) { // Status-Seite als E-Mail versenden
            PgmPrintln("Anforderung per Webfrontend zum Status-Mail-Versand");
            sendEmail(14);
          }

          // HTTP-Request lschen um Speicher frei zu geben.
          readString = "";

          // Webseite an Client ausliefern
          client.println(F("HTTP/1.1 200 OK"));
          client.println(F("Content-Type: text/html"));
          client.println();
          client.println(F("<!DOCTYPE html>"));
          client.println(F("<style>"));
          DeliverContent(&client, CSS_File);
          client.println(F("</style>"));
          ParseContent(&client, ATS_File);

          break;
        }
        if (c == '\n') {
          // you're starting a new line
          currentLineIsBlank = true;
        } else if (c != '\r') {
          // you've gotten a character on the current line
          currentLineIsBlank = false;
        }
      }
    }
    delay(1);
    client.stop();
  }
}


void DeliverSDRoot(EthernetClient *client) {
  File root;
  root = SD.open("/");
  while (true) {
    File entry = root.openNextFile();
    if (! entry) { // no more files
      break;
    }
    if (!entry.isDirectory()) {
      client->print(F("<tr><td id=\"a\">"));
      String filename = String(entry.name());
      filename.toLowerCase();
      client->print(F("<a href=\"http://"));
      client->print(host); client->print(F(".")); client->print(domain);
      client->print(F("/?download="));
      client->print(filename);
      client->print(F("\"><font class=\"n\">"));
      client->print(filename);
      client->print(F("</font></a>"));
      client->print(F("</td><td id=\"a\"><font class=\"n\">"));
      client->print(entry.size(), DEC);
      client->print(F("</font></td><td id=\"a\">"));
      client->print(F("<a href=\"http://"));
      client->print(host); client->print(F(".")); client->print(domain);
      client->print(F("/?askdelete="));
      client->print(filename);
      if (filename == "config.ini") {
        client->print(F("\"><font class=\"n\">"));
      } else {
        client->print(F("\"><font class=\"n\">X"));
      }
      client->print(F("</font></a></td>"));
      client->println(F("</tr>"));
    }
    entry.close();
  }
  delay(1);
}

void DeliverContent(EthernetClient *client, char *filename) {
  char c;
  char temp[200] = {};
  int i = 0;

  sdFile = SD.open(filename);
  if (!sdFile) {
    Serial.println(F("DeliverContent"));
    Serial.print(filename); Serial.println(F(" nicht gefunden!"));
    return false;
  }
  while (sdFile.available()) {
    c = sdFile.read();
    if ((c == '\n'))  {        // Zeile fertig eingelesen
      int len = strlen(temp);
      temp[len] = '\0';
      client->print(temp);     // ... und an Webclient ausliefern
      i = 0;
      memset(temp, '\0', sizeof(temp));
    } else {
      temp[i] = c;
      i++;
    }
  }
  sdFile.close();
}

void ParseContent(EthernetClient *client, char *filename) {
  char c;
  char temp[200] = {};
  String strLine = "";
  int i = 0;

  // Ist die Datei berhaupt da?
  sdFile = SD.open(filename);
  if (!sdFile) {
    Serial.println(F("ParseWebContent"));
    Serial.print(filename); Serial.println(F(" nicht gefunden!"));
    return false;
  }

  while (sdFile.available())   {
    c = sdFile.read();
    if ((c == '\n'))  {        // Zeile fertig eingelesen
      int len = strlen(temp);
      temp[len] = '\0';
      strLine = String(temp);

      // SD-Karteninhalt ausgeben
      if (strLine.indexOf("<sdcontent>") > 0) {
        DeliverSDRoot(client);
      }

      strLine.replace("%ram%", String(ram));
      strLine.replace("%ver%", version);
      strLine.replace("%z%", showTime());
      strLine.replace("%d%", showDate());
      strLine.replace("%sta%", Web_Status(Status));
      if (zuendung) {
        if (Status == 1 || Status == 18) {
          strLine.replace("%gen%", "Ein");
        } else {
          strLine.replace("%gen%", "Standby");
        }
      } else {
        strLine.replace("%gen%", "Aus");
      }
      strLine.replace("%sys%", ConvSeperator(t_data.SysTemperatur));
      strLine.replace("%mot%", ConvSeperator(t_data.MotorTemperatur));
      strLine.replace("%aut%", ConvSeperator(t_data.AussenTemperatur));
      strLine.replace("%bat%", ConvSeperator(GeneratorBatterie));
      strLine.replace("%p%", ConvSeperator(StrLeistung));
      strLine.replace("%1v%", String(p_data.L1_Spannung, 0));
      strLine.replace("%2v%", String(p_data.L2_Spannung, 0));
      strLine.replace("%3v%", String(p_data.L3_Spannung, 0));
      strLine.replace("%1c%", ConvSeperator(String(p_data.L1_Strom, 1)));
      strLine.replace("%2c%", ConvSeperator(String(p_data.L2_Strom, 1)));
      strLine.replace("%3c%", ConvSeperator(String(p_data.L3_Strom, 1)));

      strLine.replace("%lm%", String(lostmain));
      strLine.replace("%bm%", String(backmain));
      strLine.replace("%gt%", String(glowtime));
      strLine.replace("%it%", String(ignitiontime * 100));
      strLine.replace("%st%", String(starttrying));
      strLine.replace("%startd%", String(genstartdelay));
      strLine.replace("%stopd%", String(genstoppdelay));
      strLine.replace("%sd%", String(switchdelay));
      strLine.replace("%mv%", ConvSeperator(String(minbatvoltage, 1)));

      strLine.replace("", "&ouml;");
      strLine.replace("", "&auml;");
      strLine.replace("", "&uuml;");
      strLine.trim();

      client->println(strLine);     // ... und an Webclient ausliefern

      i = 0;
      memset(temp, '\0', sizeof(temp));

    } else {
      temp[i] = c;
      i++;
    }
  }
  sdFile.close();
}