#include <DHT.h> // DHT Bibliothek laden (Sensor)
#include <Wire.h> // Wire Bibliothek laden (Echtzeit)
#include <LiquidCrystal_I2C.h> // LiquidCrystal Bibliothek laden (LCD-Display)

#define RTC_I2C_ADDRESS 0x68 // I2C Adresse der RTC ist 0x68 für DS1307 und DS3231
#define DHTPIN 2  // Der Sensor wird an PIN 2 angeschlossen
#define DHTTYPE DHT22 // Es handelt sich um den DHT22 Sensor
#define Taster 4 // Der Taster wird an Pin 4 angeschlossen
#define Brunnen 5 // Der Brunnen wird an Pin 5 angeschlossen
#define Waerme 6 // Die Waermelammpe wird an Pin 6 angeschlossen
#define Lampe 7 // Die Tageslichtlampe wird an Pin 7 angeschlossen
#define EIN LOW
#define AUS HIGH

DHT dht(DHTPIN, DHTTYPE); // Der Sensor wird ab jetzt mit "dht" angesprochen
LiquidCrystal_I2C lcd(0x27,20, 4); // Hier wird das Display benannt (Adresse/Zeichen pro Zeile/Anzahl Zeilen).

int jahre,monate,tage,stunden,minuten,sekunden;

//Kurzzeit Timer////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct timerRelais_t
{
  byte pin;
  int dauer;
  int timer1; 
  int timer2;
};

// Hier den Kurzzeittimer definieren
timerRelais_t timerRelais={Brunnen, 10800, 1100, 1630}; // Timer an Pin-4 für 10800 Sekunden um 1100 und 1630

void relaisTimerNachZeit(int thishour, int thisminute)
{
  int thisTime= thishour*100+thisminute;
  if (thisTime==timerRelais.timer1 || thisTime==timerRelais.timer2)
  {
    Serial.println("Timer Start");
    digitalWrite(timerRelais.pin,EIN);
    delay(timerRelais.dauer*1000L);
    digitalWrite(timerRelais.pin,AUS);
    Serial.println("Timer Stopp");
  }
}

//Schalten der Relais///////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct schaltRelais_t
{
  byte pin;
  int ein; int aus;
  float tempEin; float tempAus;
};

// Hier die Relais-Pins definieren mit Ein- und Ausschaltzeiten und Ein- und Ausschalttemperatur
schaltRelais_t schaltRelais[2]=
{
  {Lampe, 930, 2130},              // pin, Einschaltzeit, Ausschaltzeit, Einschalttemperatur, Ausschalttemperatur
  {Waerme, 930, 2130, 25.0, 27.0}
};

void relaisSchaltenNachZeit(int thishour, int thisminute, float thisTemp)   
// Schaltet die Zeitschaltuhr ein und aus und setzt den Ausgang entsprechend
{
  boolean state;
  // Aus der aktuellen Zeit eine Schaltzeit bilden
  int thisTime= thishour*100+thisminute;
  float thisTempSchalt= thisTemp;
  // Alle Schaltzeiten durchgehen, falls eine davon EIN sagt, einschalten
  for (int i=0;i<sizeof(schaltRelais)/sizeof(schaltRelais_t);i++)
  {
    state=AUS;  // Annahme: Es sei nichts geschaltet
    if (
       (thisTime>=schaltRelais[i].ein && thisTime<=schaltRelais[i].aus) &&
       thisTempSchalt<=schaltRelais[i].tempEin
       )
    {   
      state=EIN;
    }
    else 
    {
      if (
         (thisTime>=schaltRelais[i].ein && thisTime<=schaltRelais[i].aus) &&
         thisTempSchalt>=schaltRelais[i].tempAus
         )
      {
         state=AUS;
      }
    }
    if (digitalRead(schaltRelais[i].pin)!=state) // Falls geschaltet werden soll
    { // ein paar Debug-Ausgaben machen
      Serial.print("Relais ");
      Serial.print(i+1);  // Relais-Index zählt ab 0, einfach 1 dazuzählen
      Serial.print(": ");
      if (state==EIN) Serial.println("EIN"); else Serial.println("AUS");
    }
    digitalWrite(schaltRelais[i].pin, state); // Schaltzustand setzen
  }
}  
//auslesen der Uhrzeit + Datum//////////////////////////////////////////////////////////////////////////////////////////////////////
// wochentag bleibt in diesem Test-Sketch unberücksichtigt
void rtcReadTime(int &jahre, int &monate, int &tage, int &stunden, int &minuten, int &sekunden)
// aktuelle Zeit aus RTC auslesen
{
// Reset the register pointer
  Wire.beginTransmission(RTC_I2C_ADDRESS);
  Wire.write(0);
  Wire.endTransmission();
  Wire.requestFrom(RTC_I2C_ADDRESS, 7);
  // A few of these need masks because certain bits are control bits
  sekunden    = bcdToDec(Wire.read() & 0x7f);
  minuten     = bcdToDec(Wire.read());
  stunden     = bcdToDec(Wire.read() & 0x3f);  // Need to change this if 12 hour am/pm
  /*wochentag   = */bcdToDec(Wire.read());
  tage        = bcdToDec(Wire.read());
  monate      = bcdToDec(Wire.read());
  jahre       = bcdToDec(Wire.read())+2000;  
}
//schreiben der aktuellen Uhrzeit + Datum///////////////////////////////////////////////////////////////////////////////////////////
// wochentag bleibt in diesem Test-Sketch unberücksichtigt
void rtcWriteTime(int jahre, int monate, int tage, int stunden, int minuten, int sekunden)
// aktuelle Zeit in der RTC speichern
{
  Wire.beginTransmission(RTC_I2C_ADDRESS);
  Wire.write(0);
  Wire.write(decToBcd(sekunden));    // 0 to bit 7 starts the clock
  Wire.write(decToBcd(minuten));
  Wire.write(decToBcd(stunden));      // If you want 12 hour am/pm you need to set
                                   // bit 6 (also need to change readDateDs1307)
  Wire.write(decToBcd(0)); // Wochentag unberücksichtigt
  Wire.write(decToBcd(tage));
  Wire.write(decToBcd(monate));
  Wire.write(decToBcd(jahre-2000));
  Wire.endTransmission();  
}
//Hilfsfunktionen zum lesen und schreiben der aktuellen Uhrzeit + Datum/////////////////////////////////////////////////////////////
byte bcdToDec(byte val)  // Hilfsfunktion zum Lesen/Schreiben der RTC
// Convert binary coded decimal to decimal number
// Hilfsfunktion für die Echtzeituhr
{
  return ( (val/16*10) + (val%16) );
}

