#include <Wire.h>
//#include <EEPROMex.h>
#include <SmoothAnalogInput.h>
#include <avr/pgmspace.h>
#include <DS3231.h>
#include <FastIO.h>
#include <I2CIO.h>
#include <LCD.h>
#include <LiquidCrystal.h>
#include <LiquidCrystal_I2C.h>
#include <LiquidCrystal_SR.h>
#include <LiquidCrystal_SR2W.h>
#include <LiquidCrystal_SR3W.h>
#include <ClickEncoder.h>
#include <TimerOne.h>
#define aref_voltage 3.3
#define THERMISTORNOMINAL 10000
#define TEMPERATURENOMINAL 25
#define BCOEFFICIENT 3950
#define SERIESRESISTOR 10000
int plnt0 = A0;                               //PLANTPUMP0
int plnt1 = A1;                               //PLANTPUMP1
int e1 = A2;                                  //Error LED 1 WATER LEVEL
int temppin = A3;                             //TEMPERATURE SENSOR
//A4 A5 I2C  D1 D2 RX TX
//2-3-7 ENCODER
int heater = 4;                               //relay4 heater
int co2 = 5;                                  //relay3 co2
int lcdbl = 6;                                //LCD BackLight
int wls = 8;                                  //Water level switch
int LED = 9;                                  //PWM RED LED
int fan = 10;                                 //PWM YELLOW FAN!!!   10
int pump = 11;                                //relay1 external filter
int neon = 12;                                //relay2 T5 lights
int e2 = 13;                                  //Temperature Error LED
DS3231  rtc(SDA, SCL);
Time  t;
byte wlsv = LOW;                                                   //water level value
float tempHeaterMin = 24.5;                                        //HEATER ON
float tempHeaterMax = 24.8;                                        //HEATER OFF
float tempHeaterMinNight = 24.5;                                   //HEATER ON
float tempHeaterMaxNight = 24.8;                                   //HEATER OFF
int tempFanMin = 10600;                                            //FAN speed min
int tempFanMax = 11100;                                            //FAN speed max
byte tempLedHigh = 27;                                             //TEMPLED Upper treshold
byte tempLedLow = 23;                                              //TEMPLED Lower treshold
byte FANspeed;                                                     //FAN speed value
byte FANsz;                                                        //FAN speed LCD
byte neonv;                                                        //NEON ON-OFF value
unsigned long LEDv;                                                //LED ON-OFF value
unsigned long LED_UPFADEON = 36000;                                //allminute   10.00
unsigned long LED_UPFADEMIDDLE = 37800;                            //allminute   10.30
unsigned long LED_UPFADEOFF = 39600;                               //allminute   11.00
unsigned long LED_DOWNFADEON = 75600;                              //allminute   21.00
unsigned long LED_DOWNFADEMIDDLE = 77400;                          //allminute   21.30
unsigned long LED_DOWNFADEOFF = 79200;                             //allminute   22.00
unsigned long eattime = 61200;                                     //allminute   17.00 61200
unsigned long co2on = 30600;                                       //8.30
unsigned long co2off = 72000;                                      //20.00
unsigned long plnt0time = 37800;
unsigned long plnt1time = 37810;
unsigned long allsec;
unsigned long hour;
unsigned long min;
unsigned long sec;
unsigned long date;
byte hourminute = 60;
byte leddisp;                                                      //LED value LCD
unsigned long previousMillisdisplay;
unsigned long previousMillistemp;
unsigned long previousMillistempz;
unsigned long previousMilliswlsv;
unsigned long previousMillispump;
unsigned long previousMillisplnt0;
unsigned long previousMillisplnt1;
unsigned long timeoutTime = 5000;
unsigned long timeoutTime2 = 15000;
int waitsteinhart = 12000;
int previousvalue;
int menuTimeout = 5000;
int menuTimeout2 = 15000;
int intervaltemp = 1000;
int intervalwlsv = 5000;
int intervallcdbl = 600;
unsigned long intervalpump = 4000;
byte blinktime = 100;
float average1;
float steinhart;
byte offpump = 5;
unsigned long pumpofftime = 300000;
unsigned long plnt0ontime = 5555;    ///26,5ml - 30s   0,9/s    5ml/nap  Macro
unsigned long plnt1ontime = 2500;    ///  24ml - 30s   0,8/s    5ml/nap  Carbo
byte MoonPWMValue = 0;
byte DayLightPWMValue = 100;
unsigned long uptimedays = 0;
unsigned long uptimehours = 0;
unsigned long uptimemins = 0;
unsigned long uptimesecs = 0;
byte displayowr = 0;
//byte eepneon1 = 0;
//byte eepneon2 = 4;
//byte eepuptime = 8;
//float neon1oh;
//float neon2oh;
//float uptimecount;
//float neon1restart = 0;
//float neon2restart = 0;
//float uptimecountrestart = 0;
//float eepintervalhour = 0.1;
//unsigned long previousMillistube = 0;
//unsigned long previousMillisuptime = 0;
//unsigned long eepinterval1 = 360000;
//unsigned long eepinterval2 = 720000;
byte heaterv;
byte pumpv;
byte lastneonv;
byte co2v;
byte plnt0v;
byte plnt1v;
byte setupvalue = 0;
byte lastsetupvalue = 0;
byte wlscntrl = 0;
byte lastwls = 0;
byte heatercntrl = 0;
byte lastheater = 0;
byte fancntrl =  0;
byte eledcntrl = 0;
byte plnt0cntrl = 0;
byte plnt1cntrl = 0;
byte lastfan = 0;
byte neoncntrl = 0;
byte lastneon = 0;
byte co2cntrl = 0;
byte lastco2 = 0;
byte ledcntrl = 0;
byte lastled = 0;
byte lasteled = 0;
byte lastplnt0 = 0;
byte lastplnt1 = 0;
byte lastplnt0lst = 0;
byte lastplnt01st = 0;
byte feedcount = 0;
byte lcdbls = LOW;
LiquidCrystal_I2C  lcd(0x27, 2, 1, 0, 4, 5, 6, 7); // 0x27 is the I2C bus address for an unmodified backpack
ClickEncoder *encoder;
int16_t last, value;
void timerIsr() {
  encoder->service();
}

SmoothAnalogInput ai;
byte small2[8] = {
  0b00000,
  0b00000,
  0b00000,
  0b00110,
  0b01001,
  0b00010,
  0b00100,
  0b01111
};

