// MACRO-START * MACRO-START * MACRO-START * MACRO-START * MACRO-START * MACRO-START *
// Take it for granted at the moment scroll down to void setup
// start of macros dbg and dbgi
#define dbg(myFixedText, variableName) \
  Serial.print( F(#myFixedText " "  #variableName"=") ); \
  Serial.println(variableName);
// usage: dbg("1:my fixed text",myVariable);
// myVariable can be any variable or expression that is defined in scope

#define dbgi(myFixedText, variableName,timeInterval) \
  do { \
    static unsigned long intervalStartTime; \
    if ( millis() - intervalStartTime >= timeInterval ){ \
      intervalStartTime = millis(); \
      Serial.print( F(#myFixedText " "  #variableName"=") ); \
      Serial.println(variableName); \
    } \
  } while (false);
// usage: dbgi("2:my fixed text",myVariable,1000);
// myVariable can be any variable or expression that is defined in scope
// third parameter is the time in milliseconds that must pass by until the next time a
// Serial.print is executed
// end of macros dbg and dbgi
// print only once when value has changed
#define dbgc(myFixedText, variableName) \
  do { \
    static long lastState; \
    if ( lastState != variableName ){ \
      Serial.print( F(#myFixedText " "  #variableName" changed from ") ); \
      Serial.print(lastState); \
      Serial.print( F(" to ") ); \
      Serial.println(variableName); \
      lastState = variableName; \
    } \
  } while (false);
// MACRO-END * MACRO-END * MACRO-END * MACRO-END * MACRO-END * MACRO-END * MACRO-END *

/*-----( Import needed libraries )-----*/
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

/*-----( Declare Constants )-----*/
/*-----( Declare objects )-----*/
// set the LCD address to 0x27 for a 20 chars 4 line display
LiquidCrystal_I2C lcd(0x27,20,4);  

// hier geht der interessante Code lose
const byte Luefter    =  2;
const byte Licht      =  3;
const byte Komp       =  4;
const byte Komp2      =  5;
const byte TASTER     = 12; // 13 ist die Onboard LED die frei lassen
const byte Verdampfer = A0;
const byte Raum       = A1;
const byte Poti       = A2;

//const byte EIN = LOW; // low-active
//const byte AUS = HIGH;

const byte EIN = HIGH; // HIGH-active
const byte AUS = LOW;

const byte LosGelassen = HIGH;
const byte gedrueckt   = LOW;

const int NullGrad  = 500;
const int Plus3Grad = 400;

boolean aktButton, altButton, aktiv;
unsigned long startTime;
const unsigned long interval = 3 * 1000;  // das sind n Sekunden zum Testen; kann max ca. 49 Tage sein
// 6 Stunden wären: 6 * 60 * 60 * 1000
int Wert0;
int Wert1;
int Wert2;

enum Modus {NORMAL, TIMER} modus;

void setup() {
  Serial.begin(115200);
  Serial.println( F("Setup-Start") );
  lcd.init();                      // initialize the lcd
  lcd.backlight();
   
  pinMode(Komp, OUTPUT);
  pinMode(Komp2, OUTPUT);
  pinMode(Licht, OUTPUT);
  pinMode(Luefter, OUTPUT);
  
  pinMode(TASTER, INPUT_PULLUP);  // geändert auf INPUT_PULLUP
  pinMode(Verdampfer, INPUT);
  pinMode(Raum, INPUT);
  pinMode(Poti, INPUT);
}

void loop() {
  DatenAufLCDAusgeben();

  altButton = aktButton;
  aktButton = digitalRead(TASTER);

  if (digitalRead(Komp) == AUS) {// Kompressor auf 2 Relais
    digitalWrite(Komp2, AUS);
  }

  if (digitalRead(Komp) == EIN) {
    digitalWrite(Komp2, EIN);
  }
  dbgc("m:",modus);
  dbgc("T:",aktButton);

  switch (modus) {
    case NORMAL :
      // 1a. Der Kühlschrank soll beim drücken des Tasters die Kühlung, den innere Lüfter und das Licht einschalten. (falls er auf einer Party mal öfters geöffnet wird und gut aussieht)
      if (altButton == gedrueckt && aktButton == LosGelassen) {  // wenn der Taster losgelassen wurde...
        // was passieren soll, wenn der Taster losgelassen wird könnte hier stehen
        delay(30);  // einfaches Entprellen
        startTime = millis();    // Starten des "Timers"
        modus = TIMER;
        Serial.println(F("Timer gestartet"));
        digitalWrite(Komp,    EIN);
        digitalWrite(Licht,   EIN);
        digitalWrite(Luefter, EIN);
        //break;
      }

      // 2. Der innere Lüfter soll dauernd Laufen, wenn der Verdampfer unter 0 Grad hat. (somit kann er nie Vereisen)
      if (analogRead(Verdampfer) > NullGrad) {//0-1023 einschaltwert
        digitalWrite(Luefter, EIN);
      }

      if (analogRead(Verdampfer) < Plus3Grad) {//0-1023 ausschaltwert
        digitalWrite(Luefter, AUS);
      }

      // 3. mit dem Poti will ich die Temperatur im Kühlschrank einstellen. (Kühlung und Lüfter sollen dabei Laufen)
      if (analogRead(Raum) > (analogRead(Poti) + 100)) {//0-1023 einschaltwert
        digitalWrite(Luefter, EIN);
        digitalWrite(Komp,    EIN);
      }
      
      if (analogRead(Raum) < (analogRead(Poti) ) ) { //0-1023 ausschaltwert
        digitalWrite(Luefter, AUS);
        digitalWrite(Komp,    AUS);
      }
      break;

    case TIMER :
      // 1b. bei erneutem drücken wieder ausschalten,
      if (altButton == gedrueckt && aktButton == LosGelassen) {   // wenn der Taster losgelassen wurde...
        // was passieren soll, wenn der Taster losgelassen wird könnte hier stehen
        delay(30);  // einfaches Entprellen
        modus = NORMAL;
        Serial.println(F("Timer manuell gestopp"));
        digitalWrite(Komp,    AUS);
        digitalWrite(Licht,   AUS);
        digitalWrite(Luefter, AUS);
      }
      // 1c. und nach einer gewissen Zeit wieder von alleine ausschalten
      if (millis() - startTime > interval) {
        modus = NORMAL;
        Serial.println(F("Timer durch Zeitablauf beendet"));
        digitalWrite(Komp,    AUS);
        digitalWrite(Licht,   AUS);
        digitalWrite(Luefter, AUS);
      }
      break;
  }
}

//*************************************************************************************
// Hilfs-Funktionen 

// easy to use helper-function for non-blocking timing
boolean TimePeriodIsOver (unsigned long &startOfPeriod, unsigned long TimePeriod) {
  unsigned long currentMillis  = millis();
  if ( currentMillis - startOfPeriod >= TimePeriod ) {
    // more time than TimePeriod has elapsed since last time if-condition was true
    startOfPeriod = currentMillis; // a new period starts right here so set new starttime
    return true;
  }
  else return false;            // actual TimePeriod is NOT yet over
}

//*************************************************************************************
void DatenAufLCDAusgeben() {
  static unsigned long updateTimer;
  if ( TimePeriodIsOver(updateTimer,1000) ) { 
    lcd.setCursor(0,0); 
    lcd.print("V:");
    int ADC_Verdampfer = analogRead(Verdampfer);
    if (ADC_Verdampfer < 10) {
      lcd.print(" ");  
    }
    if (ADC_Verdampfer < 100) {
      lcd.print(" ");  
    }
    if (ADC_Verdampfer < 1000) {
      lcd.print(" ");  
    }
    lcd.print(ADC_Verdampfer);

    lcd.setCursor(6,0); 
    lcd.print(" R:");
    int ADC_Raum = analogRead(Raum);
    if (ADC_Raum < 10) {
      lcd.print(" ");  
    }
    if (ADC_Raum < 100) {
      lcd.print(" ");  
    }
    if (ADC_Raum < 1000) {
      lcd.print(" ");  
    }
    lcd.print(ADC_Raum);
    //012345678901234567890
    //R:1234V:1234P:1234
    lcd.setCursor(13,0); 
    lcd.print(" P:");
    int ADC_Poti = analogRead(Poti);
    if (ADC_Poti < 10) {
      lcd.print(" ");  
    }
    if (ADC_Poti < 100) {
      lcd.print(" ");  
    }
    if (ADC_Poti < 1000) {
      lcd.print(" ");  
    }
    lcd.print(ADC_Poti);
  }
    lcd.setCursor(0,1); 
             //012345678901234567890
             //Komp:EIN Vent:EIN
    lcd.print("Komp:");
    if (digitalRead(Komp) == EIN) {
      lcd.print("EIN");
    }
    else {
      lcd.print("AUS");
    }

    lcd.print(" Vent:");
    if (digitalRead(Luefter) == EIN) {
      lcd.print("EIN");
    }
    else {
      lcd.print("AUS");
    }

    lcd.setCursor(0,2); 
               //012345678901234567890
               //Modus: Normal
    if (modus == NORMAL) {
      lcd.print("Modus: Normal");
    }

    if (modus == TIMER) {
      lcd.print("Modus: Timer");
      lcd.setCursor(0,3); 
      lcd.print("Timer:");
      lcd.print(millis() - startTime);
      lcd.print(" ms");
    }


}