//Includes
#include <Time.h>                           // Zeitfunktionen
#include <Ethernet.h>                       // Ethernetfunktionen
#include <EthernetUdp.h>                    // UDP Funktionen auf Ethernet
#include <SPI.h>                            // SPI für Ethernetboard
#include <OneWire.h>                        // OneWire für DS18B20
#include <DallasTemperature.h>              // Temperatur-Funktionen

//Variablen

//Ethernet
static byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0x9B, 0xC1 };
EthernetClient client;                      // EthernetClient - Instanz erstellen (Uhrzeit über Internet)
EthernetClient clientmysql;                 // EthernetClient - Instanz erstellen (Mysql)
EthernetClient clientserv;                  // EthernetClient - Instanz erstellen (Webserver)
EthernetUDP Udp;                            // UDP - Instanz erstellen
EthernetServer tempserver(80);

byte gateway[] = { 192, 168, 178, 1 };      // Gateway eingeben!
byte subnet[]  = { 255, 255, 255, 0 };      // Subnetzmaske
byte server[] = { 192,168,178,22 };         // IP des Servers eingeben

// Mysql
char host[] = "192.168.178.22";             // DOMAIN eingeben!
int Port = 5200;
char url[]  = "/mysql.php";                 // Pfad zur PHP-Datei eingeben
String query = "";                          // Variable für Mysql-Eintrag

// NTP-Server
const char timeServer[] = "ptbtime1.ptb.de";
const int NTP_PACKET_SIZE = 48;               // NTP Paketgroeße
byte packetBuffer[NTP_PACKET_SIZE];           // NTP Datenpuffer
time_t prevDisplay = 0;                       // NTP Klasse - Zeit wurde noch nicht geändert

boolean tupd = false;                         // Zeit update false/true
boolean supd = false;                         // Temperaturupdate false/true

// DS18S20 Temperaturchip i/o
OneWire TeichTemp(3);                         // an pin 3
DallasTemperature sensors(&TeichTemp);
int errzahl;                                  // Variable für Anzahl defekter Sensoren
const int senzahl = 10;                       // Anzahl der One-Wire-Sensoren
int sensdef[senzahl];                                  // Variable für defekte Sensoren
const DeviceAddress sen[senzahl] =                    //Sensoradressen
{
  {0x28, 0xFF, 0xF7, 0xE4, 0x01, 0x17, 0x03, 0x33},   // Sensor 01 - Teich - Wasser - Boden
  {0x28, 0xFF, 0xD2, 0xA3, 0x01, 0x17, 0x03, 0x7F},   // Sensor 02 - Teich - Wasser - Tiefe 150 cm
  {0x28, 0xFF, 0x9E, 0xE3, 0x01, 0x17, 0x03, 0x57},   // Sensor 03 - Teich - Wasser - Tiefe 100 cm
  {0x28, 0xFF, 0xE8, 0x41, 0x02, 0x17, 0x03, 0xEC},   // Sensor 04 - Teich - Wasser - Tiefe  50 cm
  {0x28, 0xFF, 0x25, 0x98, 0x01, 0x17, 0x03, 0x54},   // Sensor 05 - Teich - Wasser - Tiefe   0 cm
  {0x28, 0xFF, 0x13, 0x03, 0x02, 0x17, 0x03, 0xDD},   // Sensor 06 - Trommler - Wasser
  {0x28, 0xFF, 0x8F, 0x9E, 0x01, 0x17, 0x05, 0x0E},   // Sensor 07 - Trommler - Luft
  {0x28, 0xFF, 0xBC, 0x1E, 0x02, 0x17, 0x04, 0xA7},   // Sensor 08 - Technikraum - Unten
  {0x28, 0xFF, 0xD0, 0xF0, 0x01, 0x17, 0x03, 0xAC},   // Sensor 09 - Technikraum - Oben
  {0x28, 0xFF, 0x7F, 0x04, 0x02, 0x17, 0x03, 0x6B},   // Sensor 10 - Aussentemperatur
};


int i;                                                //allgemeiner Zähler
float celsius[senzahl];
char strbuf[10];