void setup() { //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  ai.attach(temppin);
  Wire.begin();
  //Serial.begin(9600);
  rtc.begin();
  pinMode (plnt0, OUTPUT);
  pinMode (plnt1, OUTPUT);
  pinMode (neon, OUTPUT);
  pinMode (co2, OUTPUT);
  pinMode (heater, OUTPUT);
  pinMode (pump, OUTPUT);
  pinMode (LED, OUTPUT);
  pinMode (wls, INPUT_PULLUP);
  pinMode (fan, OUTPUT);
  pinMode (e1, OUTPUT);
  pinMode (e2, OUTPUT);
  pinMode (temppin, INPUT);
  pinMode (lcdbl, OUTPUT);
  digitalWrite (pump, HIGH);
  digitalWrite (heater, HIGH);
  digitalWrite (LED, LOW);
  digitalWrite (fan, LOW);
  digitalWrite (lcdbl, HIGH);
  digitalWrite (neon, HIGH);
  digitalWrite (co2, HIGH);
  lcd.begin (16, 2); // for 16 x 2 LCD module
  lcd.createChar(0, small2);
  lcd.setBacklightPin(3, POSITIVE);
  lcd.setBacklight(HIGH);
  analogReference(EXTERNAL);

  lcd.home();
  lcd.print ("   <AQUARIUM>   "); lcd.setCursor (0, 1);
  lcd.print ("  <CONTROLLER>  "); delay(150);
  lcd.home();
  lcd.print ("  < AQUARIUM >  "); lcd.setCursor (0, 1);
  lcd.print (" < CONTROLLER > "); delay(150);
  lcd.home();
  lcd.print (" <  AQUARIUM  > "); lcd.setCursor (0, 1);
  lcd.print ("<  CONTROLLER  >"); delay(150);
  lcd.home();
  lcd.print ("<   AQUARIUM   >"); lcd.setCursor (0, 1);
  lcd.print ("   CONTROLLER   "); delay(150);

  encoder = new ClickEncoder(2, 3, 7);
  Timer1.initialize(1000);
  Timer1.attachInterrupt(timerIsr); last = -1;
  //EEPROM.writeFloat(eepneon1, neon1restart);
  //EEPROM.writeFloat(eepneon2, neon2restart);
  //EEPROM.writeFloat(eepuptime, uptimecountrestart);
  // The following lines can be uncommented to set the date and time
  //rtc.setDOW(FRIDAY);     // Set Day-of-Week to SUNDAY
  //rtc.setTime(1, 07, 00);     // Set the time to 12:00:00 (24hr format)
  //rtc.setDate(17, 6, 2016);   // Set the date to January 1st, 2014ó nap hó év
}
void loop() {//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  millis();
  pumpv = digitalRead (pump);
  plnt0v = digitalRead (plnt0);
  plnt1v = digitalRead (plnt1);

  //idő--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  t = rtc.getTime();
  hour = t.hour;
  min = t.min;
  sec = t.sec;
  allsec = ((hour * 60 * 60) + (min * 60) + sec);
  //neon1oh=EEPROM.readFloat(eepneon1);
  //neon2oh=EEPROM.readFloat(eepneon2);
  //uptimecount=EEPROM.readFloat(eepuptime);

  //etetés------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

  if ((allsec >= eattime) && (feedcount == 0) && (allsec < LED_DOWNFADEOFF)) {
    unsigned long currentMillisdisplay = millis();
    if (currentMillisdisplay - previousMillisdisplay >= intervallcdbl) {
      previousMillisdisplay = currentMillisdisplay;
      if (lcdbls == LOW) {
        lcdbls = HIGH;
      } else {
        lcdbls = LOW;
      }
      digitalWrite(lcdbl, lcdbls); displayowr = 1; delay(100);
    }
  }
  else {
    displayowr = 0;
  }
  if (allsec >= LED_DOWNFADEOFF) {
    feedcount == 0;
  }
  if (displayowr == 0)  {
    if ((value != previousvalue) || (setupvalue != lastsetupvalue)) {
      timeoutTime = millis() + menuTimeout;
      timeoutTime2 = millis() + menuTimeout2;
      previousvalue = value;
      lastsetupvalue = setupvalue;
    }
    if ((allsec >= LED_UPFADEON) && (allsec < LED_DOWNFADEOFF)) {  //nappal van
      if (timeoutTime < millis() && timeoutTime2 > millis()) {
        analogWrite (lcdbl, 10);
      }
      if (timeoutTime > millis()) {
        digitalWrite (lcdbl, HIGH);
      }
      if (timeoutTime2 < millis()) {
        analogWrite (lcdbl, 1);
        delay(890);
      }
    }
    else {
      if (timeoutTime < millis() && timeoutTime2 > millis()) {
        analogWrite (lcdbl, 5);
      }
      if (timeoutTime > millis()) {
        analogWrite (lcdbl, 50);
      }
      if (timeoutTime2 < millis()) {
        analogWrite (lcdbl, 1);
        delay(890);
      }
    }
  }
  //vízszint------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  if (wlscntrl == 0) {
    wlsv = digitalRead(wls);
    if (wlsv == LOW) {
      if ((millis() - previousMilliswlsv > intervalwlsv) && (eledcntrl == 0)) {
        previousMilliswlsv = millis();
        digitalWrite(e1, HIGH);
      }
    }
    if ((millis() - previousMilliswlsv > blinktime) && (eledcntrl == 0)) {
      digitalWrite(e1, LOW);
    }
    if ((wlsv == HIGH) && (eledcntrl == 0)) {
      digitalWrite(e1, LOW);
    }
  }
  if (wlscntrl == 1) {
    if (wlsv == LOW) {
      if ((millis() - previousMilliswlsv > intervalwlsv) && (eledcntrl == 0)) {
        previousMilliswlsv = millis();
        digitalWrite(e1, HIGH);
      }
    }
    if ((millis() - previousMilliswlsv > blinktime) && (eledcntrl == 0)) {
      digitalWrite(e1, LOW);
    }
    if ((wlsv == HIGH) && (eledcntrl == 0)) {
      digitalWrite(e1, LOW);
    }
  }
  if ((eledcntrl == 1) && (lasteled == 1)) {
    digitalWrite(e1, HIGH);
    digitalWrite(e2, HIGH);
  }
  if ((eledcntrl == 1) && (lasteled == 2)) {
    digitalWrite(e1, LOW);
    digitalWrite(e2, LOW);
  }

  //hőmérséklet---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  int sensorReading = ai.read();
  average1 = sensorReading ;
  average1 = 1023 / average1 - 1;
  average1 = SERIESRESISTOR / average1;
  steinhart = THERMISTORNOMINAL / average1 ;     // (R/Ro)
  steinhart = log(steinhart);                  // ln(R/Ro)
  steinhart /= BCOEFFICIENT;                   // 1/B * ln(R/Ro)
  steinhart += 1.0 / (TEMPERATURENOMINAL + 273.15); // + (1/To)
  steinhart = 1.0 / steinhart;                 // Invert
  steinhart = steinhart - 273.5;                         // convert to C

  //fűtés--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  if (wlsv == HIGH) {
    if (heatercntrl == 0) {
      heaterv = digitalRead(heater);
      if ((allsec >= LED_UPFADEOFF) && (allsec < LED_DOWNFADEON)) {           //nappal van
        if (steinhart <= (tempHeaterMin))                           digitalWrite(heater, LOW);
        if (steinhart >= (tempHeaterMax))                           digitalWrite(heater, HIGH);
      }
      else {
        if (steinhart <= (tempHeaterMinNight))                      digitalWrite(heater, LOW);      //éjszaka van
        if (steinhart >= (tempHeaterMaxNight))                      digitalWrite(heater, HIGH);
      }
    }

    if (heatercntrl == 1 && lastheater == 1) digitalWrite (heater, LOW);
    if (heatercntrl == 1 && lastheater == 2) digitalWrite (heater, HIGH);
  }
  if (wlsv == LOW) {
    digitalWrite(heater, HIGH);
  }

  //ventilátor---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  if (waitsteinhart > (millis())) {
    analogWrite(fan, 20); //20-ra kell visszaírni
  }
  else {
    if (fancntrl == 0) {
      if (average1 <= (tempFanMin))                              analogWrite(fan, 20);  //20-ra kell visszaírni
      if ((average1 >= tempFanMin) && (average1 <= tempFanMax))  {
        FANspeed = map(average1, tempFanMin, tempFanMax, 20, 255);
        analogWrite(fan, FANspeed);
      }
      if (average1 > tempFanMax)                                  digitalWrite (fan, HIGH);
    }

    if (steinhart >= tempLedHigh)                                if ((millis() - previousMillistempz > intervaltemp) && (eledcntrl == 0)) {
        previousMillistempz = millis();
        digitalWrite(e2, HIGH);
      }
    if ((steinhart <= tempLedHigh) && (steinhart >= tempLedLow) && (eledcntrl ==  0)) digitalWrite(e2, LOW);
    if (steinhart <= tempLedLow)                                 if ((millis() - previousMillistempz > intervaltemp) && (eledcntrl == 0)) {
        previousMillistempz = millis();
        digitalWrite(e2, HIGH);
      }
  }

  //neon----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  if (neoncntrl == 0); {
    if ((allsec > LED_UPFADEOFF) && (allsec < LED_DOWNFADEON)) {
      digitalWrite (neon, LOW);
    }
    else {
      digitalWrite (neon, HIGH);
    }
  }
  if (neoncntrl == 1 && lastneon == 1) digitalWrite (neon, LOW);
  if (neoncntrl == 1 && lastneon == 2) digitalWrite (neon, HIGH);

  //CO2------------------
  if (co2cntrl == 0); {
    if ((allsec > co2on) && (allsec < co2off)) {
      digitalWrite (co2, LOW);
    }
    else {
      digitalWrite (co2, HIGH);
    }
  }
  if (co2cntrl == 1 && lastco2 == 1) digitalWrite (co2, LOW);
  if (co2cntrl == 1 && lastco2 == 2) digitalWrite (co2, HIGH);
  co2v = digitalRead(co2);

  neonv = digitalRead(neon);
  //if (neonv != lastneonv && neonv==HIGH) {lastneonv=neonv;}
  //if (neonv != lastneonv && neonv==LOW) {lastneonv=neonv; previousMillistube=millis();}
  //if (neonv==LOW && (millis() - previousMillistube >= eepinterval1)){previousMillistube=millis();
  //    neon1oh=(neon1oh + eepintervalhour); EEPROM.updateFloat(eepneon1, neon1oh);
  //    neon2oh=(neon2oh + eepintervalhour); EEPROM.updateFloat(eepneon2, neon2oh);}
  //if (millis() - previousMillisuptime >=eepinterval2) {uptimecount=(uptimecount+eepintervalhour); uptimecount=(uptimecount+eepintervalhour); EEPROM.updateFloat(eepuptime, uptimecount);}

  //LED-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  if (ledcntrl == 0) {
    if (((allsec >= LED_UPFADEON) && (allsec <= LED_UPFADEMIDDLE))) {
      LEDv = map (allsec, LED_UPFADEON, LED_UPFADEMIDDLE, 0, 70);
      analogWrite(LED, LEDv);
    }
    if (((allsec >= LED_UPFADEMIDDLE) && (allsec <= LED_UPFADEOFF))) {
      LEDv = map (allsec, LED_UPFADEMIDDLE, LED_UPFADEOFF, 70, 255);
      analogWrite(LED, LEDv);
    }
    if ((allsec >= LED_DOWNFADEON) && (allsec <= LED_DOWNFADEMIDDLE)) {
      LEDv = map (allsec, LED_DOWNFADEON, LED_DOWNFADEMIDDLE, 255, 70);
      analogWrite(LED, LEDv);
    }
    if ((allsec >= LED_DOWNFADEMIDDLE) && (allsec <= LED_DOWNFADEOFF)) {
      LEDv = map (allsec, LED_DOWNFADEMIDDLE, LED_DOWNFADEOFF, 70, 1);
      analogWrite(LED, LEDv);
    }
    if ((allsec >= LED_DOWNFADEOFF) || (allsec <= LED_UPFADEON)) {
      analogWrite(LED, MoonPWMValue); //MOON
    }
    if ((allsec >= LED_UPFADEOFF) && (allsec < LED_DOWNFADEON)) {
      analogWrite(LED, DayLightPWMValue); //DAYLIGHTPLUS
    }
  }
  if ((millis() - previousMillispump < pumpofftime) && (pumpofftime < millis())) {
    digitalWrite (pump, LOW);
  }
  else {
    digitalWrite (pump, HIGH);
  }

  if ((plnt0cntrl == 0) && (allsec == plnt0time)) {
    previousMillisplnt0 = millis();
  }
  if ((plnt1cntrl == 0) && (allsec == plnt1time)) {
    previousMillisplnt1 = millis();
  }

  if ((millis() - previousMillisplnt0 < plnt0ontime) && (plnt0ontime < millis())) {
    digitalWrite (plnt0, HIGH), (delay (10));
  }
  else {
    digitalWrite (plnt0, LOW);
  }

  if ((millis() - previousMillisplnt1 < plnt1ontime) && (plnt1ontime < millis())) {
    digitalWrite (plnt1, HIGH), (delay (10));
  }
  else {
    digitalWrite (plnt1, LOW);
  }

  value += encoder->getValue(); //------------------------------------------------------------------------------------------------------------------------------------------------------------
  if (value != last) {
    last = value;
    if (value == 3) {
      setupvalue = lastwls;
    }
    if (value == 4) {
      setupvalue = lastheater;
    }
    if (value == 5) {
      setupvalue = lastfan;
    }
    if (value == 6) {
      setupvalue = lastneon;
    }
    if (value == 7) {
      setupvalue = lastled;
    }
    if (value == 8) {
      setupvalue = lastco2;
    }
    if (value == 9) {
      setupvalue = lastplnt0;
    }
    if (value == 10) {
      setupvalue = lastplnt1;
    }
    if (value == 11) {
      setupvalue = lasteled;
    }
  }

  ClickEncoder::Button b = encoder->getButton();
  if (b != ClickEncoder::Open) {
#define VERBOSECASE(label) case label: Serial.println(#label); break;
    switch (b) {
        VERBOSECASE(ClickEncoder::Pressed);
        VERBOSECASE(ClickEncoder::Released);
      case ClickEncoder::Held: {
          (value += 100);
          (previousMillispump = millis());
        }
        break;
    }
  }
  if (value > 12 && value < 80) {
    value = 13;
  }
  if (value >= 100)  {
    value = 100;
  }
  if (value <= 0) {
    value = 0;
  }

  //LCD------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  switch (value) {
    case 0:
      lcd.home();
      lcd.print ("    AQUARIUM    ");
      lcd.setCursor (0, 1);
      lcd.print ("   CONTROLLER   ");
      break;

    case 1:
      lcd.home ();
      lcd.print("Heater:");
      if (heaterv == LOW) {
        lcd.print("ON   ");
      }
      if (heaterv == HIGH) {
        lcd.print("OFF  ");
      }
      lcd.setCursor (12, 0);
      lcd.print ("Temp");
      lcd.setCursor (0, 1);
      lcd.print("Fan:");
      lcd.setCursor (4, 1);
      if (fancntrl == 0) {
        FANsz = map(FANspeed, 0, 255, 0, 99);
        if ((average1 >= tempFanMin) && (average1 <= tempFanMax)) {
          if (FANsz < 10) {
            lcd.print("0");
          } lcd.print(FANsz);
          lcd.print("% ");
        }
        if (average1 <= (tempFanMin)) {
          lcd.print("OFF"); // "Min"
        }
        if (average1 > tempFanMax) {
          lcd.print ("ON ");
        }
      }
      if (fancntrl == 1) {
        lcd.print("OWR");
      }
      lcd.print ("   ");
      if (waitsteinhart > (millis())) {
        lcd.print("----");
      }
      if (waitsteinhart < (millis())) {
        lcd.print (steinhart, 1);
      }
      lcd.print((char)223);
      lcd.print ("C");
      break;


    case 2:
      lcd.home();
      lcd.print("Neon:");
      if (neoncntrl == 0) {
        if (neonv == LOW)
        {
          lcd.print("ON    ");
        }
        else {
          lcd.print ("OFF   ");
        }
      }
      if (neoncntrl == 1 && lastneon == 1) {
        lcd.print("ON    ");
      }
      if (neoncntrl == 1 && lastneon == 2) {
        lcd.print("OFF   ");
      }
      if (t.hour < 10)
      {
        lcd.print("0");
      }
      lcd.print(t.hour, DEC);
      lcd.print(":");
      if (t. min < 10)
      {
        lcd.print("0");
      }
      lcd.print(t.min, DEC);
      lcd.setCursor (0, 1);
      lcd.print("LED:");
      if (ledcntrl == 0) {
        leddisp = map(LEDv, 0, 255, 0, 99);
        if ((allsec >= LED_UPFADEON) && (allsec <= LED_UPFADEOFF)) {
          if (leddisp < 10) {
            lcd.print("0");
          } lcd.print(leddisp);
          lcd.print("% ");
        }
        if ((allsec >= LED_DOWNFADEON) && (allsec <= LED_DOWNFADEOFF)) {
          if (leddisp < 10) {
            lcd.print("0");
          } lcd.print(leddisp);
          lcd.print("% ");
        }
        if ((allsec >= LED_DOWNFADEOFF) || (allsec <= LED_UPFADEON)) {
          lcd.print ("Moon");
        }
        if ((allsec > LED_UPFADEOFF) && (allsec < LED_DOWNFADEON)) {
          lcd.print ("DayL");
        }
      }
      else lcd.print("OWR ");
      lcd.print("  ");
      byte realmonth;
      realmonth = (t.mon);
      if (realmonth == 1)  {
        lcd.print("Jan");
      }
      if (realmonth == 2)  {
        lcd.print("Feb");
      }
      if (realmonth == 3)  {
        lcd.print("Mar");
      }
      if (realmonth == 4)  {
        lcd.print("Apr");
      }
      if (realmonth == 5)  {
        lcd.print("May");
      }
      if (realmonth == 6)  {
        lcd.print("Jun");
      }
      if (realmonth == 7)  {
        lcd.print("Jul");
      }
      if (realmonth == 8)  {
        lcd.print("Aug");
      }
      if (realmonth == 9)  {
        lcd.print("Sep");
      }
      if (realmonth == 10) {
        lcd.print("Oct");
      }
      if (realmonth == 11) {
        lcd.print("Nov");
      }
      if (realmonth == 12) {
        lcd.print("Dec");
      }
      lcd.print("/");
      if (t.date < 10)
      {
        lcd.print("0");
      }
      lcd.print(t.date, DEC);
      break;

    /*  case 3:
      lcd.home();
      lcd.print (F("  Osram 6500K   "));
      lcd.setCursor (0,1);
      lcd.print (F("Op.hrs:"));
      if (neon1oh<10) {lcd.print("      ");}
      if ((neon1oh<100) && (neon1oh>9)) {lcd.print("     ");}
      if ((neon1oh<1000) && (neon1oh>99)) {lcd.print("    ");}
      if ((neon1oh<10000) && (neon1oh>999)) {lcd.print("   ");}
      if ((neon1oh<100000) && (neon1oh>9999)) {lcd.print("  ");}
      if ((neon1oh<1000000) && (neon1oh>99999)) {lcd.print(" ");}
      lcd.print(neon1oh,1);
      lcd.print("h");
      break;

        case 4:
      lcd.home();
      lcd.print ("  Grolux 3000K  ");
      lcd.setCursor (0,1);
      lcd.print (F("Op.hrs:"));
      neon2oh=EEPROM.readFloat(eepneon2);
      if (neon2oh<10) {lcd.print("      ");}
      if ((neon2oh<100) && (neon2oh>9)) {lcd.print("     ");}
      if ((neon2oh<1000) && (neon2oh>99)) {lcd.print("    ");}
      if ((neon2oh<10000) && (neon2oh>999)) {lcd.print("   ");}
      if ((neon2oh<100000) && (neon2oh>9999)) {lcd.print("  ");}
      if ((neon2oh<1000000) && (neon2oh>99999)) {lcd.print(" ");}
      lcd.print(neon2oh,1);
      lcd.print("h");
      break; */

    case 3:
      switch (b) {
        case ClickEncoder::Clicked: setupvalue = (setupvalue + 1);
          break;
        case ClickEncoder::DoubleClicked: lastwls = setupvalue;
          break;
      }
      if (setupvalue > 2) {
        setupvalue = 0;
      }
      if (lastwls > 2) {
        lastwls = 0;
      }
      lcd.home();
      lcd.print ("Water Level: ");
      if (wlscntrl == 0) {
        if (wlsv == HIGH) lcd.print ("HI ");
      }
      if (wlscntrl == 0) {
        if (wlsv == LOW) lcd.print ("LOW");
      }
      if (wlscntrl == 1) lcd.print ("OWR");
      lcd.setCursor (0, 1);
      if (setupvalue == 0 && lastwls == 0) {
        lcd.print F((" #PROG  HI  LOW "));
        (wlscntrl = 0);
      }
      if (setupvalue == 1 && lastwls == 0) {
        lcd.print F((" #PROG >HI  LOW "));
        (wlscntrl = 0);
      }
      if (setupvalue == 2 && lastwls == 0) {
        lcd.print F((" #PROG  HI >LOW "));
        (wlscntrl = 0);
      }
      if (setupvalue == 0 && lastwls == 1) {
        lcd.print F((" >PROG #HI  LOW "));
        (wlscntrl = 1);
        (wlsv = HIGH);
      }
      if (setupvalue == 1 && lastwls == 1) {
        lcd.print F(("  PROG #HI  LOW "));
        (wlscntrl = 1);
        (wlsv = HIGH);
      }
      if (setupvalue == 2 && lastwls == 1) {
        lcd.print F(("  PROG #HI >LOW "));
        (wlscntrl = 1);
        (wlsv = HIGH);
      }
      if (setupvalue == 0 && lastwls == 2) {
        lcd.print F((" >PROG  HI #LOW "));
        (wlscntrl = 1);
        (wlsv = LOW);
      }
      if (setupvalue == 1 && lastwls == 2) {
        lcd.print F(("  PROG >HI #LOW "));
        (wlscntrl = 1);
        (wlsv = LOW);
      }
      if (setupvalue == 2 && lastwls == 2) {
        lcd.print F(("  PROG  HI #LOW "));
        (wlscntrl = 1);
        (wlsv = LOW);
      }
      break;

    case 4:
      switch (b) {
        case ClickEncoder::Clicked: setupvalue = (setupvalue + 1);
          break;
        case ClickEncoder::DoubleClicked: lastheater = setupvalue;
          break;
      }
      if (setupvalue > 2) {
        setupvalue = 0;
      }
      if (lastheater > 2) {
        lastheater = 0;
      }
      lcd.home();
      lcd.print ("Heater State:");
      if (heatercntrl == 0) {
        if (heaterv == HIGH) lcd.print ("OFF");
      }
      if (heatercntrl == 0) {
        if (heaterv == LOW) lcd.print (" ON");
      }
      if (heatercntrl == 1) lcd.print ("OWR");
      lcd.setCursor (0, 1);
      if (setupvalue == 0 && lastheater == 0 && wlsv == HIGH) {
        lcd.print F((" #PROG  ON  OFF "));
        (heatercntrl = 0);
      }
      if (setupvalue == 1 && lastheater == 0 && wlsv == HIGH) {
        lcd.print F((" #PROG >ON  OFF "));
        (heatercntrl = 0);
      }
      if (setupvalue == 2 && lastheater == 0 && wlsv == HIGH) {
        lcd.print F((" #PROG  ON >OFF "));
        (heatercntrl = 0);
      }
      if (setupvalue == 0 && lastheater == 1 && wlsv == HIGH) {
        lcd.print F((" >PROG #ON  OFF "));
        (heatercntrl = 1);
        (heaterv = LOW);
      }
      if (setupvalue == 1 && lastheater == 1 && wlsv == HIGH) {
        lcd.print F(("  PROG #ON  OFF "));
        (heatercntrl = 1);
        (heaterv = LOW);
      }
      if (setupvalue == 2 && lastheater == 1 && wlsv == HIGH) {
        lcd.print F(("  PROG #ON >OFF "));
        (heatercntrl = 1);
        (heaterv = LOW);
      }
      if (setupvalue == 0 && lastheater == 2 && wlsv == HIGH) {
        lcd.print F((" >PROG  ON #OFF "));
        (heatercntrl = 1);
        (heaterv = HIGH);
      }
      if (setupvalue == 1 && lastheater == 2 && wlsv == HIGH) {
        lcd.print F(("  PROG >ON #OFF "));
        (heatercntrl = 1);
        (heaterv = HIGH);
      }
      if (setupvalue == 2 && lastheater == 2 && wlsv == HIGH) {
        lcd.print F(("  PROG  ON #OFF "));
        (heatercntrl = 1);
        (heaterv = HIGH);
      }
      if (wlsv == LOW) {
        lcd.print F(("Low water level!"));
        (heaterv = HIGH);
      }
      break;

    case 5:
      switch (b) {
        case ClickEncoder::Clicked: setupvalue = (setupvalue + 1);
          break;
        case ClickEncoder::DoubleClicked: lastfan = setupvalue;
          break;
      }
      if (setupvalue > 4) {
        setupvalue = 0;
      }
      if (lastfan > 4) {
        lastfan = 0;
      }
      lcd.home();
      lcd.print ("Fan Level:  ");
      if (fancntrl == 0 && (average1 <= (tempFanMin))) {
        lcd.print ("OFF "); //"Min "
      }
      if (fancntrl == 0 && (average1 > (tempFanMin) && (average1 < (tempFanMax)))) {
        if (FANsz < 10) {
          lcd.print("0");
        } FANsz == lcd.print (FANsz);
        lcd.print ("% ");
      }
      if (fancntrl == 0 && (average1 >= (tempFanMin)))  {
        lcd.print ("ON  ");
      }
      if (fancntrl == 1) lcd.print ("OWR ");
      lcd.setCursor (0, 1);
      if (setupvalue == 0 && lastfan == 0) {
        lcd.print F((" #P  0  1  2  3 "));
        (fancntrl = 0);
      }
      if (setupvalue == 1 && lastfan == 0) {
        lcd.print F((" #P >0  1  2  3 "));
        (fancntrl = 0);
      }
      if (setupvalue == 2 && lastfan == 0) {
        lcd.print F((" #P  0 >1  2  3 "));
        (fancntrl = 0);
      }
      if (setupvalue == 3 && lastfan == 0) {
        lcd.print F((" #P  0  1 >2  3 "));
        (fancntrl = 0);
      }
      if (setupvalue == 4 && lastfan == 0) {
        lcd.print F((" #P  0  1  2 >3 "));
        (fancntrl = 0);
      }

      if (setupvalue == 0 && lastfan == 1) {
        lcd.print F((" >P #0  1  2  3 "));
        (fancntrl = 1);
        analogWrite (fan, 0);
      }
      if (setupvalue == 1 && lastfan == 1) {
        lcd.print F(("  P #0  1  2  3 "));
        (fancntrl = 1);
        analogWrite (fan, 0);
      }
      if (setupvalue == 2 && lastfan == 1) {
        lcd.print F(("  P #0 >1  2  3 "));
        (fancntrl = 1);
        analogWrite (fan, 0);
      }
      if (setupvalue == 3 && lastfan == 1) {
        lcd.print F(("  P #0  1 >2  3 "));
        (fancntrl = 1);
        analogWrite (fan, 0);
      }
      if (setupvalue == 4 && lastfan == 1) {
        lcd.print F(("  P #0  1  2 >3 "));
        (fancntrl = 1);
        analogWrite (fan, 0);
      }

      if (setupvalue == 0 && lastfan == 2) {
        lcd.print F((" >P  0 #1  2  3 "));
        (fancntrl = 1);
        analogWrite (fan, 80);
      }
      if (setupvalue == 1 && lastfan == 2) {
        lcd.print F(("  P >0 #1  2  3 "));
        (fancntrl = 1);
        analogWrite (fan, 80);
      }
      if (setupvalue == 2 && lastfan == 2) {
        lcd.print F(("  P  0 #1  2  3 "));
        (fancntrl = 1);
        analogWrite (fan, 80);
      }
      if (setupvalue == 3 && lastfan == 2) {
        lcd.print F(("  P  0 #1 >2  3 "));
        (fancntrl = 1);
        analogWrite (fan, 80);
      }
      if (setupvalue == 4 && lastfan == 2) {
        lcd.print F(("  P  0 #1  2 >3 "));
        (fancntrl = 1);
        analogWrite (fan, 80);
      }

      if (setupvalue == 0 && lastfan == 3) {
        lcd.print F((" >P  0  1 #2  3 "));
        (fancntrl = 1);
        analogWrite (fan, 170);
      }
      if (setupvalue == 1 && lastfan == 3) {
        lcd.print F(("  P >0  1 #2  3 "));
        (fancntrl = 1);
        analogWrite (fan, 170);
      }
      if (setupvalue == 2 && lastfan == 3) {
        lcd.print F(("  P  0 >1 #2  3 "));
        (fancntrl = 1);
        analogWrite (fan, 170);
      }
      if (setupvalue == 3 && lastfan == 3) {
        lcd.print F(("  P  0  1 #2  3 "));
        (fancntrl = 1);
        analogWrite (fan, 170);
      }
      if (setupvalue == 4 && lastfan == 3) {
        lcd.print F(("  P  0  1 #2 >3 "));
        (fancntrl = 1);
        analogWrite (fan, 170);
      }

      if (setupvalue == 0 && lastfan == 4) {
        lcd.print F((" >P  0  1  2 #3 "));
        (fancntrl = 1);
        digitalWrite (fan, HIGH);
      }
      if (setupvalue == 1 && lastfan == 4) {
        lcd.print F(("  P >0  1  2 #3 "));
        (fancntrl = 1);
        digitalWrite (fan, HIGH);
      }
      if (setupvalue == 2 && lastfan == 4) {
        lcd.print F(("  P  0 >1  2 #3 "));
        (fancntrl = 1);
        digitalWrite (fan, HIGH);
      }
      if (setupvalue == 3 && lastfan == 4) {
        lcd.print F(("  P  0  1 >2 #3 "));
        (fancntrl = 1);
        digitalWrite (fan, HIGH);
      }
      if (setupvalue == 4 && lastfan == 4) {
        lcd.print F(("  P  0  1  2 #3 "));
        (fancntrl = 1);
        digitalWrite (fan, HIGH);
      }
      break;

    case 6:
      switch (b) {
        case ClickEncoder::Clicked: setupvalue = (setupvalue + 1);
          break;
        case ClickEncoder::DoubleClicked: lastneon = setupvalue;
          break;
      }
      if (setupvalue > 2) {
        setupvalue = 0;
      }
      if (lastneon > 2) {
        lastneon = 0;
      }
      lcd.home();
      lcd.print ("Neon State: ");
      if (neoncntrl == 0) {
        if (neonv == HIGH) lcd.print ("OFF ");
      }
      if (neoncntrl == 0) {
        if (neonv == LOW) lcd.print (" ON ");
      }
      if (neoncntrl == 1) lcd.print ("OWR ");
      lcd.setCursor (0, 1);
      if (setupvalue == 0 && lastneon == 0) {
        lcd.print F((" #PROG  ON  OFF "));
        (neoncntrl = 0);
      }
      if (setupvalue == 1 && lastneon == 0) {
        lcd.print F((" #PROG >ON  OFF "));
        (neoncntrl = 0);
      }
      if (setupvalue == 2 && lastneon == 0) {
        lcd.print F((" #PROG  ON >OFF "));
        (neoncntrl = 0);
      }
      if (setupvalue == 0 && lastneon == 1) {
        lcd.print F((" >PROG #ON  OFF "));
        (neoncntrl = 1);
      }
      if (setupvalue == 1 && lastneon == 1) {
        lcd.print F(("  PROG #ON  OFF "));
        (neoncntrl = 1);
      }
      if (setupvalue == 2 && lastneon == 1) {
        lcd.print F(("  PROG #ON >OFF "));
        (neoncntrl = 1);
      }
      if (setupvalue == 0 && lastneon == 2) {
        lcd.print F((" >PROG  ON #OFF "));
        (neoncntrl = 1);
      }
      if (setupvalue == 1 && lastneon == 2) {
        lcd.print F(("  PROG >ON #OFF "));
        (neoncntrl = 1);
      }
      if (setupvalue == 2 && lastneon == 2) {
        lcd.print F(("  PROG  ON #OFF "));
        (neoncntrl = 1);
      }
      break;


    case 7:
      switch (b) {
        case ClickEncoder::Clicked: setupvalue = (setupvalue + 1);
          break;
        case ClickEncoder::DoubleClicked: lastled = setupvalue;
          break;
      }
      if (setupvalue > 4) {
        setupvalue = 0;
      }
      if (lastled > 4) {
        lastled = 0;
      }
      lcd.home();
      lcd.print ("LED Level:  ");
      if (ledcntrl == 0) {
        lcd.print ("PROG");
      }
      if (ledcntrl == 1) lcd.print ("OWR ");
      lcd.setCursor (0, 1);
      if (setupvalue == 0 && lastled == 0) {
        lcd.print F((" #P  0  1  2  3 "));
        (ledcntrl = 0);
      }
      if (setupvalue == 1 && lastled == 0) {
        lcd.print F((" #P >0  1  2  3 "));
        (ledcntrl = 0);
      }
      if (setupvalue == 2 && lastled == 0) {
        lcd.print F((" #P  0 >1  2  3 "));
        (ledcntrl = 0);
      }
      if (setupvalue == 3 && lastled == 0) {
        lcd.print F((" #P  0  1 >2  3 "));
        (ledcntrl = 0);
      }
      if (setupvalue == 4 && lastled == 0) {
        lcd.print F((" #P  0  1  2 >3 "));
        (ledcntrl = 0);
      }

      if (setupvalue == 0 && lastled == 1) {
        lcd.print F((" >P #0  1  2  3 "));
        (ledcntrl = 1);
        analogWrite (LED, 0);
      }
      if (setupvalue == 1 && lastled == 1) {
        lcd.print F(("  P #0  1  2  3 "));
        (ledcntrl = 1);
        analogWrite (LED, 0);
      }
      if (setupvalue == 2 && lastled == 1) {
        lcd.print F(("  P #0 >1  2  3 "));
        (ledcntrl = 1);
        analogWrite (LED, 0);
      }
      if (setupvalue == 3 && lastled == 1) {
        lcd.print F(("  P #0  1 >2  3 "));
        (ledcntrl = 1);
        analogWrite (LED, 0);
      }
      if (setupvalue == 4 && lastled == 1) {
        lcd.print F(("  P #0  1  2 >3 "));
        (ledcntrl = 1);
        analogWrite (LED, 0);
      }

      if (setupvalue == 0 && lastled == 2) {
        lcd.print F((" >P  0 #1  2  3 "));
        (ledcntrl = 1);
        analogWrite (LED, 80);
      }
      if (setupvalue == 1 && lastled == 2) {
        lcd.print F(("  P >0 #1  2  3 "));
        (ledcntrl = 1);
        analogWrite (LED, 80);
      }
      if (setupvalue == 2 && lastled == 2) {
        lcd.print F(("  P  0 #1  2  3 "));
        (ledcntrl = 1);
        analogWrite (LED, 80);
      }
      if (setupvalue == 3 && lastled == 2) {
        lcd.print F(("  P  0 #1 >2  3 "));
        (ledcntrl = 1);
        analogWrite (LED, 80);
      }
      if (setupvalue == 4 && lastled == 2) {
        lcd.print F(("  P  0 #1  2 >3 "));
        (ledcntrl = 1);
        analogWrite (LED, 80);
      }

      if (setupvalue == 0 && lastled == 3) {
        lcd.print F((" >P  0  1 #2  3 "));
        (ledcntrl = 1);
        analogWrite (LED, 210);
      }
      if (setupvalue == 1 && lastled == 3) {
        lcd.print F(("  P >0  1 #2  3 "));
        (ledcntrl = 1);
        analogWrite (LED, 210);
      }
      if (setupvalue == 2 && lastled == 3) {
        lcd.print F(("  P  0 >1 #2  3 "));
        (ledcntrl = 1);
        analogWrite (LED, 210);
      }
      if (setupvalue == 3 && lastled == 3) {
        lcd.print F(("  P  0  1 #2  3 "));
        (ledcntrl = 1);
        analogWrite (LED, 210);
      }
      if (setupvalue == 4 && lastled == 3) {
        lcd.print F(("  P  0  1 #2 >3 "));
        (ledcntrl = 1);
        analogWrite (LED, 210);
      }

      if (setupvalue == 0 && lastled == 4) {
        lcd.print F((" >P  0  1  2 #3 "));
        (ledcntrl = 1);
        digitalWrite (LED, HIGH);
      }
      if (setupvalue == 1 && lastled == 4) {
        lcd.print F(("  P >0  1  2 #3 "));
        (ledcntrl = 1);
        digitalWrite (LED, HIGH);
      }
      if (setupvalue == 2 && lastled == 4) {
        lcd.print F(("  P  0 >1  2 #3 "));
        (ledcntrl = 1);
        digitalWrite (LED, HIGH);
      }
      if (setupvalue == 3 && lastled == 4) {
        lcd.print F(("  P  0  1 >2 #3 "));
        (ledcntrl = 1);
        digitalWrite (LED, HIGH);
      }
      if (setupvalue == 4 && lastled == 4) {
        lcd.print F(("  P  0  1  2 #3 "));
        (ledcntrl = 1);
        digitalWrite (LED, HIGH);
      }
      break;

    case 8:
      switch (b) {
        case ClickEncoder::Clicked: setupvalue = (setupvalue + 1);
          break;
        case ClickEncoder::DoubleClicked: lastco2 = setupvalue;
          break;
      }
      if (setupvalue > 2) {
        setupvalue = 0;
      }
      if (lastco2 > 2) {
        lastco2 = 0;
      }
      lcd.home();
      lcd.print ("CO");
      lcd.write(byte(0));
      lcd.print (" Solenoid:");
      if (co2cntrl == 0) {
        if (co2v == HIGH) lcd.print ("OFF");
      }
      if (co2cntrl == 0) {
        if (co2v == LOW) lcd.print (" ON");
      }
      if (co2cntrl == 1) lcd.print ("OWR");
      lcd.setCursor (0, 1);
      if (setupvalue == 0 && lastco2 == 0) {
        lcd.print F((" #PROG  ON  OFF "));
        (co2cntrl = 0);
      }
      if (setupvalue == 1 && lastco2 == 0) {
        lcd.print F((" #PROG >ON  OFF "));
        (co2cntrl = 0);
      }
      if (setupvalue == 2 && lastco2 == 0) {
        lcd.print F((" #PROG  ON >OFF "));
        (co2cntrl = 0);
      }
      if (setupvalue == 0 && lastco2 == 1) {
        lcd.print F((" >PROG #ON  OFF "));
        (co2cntrl = 1);
      }
      if (setupvalue == 1 && lastco2 == 1) {
        lcd.print F(("  PROG #ON  OFF "));
        (co2cntrl = 1);
      }
      if (setupvalue == 2 && lastco2 == 1) {
        lcd.print F(("  PROG #ON >OFF "));
        (co2cntrl = 1);
      }
      if (setupvalue == 0 && lastco2 == 2) {
        lcd.print F((" >PROG  ON #OFF "));
        (co2cntrl = 1);
      }
      if (setupvalue == 1 && lastco2 == 2) {
        lcd.print F(("  PROG >ON #OFF "));
        (co2cntrl = 1);
      }
      if (setupvalue == 2 && lastco2 == 2) {
        lcd.print F(("  PROG  ON #OFF "));
        (co2cntrl = 1);
      }
      break;

    case 9:
      switch (b) {
        case ClickEncoder::Clicked: setupvalue = (setupvalue + 1);
          break;
        case ClickEncoder::DoubleClicked: lastplnt0 = setupvalue;
          break;
      }
      if (setupvalue > 2) {
        setupvalue = 0;
      }
      if (lastplnt0 > 2) {
        lastplnt0 = 0;
      }
      lcd.home();
      lcd.print (" TF Macro: ");
      if (plnt0cntrl == 0) {
        if (plnt0v == LOW) lcd.print ("OFF  ");
      }
      if (plnt0cntrl == 0) {
        if (plnt0v == HIGH) lcd.print ("ON   ");
      }
      if (plnt0cntrl == 1) lcd.print ("OWR  ");
      lcd.setCursor (0, 1);
      if (setupvalue == 0 && lastplnt0 == 0) {
        lcd.print F((" #PROG  1x  OFF "));
        (plnt0cntrl = 0);
      }
      if (setupvalue == 1 && lastplnt0 == 0) {
        lcd.print F((" #PROG >1x  OFF "));
        (plnt0cntrl = 0);
      }
      if (setupvalue == 2 && lastplnt0 == 0) {
        lcd.print F((" #PROG  1x >OFF "));
        (plnt0cntrl = 0);
      }
      if (setupvalue == 1 && lastplnt0 == 1) {
        lcd.print F(("  PROG #1x  OFF "));
        (plnt0cntrl = 1);
        previousMillisplnt0 = millis();
        setupvalue = 0;
        lastplnt0 = 0;
      }
      if (setupvalue == 0 && lastplnt0 == 1) {
        lcd.print F((" >PROG #1x  OFF "));
        (plnt0cntrl = 1);
      }
      if (setupvalue == 1 && lastplnt0 == 1) {
        lcd.print F(("  PROG #1x  OFF "));
        (plnt0cntrl = 1);
      }
      if (setupvalue == 2 && lastplnt0 == 1) {
        lcd.print F(("  PROG #1x >OFF "));
        (plnt0cntrl = 1);
      }
      if (setupvalue == 0 && lastplnt0 == 2) {
        lcd.print F((" >PROG  1x #OFF "));
        (plnt0cntrl = 1);
      }
      if (setupvalue == 1 && lastplnt0 == 2) {
        lcd.print F(("  PROG >1x #OFF "));
        (plnt0cntrl = 1);
      }
      if (setupvalue == 2 && lastplnt0 == 2) {
        lcd.print F(("  PROG  1x #OFF "));
        (plnt0cntrl = 1);
      }
      break;

    case 10:
      switch (b) {
        case ClickEncoder::Clicked: setupvalue = (setupvalue + 1);
          break;
        case ClickEncoder::DoubleClicked: lastplnt1 = setupvalue;
          break;
      }
      if (setupvalue > 2) {
        setupvalue = 0;
      }
      if (lastplnt1 > 2) {
        lastplnt1 = 0;
      }
      lcd.home();
      lcd.print (" EasyCarbo: ");
      if (plnt1cntrl == 0) {
        if (plnt1v == LOW) lcd.print ("OFF ");
      }
      if (plnt1cntrl == 0) {
        if (plnt1v == HIGH) lcd.print ("ON  ");
      }
      if (plnt1cntrl == 1) lcd.print ("OWR ");
      lcd.setCursor (0, 1);
      if (setupvalue == 0 && lastplnt1 == 0) {
        lcd.print F((" #PROG  1x  OFF "));
        (plnt1cntrl = 0);
      }
      if (setupvalue == 1 && lastplnt1 == 0) {
        lcd.print F((" #PROG >1x  OFF "));
        (plnt1cntrl = 0);
      }
      if (setupvalue == 2 && lastplnt1 == 0) {
        lcd.print F((" #PROG  1x >OFF "));
        (plnt1cntrl = 0);
      }
      if (setupvalue == 1 && lastplnt1 == 1) {
        lcd.print F(("  PROG #1x  OFF "));
        (plnt1cntrl = 1);
        previousMillisplnt1 = millis();
        setupvalue = 0;
        lastplnt1 = 0;
      }
      if (setupvalue == 0 && lastplnt1 == 1) {
        lcd.print F((" >PROG #1x  OFF "));
        (plnt1cntrl = 1);
      }
      if (setupvalue == 1 && lastplnt1 == 1) {
        lcd.print F(("  PROG #1x  OFF "));
        (plnt1cntrl = 1);
      }
      if (setupvalue == 2 && lastplnt1 == 1) {
        lcd.print F(("  PROG #1x >OFF "));
        (plnt1cntrl = 1);
      }
      if (setupvalue == 0 && lastplnt1 == 2) {
        lcd.print F((" >PROG  1x #OFF "));
        (plnt1cntrl = 1);
      }
      if (setupvalue == 1 && lastplnt1 == 2) {
        lcd.print F(("  PROG >1x #OFF "));
        (plnt1cntrl = 1);
      }
      if (setupvalue == 2 && lastplnt1 == 2) {
        lcd.print F(("  PROG  1x #OFF "));
        (plnt1cntrl = 1);
      }
      break;

    case 11:
      switch (b) {
        case ClickEncoder::Clicked: setupvalue = (setupvalue + 1);  break;
        case ClickEncoder::DoubleClicked: lasteled = setupvalue;  break;
      }
      if (setupvalue > 2) {
        setupvalue = 0;
      }
      if (lasteled > 2) {
        lasteled = 0;
      }
      lcd.home ();
      lcd.print ("ELED Level: ");
      if (eledcntrl == 0) lcd.print ("PROG");
      if (eledcntrl == 1) lcd.print ("OWR ");
      lcd.setCursor (0, 1);
      if (setupvalue == 0 && lasteled == 0) {
        lcd.print F((" #PROG  ON  OFF "));
        (eledcntrl = 0);
      }
      if (setupvalue == 1 && lasteled == 0) {
        lcd.print F((" #PROG >ON  OFF "));
        (eledcntrl = 0);
      }
      if (setupvalue == 2 && lasteled == 0) {
        lcd.print F((" #PROG  ON >OFF "));
        (eledcntrl = 0);
      }
      if (setupvalue == 0 && lasteled == 1) {
        lcd.print F((" >PROG #ON  OFF "));
        (eledcntrl = 1);
      }
      if (setupvalue == 1 && lasteled == 1) {
        lcd.print F(("  PROG #ON  OFF "));
        (eledcntrl = 1);
      }
      if (setupvalue == 2 && lasteled == 1) {
        lcd.print F(("  PROG #ON >OFF "));
        (eledcntrl = 1);
      }
      if (setupvalue == 0 && lasteled == 2) {
        lcd.print F((" >PROG  ON #OFF "));
        (eledcntrl = 1);
      }
      if (setupvalue == 1 && lasteled == 2) {
        lcd.print F(("  PROG >ON #OFF "));
        (eledcntrl = 1);
      }
      if (setupvalue == 2 && lasteled == 2) {
        lcd.print F(("  PROG  ON #OFF "));
        (eledcntrl = 1);
      }
      break;

    case 12:
      lcd.home();
      uptimesecs = millis() / 1000; //convect milliseconds to seconds
      uptimemins = uptimesecs / 60; //convert seconds to minutes
      uptimehours = uptimemins / 60; //convert minutes to hours
      uptimedays = uptimehours / 24; //convert hours to days
      uptimesecs = uptimesecs - (uptimemins * 60); //subtract the coverted seconds to minutes in order to display 59 secs max
      uptimemins = uptimemins - (uptimehours * 60); //subtract the coverted minutes to hours in order to display 59 minutes max
      uptimehours = uptimehours - (uptimedays * 24); //subtract the coverted hours to days in order to display 23 hours max

      lcd.home();
      lcd.print(" System Uptime: ");
      lcd.setCursor(0, 1);
      if (uptimedays < 10) {
        lcd.print("0");
      }
      lcd.print(uptimedays);
      lcd.print("days, ");
      if (uptimehours < 10) {
        lcd.print("0");
      }
      lcd.print(uptimehours);
      lcd.print(":");
      if (uptimemins < 10) {
        lcd.print("0");
      }
      lcd.print(uptimemins);
      lcd.print(":");
      if (uptimesecs < 10) {
        lcd.print("0");
      }
      lcd.print(uptimesecs);
      break;

    case 100:
      lcd.home ();
      lcd.print("    Pump OFF    ");
      lcd.setCursor(0, 1);
      lcd. print ("   ");
      lcd. print (offpump);
      lcd. print (" minutes    ");
      feedcount = 1; displayowr = 0;
      if ((millis() - previousMillispump) >= intervalpump) {
        (value = 0);
      }

      break;
  }
  delay(100);
  /*Serial.print (F("Water level: "));
      if (wlsv==LOW) Serial.println(F("LOW"));
      if  (wlsv==HIGH)Serial.println(F("NORMAL"));
    Serial.print(F("Temperature "));
      Serial.print(steinhart);
      Serial.println(F(" *C"));
      Serial.println(average1);
    Serial.print(F("HEATER: "));
    if(heaterv==HIGH) {Serial.println(F("OFF"));}
    if(heaterv==LOW) {Serial.println(F("ON"));}
    Serial.print(F("FAN: "));
    if(fan==LOW) {Serial.println(F("OFF"));}
    else {Serial.println(F("ON"));}
    Serial.print(F("PUMP: "));
    if(pumpv==HIGH) {Serial.println(F("ON"));}
    if(pumpv==LOW) {Serial.println(F("OFF"));}
    Serial.print(t.date, DEC);
      Serial.print("/");
      Serial.print(rtc.getMonthStr());
      Serial.print("/");
      Serial.print(t.year, DEC);
      Serial.print(" - ");
      Serial.print(t.hour, DEC);
      Serial.print(":");
      Serial.print(t.min, DEC);
      Serial.print(":");
      Serial.println(t.sec, DEC);
    Serial.print (F("Allsec: "));
    Serial.println(allsec);
    Serial.println(neon1oh);
    Serial.println(neon2oh);
    Serial.println(value);

    Serial.print(F("NEON: "));
    if(neonv==HIGH) {Serial.println(F("OFF"));}
    if(neonv==LOW) {Serial.println(F("ON"));}
    Serial.print(F("LED: "));
    if(LED==MoonPWMValue) {Serial.println(F("MOON"));}
    if(LED==DayLightPWMValue) {Serial.println(F("DAYLIGHT"));}
    if((LED != MoonPWMValue) || (LED != DayLightPWMValue)) {Serial.println(F("FADE"));}
    Serial.println(previousMillispump);
    Serial.println(lastwls); */


}