byte decToBcd(byte val) // Hilfsfunktion zum Lesen/Schreiben der RTC
// Convert decimal number to binary coded decimal
// Hilfsfunktion für die Echtzeituhr
{
  return ( (val/10*16) + (val%10) );
}
//schreiben der aktuellen Uhrzeit + Datum über Seriellen Monitor////////////////////////////////////////////////////////////////////
void behandleSerielleBefehle()
{
  char linebuf[30];
  byte counter;
  if (Serial.available())
  {
    delay(100); // Warte auf das Eintreffen aller Zeichen vom seriellen Monitor
    memset(linebuf,0,sizeof(linebuf)); // Zeilenpuffer löschen
    counter=0; // Zähler auf Null
    while (Serial.available())
    {
      linebuf[counter]=Serial.read(); // Zeichen in den Zeilenpuffer einfügen
      if (counter<sizeof(linebuf)-1) counter++; // Zeichenzähler erhöhen
    }
    // Ab hier ist die Zeile eingelesen
    if (strstr(linebuf,"set")==linebuf) // Prüfe auf Befehl "set" zum Setzen der Zeit
    { // Alle übermittelten Zahlen im String auslesen
      tage=getIntFromString (linebuf,1);
      monate=getIntFromString (linebuf,2);
      jahre=getIntFromString (linebuf,3);
      stunden=getIntFromString (linebuf,4);
      minuten=getIntFromString (linebuf,5);
      sekunden=getIntFromString (linebuf,6);
    }
    else
    {
      Serial.println("Befehl unbekannt.");
      return;
    }
    // Ausgelesene Werte einer groben Plausibilitätsprüfung unterziehen:
    if (jahre<2000 || monate<1 || monate>12 || tage<1 || tage>31 || (stunden+minuten)==0)
    {
      Serial.println(linebuf);
      Serial.println("\r\nFehlerhafte Zeitangabe im 'set' Befehl");
      Serial.println("\r\nBeispiel:");
      Serial.println("set 28.08.2013 10:54\r\n");
      return;
    }
    rtcWriteTime(jahre, monate, tage, stunden, minuten, sekunden);
    Serial.println("Zeit und Datum wurden auf neue Werte gesetzt.");
  }
}