//Funktionsprototypen
void webserv ();
void readsensors(float*, int*);
void zeitsync();
time_t getNtpTime();
void sendNTPpacket(const char * address);
void TempRec();


void setup() {
  Ethernet.begin(mac);                                // Ethernet-Verbindung starten
  Udp.begin(8888);                                    // UDP starten Port 8888
  tempserver.begin();                                     // Webserver starten
  zeitsync();                                         // Das erste mal Internet-Zeit holen und Arduino-Uhr stellen
  sensors.begin();                                    // Sensoren starten
  for (i=0; i<senzahl; i++) {
    sensors.setResolution(sen[i], 9);                 //Setzen der Sensor-Auflösung auf 9 Bit
  }
  delay(30000);
}

void loop() {
  if (minute() == 50 && !tupd) {                      // Jeweils x Uhr 50 und Uhrzeit noch nicht aktualisiert (tupd = false)
    zeitsync();                                       // hole die aktuelle Uhrzeit aus dem Internet und korrigiere interne Uhr
    tupd = !tupd;                                     // Setze tupd auf true, damit für den Rest der Minute kein weiteres Update erfolgt
  }
  if (minute() != 50 && tupd) {                       // Zu jeder anderen Zeit und Uhrzeit aktualisiert (tupd = true)
    tupd = !tupd;                                     // Setze tupd auf false, damit in der darauf folgenden Stunde das Update wieder laufen kann
  }
  if (minute() == 0 && !supd) {                       // Zu jeder vollen Stunde und Temperaturen noch nicht aktualisiert (supd = false)
    TempRec();                                        // frage die Sensoren ab und schicke die Daten an den Mysql-Server
    supd = !supd;                                     // Setze supd auf true, damit für den Rest der Minute kein weiteres Update erfolgt
  }
  if (minute() != 0 && supd) {                        // Zu jeder anderen Zeit und Temperaturen aktualisiert (supd = true)
    supd = !supd;                                       // Setze supd auf false, damit in der darauf folgenden Stunde das Update wieder laufen kann
  }
  webserv();
}


// Benötigte Funktionen

void webserv() {
  clientserv = tempserver.available();
  if (clientserv) {
    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    while (clientserv.connected()) {
      if (clientserv.available()) {
        char c = clientserv.read();
        // if you've gotten to the end of the line (received a newline
        // character) and the line is blank, the http request has ended,
        // so you can send a reply
        if (c == '\n' && currentLineIsBlank) {
          // send a standard http response header
          readsensors();
          clientserv.println("HTTP/1.1 200 OK");
          clientserv.println("Content-Type: text/html");
          clientserv.println("Connection: close");  // the connection will be closed after completion of the response
          clientserv.println();
          clientserv.println("<!DOCTYPE HTML>");
          clientserv.println("<html>");
          clientserv.println("Aktuelle Temperaturen:");
          clientserv.println("<br /><br />");;
          // output the value of each analog input pin
          for (i=0; i<senzahl; i++) {
            clientserv.print("Sensor ");
            clientserv.print(i+1);
            clientserv.print(": ");
            dtostrf (celsius[i],6,1,strbuf);
            clientserv.print(strbuf);
            clientserv.println(" &deg;C<br />");
          }
          client.println("</html>");
          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;
        }
      }
    }
    // give the web browser time to receive the data
    delay(1000);
    // close the connection:
    clientserv.stop();
  }
}

//Temperature abrufen und ausgeben
void TempRec() {
  sensors.requestTemperatures();                      // Sensoren anweisen, die Temperaturen bereitzustellen
  delay(1000);                                        // Gib den Sensoren 1 Sekunde Zeit
  if (clientmysql.connect(host, Port))                // Verbindung zum Server aufbauen
  {
    readsensors();                                    // Lese alle Sensoren aus
    query = "GET /mysql.php";                         // Bereite die Variable für den Mysql-Eintrag vor
    for (i=0; i<senzahl; i++) {                       // Durchlaufe der Reihe nach alle Sensoren
      if (i == 0) {
        query=query+("?s");
      }
      else {
        query=query+("\&s");
      }
      query=query+(String (i))+"="+(String (celsius[i]))+"&e"+(String (i))+"="+(String (sensdef[i]));
    }
    clientmysql.print(query);                           // Schicke den Mysql-Eintrag ab
    clientmysql.println();
    clientmysql.println("Connection: close");
  }
}