int getIntFromString (char *stringWithInt, byte num)
// input: pointer to a char array
// returns an integer number from the string (positive numbers only!)
// num=1, returns 1st number from the string
// num=2, returns 2nd number from the string, and so on
{
  char *tail; 
  while (num>0)
  {
    num--;
    // skip non-digits
    while ((!isdigit (*stringWithInt))&&(*stringWithInt!=0)) stringWithInt++;
    tail=stringWithInt;
    // find digits
    while ((isdigit(*tail))&&(*tail!=0)) tail++;
    if (num>0) stringWithInt=tail; // new search string is the string after that number
  }  
  return(strtol(stringWithInt, &tail, 10));
} 
//Setup-Teil (alles wird nur einmal ausgeführt)//////////////////////////////////////////////////////////////////////////////////////
void setup()
{
  Wire.begin();       // initialisiert die Wire-Library
  dht.begin();        // DHT22 Sensor starten
  Serial.begin(9600); // Serielle Kommunikation starten
  while (!Serial);    // wait for serial port to connect. Needed for Leonardo only
  Serial.println("\r\nZeitschaltuhr-, Kurzzeittimer- und Temperaturschaltung-Sketch");
  Serial.println("Jede Minute wird die aktuelle Zeit im 'Seriellen Monitor' angezeigt.");
  Serial.println("Ebenso alle Ein- und Ausschaltungen und die Kurzzeittimer-Aktion");
  Serial.println();
  Serial.println("Du kannst die Zeit mit einem 'set' Befehl im 'Serial Monitor' neu setzen.");
  Serial.println("\r\nBeispiel:");
  Serial.println("set 28.08.2013 10:54\r\n");

  lcd.init(); // LCD wird gestartet
  lcd.backlight();  // Hintergrundbeleuchtung einschalten
  delay(2000);
  lcd.noBacklight(); // Hintergrundbeleuchtung ausschalten

  for (int i=0;i<sizeof(schaltRelais)/sizeof(schaltRelais_t);i++)
  {
    digitalWrite(schaltRelais[i].pin,AUS);
    pinMode(schaltRelais[i].pin,OUTPUT);
  }  
  digitalWrite(timerRelais.pin,AUS);
  pinMode(timerRelais.pin,OUTPUT);
  pinMode(Taster,INPUT);
  pinMode(13,OUTPUT);
  digitalWrite(13,LOW);
}
//Loop-Teil (läuft immer wieder durch)//////////////////////////////////////////////////////////////////////////////////////////////
void loop()
{ 
  delay(10000);  // eineinhalb Sekunden bis zur Messung warten, da Sensor etwas träge ist
  float Luftfeuchtigkeit = dht.readHumidity();  // Luftfeuchtigkeit auslesen und als "Luftfeuchtigkeit" speichern
  float Temperatur = dht.readTemperature();      //Temperatur auslesen und als "Temperatur" speichern
  
  char buffer[30];
  static unsigned long lastMillis;
  static int lastMinute;
  int stunden, minuten, sekunden, dummy;
  if (millis()-lastMillis>1000) // nur einmal pro Sekunde
  {
    lastMillis=millis();
    rtcReadTime(dummy, dummy, dummy, stunden, minuten, sekunden);
    if (minuten!=lastMinute) // die aktuelle Minute hat gewechselt
    {
      lastMinute=minuten;
      snprintf(buffer,sizeof(buffer),"%02d:%02d Uhr",stunden,minuten);
      Serial.println(buffer);
      relaisSchaltenNachZeit(stunden,minuten,Temperatur);
      relaisTimerNachZeit(stunden,minuten);
    }
  }
  behandleSerielleBefehle();
////////////////////////////////schreiben der Luftfeuchtigkeit und Temperatur in den Seriellen Monitor//////////////////////////////  
  Serial.print("Luftfeuchtigkeit: "); // Im seriellen Monitor den Text und 
  Serial.print(Luftfeuchtigkeit); // die Dazugehörigen Werte und
  Serial.println(" %"); // die Einheit anzeigen
  Serial.print("Temperatur: "); // Im seriellen Monitor den Text und 
  Serial.print(Temperatur); // die Dazugehörigen Werte und
  Serial.println(" Grad Celsius"); // die Einheit anzeigen
////////////////////////////////schreiben des Datums + Uhrzeit + Luftfeuchtigkeit + Temperatur ins LCD-Display//////////////////////
  lcd.setCursor(1,0); // Text soll beim zweiten Zeichen in der ersten Reihe beginnen.
  lcd.print(tage); // In der ersten Zeile soll das Datum angezeigt werden
  lcd.print(".");
  lcd.print(monate);
  lcd.print(".");
  lcd.print(jahre);
  lcd.setCursor(2,1); // Text soll beim dritten Zeichen in der zweiten Reihe beginnen.
  lcd.print(stunden); // In der zweiten Zeile soll die Uhrzeit angezeigt werden
  lcd.print(":");
  lcd.print(minuten);
  lcd.print(":");
  lcd.print(sekunden);   
  lcd.setCursor(0,2); // Text soll beim ersten Zeichen in der dritten Reihe beginnen.
  lcd.print("Humidity: "); // In der dritten Zeile soll die Luftfeuchtigkeit angezeigt werden
  lcd.print(Luftfeuchtigkeit);
  lcd.print(" %");
  lcd.setCursor(0,3); // Text soll beim ersten Zeichen in der vierten Reihe beginnen.
  lcd.print("Temperature: "); // In der viertel Zeile soll die Temperatur angezeigt werden
  lcd.print(Temperatur);
  lcd.print(" C");
////////////////////////////////ein-/ausschalten der Hintergrundbeleuchtung/////////////////////////////////////////////////////////
  if(digitalRead(Taster) == AUS)
  {
    lcd.backlight();
    delay(10000);
    lcd.noBacklight();
  }
}