void readsensors() {
  for (i=0; i<senzahl; i++) {                           // Durchlaufe der Reihe nach alle Sensoren
    sensdef[i]=0;                                          // Setze den Fehlerstatus auf false
    if (sensors.isConnected (sen[i])) {                     // Wenn der aktuelle Sensor angeschlossen ist, dann
      celsius[i] = sensors.getTempC(sen[i]);                  // Lies den aktuellen Sensor aus
      errzahl = 0;                                            // Setze Anzahl der Durchläufe auf Null
      if (celsius[i] == 85) {
        while (celsius[i] == 85 && errzahl < 10) {              // Wenn Sensor noch nicht bereit, versuche bis zu 10mal , den Sensor auszulesen
          delay (100);                                            // Warte eine zehntel Sekunde, um dem Sensor Zeit zu geben
          celsius[i] = sensors.getTempC(sen[i]);                  // Versuche erneut, den Sensor auszulesen
          errzahl++;                                              // Erhöhe die Anzahl der Durchläufe um 1
        }
      }
      if (celsius[i] == 85 || celsius[i] == -127) {           // Wenn der Sensor 85 oder -127 zurückgibt, dann
        sensdef[i]=(int)celsius[i];                                // setze den Fehlerstatus auf true
      }
    }
    else {                                                // Wenn der aktuelle Sensor nicht angeschlossen ist, dann
      celsius[i] = -127;                                    // setze die Temperatur auf -127°
      sensdef[i]=(int)celsius[i];                              // und den Fehlerstatus auf true
    }
  }
}

void zeitsync() {                                           // Ruft den NTP-Server ab und setzt die interne Uhr
  setSyncProvider(getNtpTime);                              // NTP Provider starten / erstmalig abfragen
  setTime(hour(),minute(),second(),day(),month(),year());   // Zeit auf Arduino setzen
}

// NTP Provider - prüft ob NTP läuft und holt die Daten
time_t getNtpTime()
{
  while (Udp.parsePacket() > 0) ;                           // vorhergehende Pakete verwerfen
  sendNTPpacket(timeServer);
  uint32_t beginWait = millis();
  while (millis() - beginWait < 1500)                       // 1500 Millisekunden Wartezeit für NTP Antwort
  {
    int size = Udp.parsePacket();
    if (size >= NTP_PACKET_SIZE)
    {
      Udp.read(packetBuffer, NTP_PACKET_SIZE);              // Paket in Puffer einlesen
      unsigned long secsSince1900;
                                                            // Byte 40,41,42,43 zusammen in long umwandeln
      secsSince1900 =  (unsigned long)packetBuffer[40] << 24;
      secsSince1900 |= (unsigned long)packetBuffer[41] << 16;
      secsSince1900 |= (unsigned long)packetBuffer[42] << 8;
      secsSince1900 |= (unsigned long)packetBuffer[43];
      return secsSince1900 - 2208988800UL + 2 * SECS_PER_HOUR;
    }
  }
  return 0;
}

// NTP Request senden
void sendNTPpacket(const char * address) {
  memset(packetBuffer, 0, NTP_PACKET_SIZE);                 // set all bytes in the buffer to 0
                                                            // Initialize values needed to form NTP request
  packetBuffer[0] = 0b11100011;                             // LI, Version, Mode
  packetBuffer[1] = 0;                                      // Stratum, or type of clock
  packetBuffer[2] = 6;                                      // Polling Interval
  packetBuffer[3] = 0xEC;                                   // Peer Clock Precision
                                                         // 8 bytes of zero for Root Delay & Root Dispersion
  packetBuffer[12]  = 49;
  packetBuffer[13]  = 0x4E;
  packetBuffer[14]  = 49;
  packetBuffer[15]  = 52;

                                                         // all NTP fields have been given values, now you can send a packet requesting a timestamp:
  Udp.beginPacket(address, 123);                            // NTP requests are to port 123
  Udp.write(packetBuffer, NTP_PACKET_SIZE);
  Udp.endPacket();
}