///////////////////////////////////////////////////////////////////////////////////////////////
//REMINDER * DHTTYPE DHT22 to DHT11
//         * relay_is_inverted to HIGH
//
///////////////////////////////////////////////////////////////////////////////////////////////


#include <DHT.h>
#include <LiquidCrystal_I2C.h>
#include <EEPROM.h>
#include <ESP32Servo.h>

#define DHT1PIN 14
#define DHT2PIN 27
#define DHT1TYPE DHT22
#define DHT2TYPE DHT22
#define e_SIZE 256
DHT dht1(DHT1PIN, DHT1TYPE);
DHT dht2(DHT2PIN, DHT2TYPE);
LiquidCrystal_I2C lcd(0x27, 16,2);

byte Humidity_down_pin = 34;                   //pin for the humidity down button
byte timer_pin = 35;                           //pin for the timer dry button
byte on_off_button = 15;                       //pin for the on/off button
byte Heaterandfanpin = 12;                     //pin for the heater and fan output
byte buzzerPin = 23;                           //pin for the buzzer
int defaulthumiditytarget = 50;                //default humidity target in celcius
int min_humidity_target = 10;                  //minimum humidity target in celcius
unsigned long dry_timer = 30;                  //timer mode dry time in minutes
int alarm_temp = 50;                           //alarm temperature
bool state_changed = HIGH;                     // set HIGH to start in OFF state, low to start in dehumidify state
const int servoPin = 18;                       //servo attatched to this pin
int max_angle = 100;
int Servo_power_pin = 4;                       //2N2222 attatched to this pin


//Defaults - changes to values saved in eeprom
//reverts to defaults if max_temp < 1
int max_temp = 45;                             //max temperature able to set
int temp_lag = 5;                              //wait for temp to drop this value before trning on
unsigned long back_to_on_delay = 0;            //seconds to wait to switch back on to (compressor)
unsigned long backlight_timeout = 5;           //timout in minutes
bool Default_to_prev_humidity = LOW;           //HIGH - revert to previous humidity, LOW - revert to off
bool relay_is_inverted = LOW;                  //set to high if relay output is inverted
unsigned long Main_timeout = 4;                //main timout in hours
int max_motor_temp = 30;                       //switch off for overheat protection

//////////////////////////////////////////////////////////////////////
//dont edit below//dont edit below//dont edit below//dont edit below//
//////////////////////////////////////////////////////////////////////

//saved in eeprom
int e_max_temp;
int e_temp_lag;
unsigned long e_back_to_on_delay;
unsigned long e_backlight_timeout;
bool e_Default_to_prev_humidity;
bool e_relay_is_inverted;
unsigned long e_Main_timeout;
int e_max_motor_temp;

Servo servo;
byte mode = 0;
int savedtemp = 0;
int savedhum = 0;
bool on_off_state = LOW;
int newhumiditytarget = 50; //default humidity target
bool refresh = HIGH;
int before_timer_humidity = 30;
bool timer_already_tripped = HIGH;
int temperature = 10;
int humidity = 10;
bool on_off_pressed_once = LOW;
bool buzzer_state = LOW;

bool temperature_state = HIGH;
unsigned long dehumidify_time1 ;               //counter to check
unsigned long dehumidify_time2 ;               //counter to check
unsigned long saved_dehumidify_time2 ;

bool already_in_mode_0;
bool already_in_mode_1;
bool already_in_mode_2;
bool already_in_mode_3;

bool Humidity_down_pin_state = LOW;

unsigned long time1 ;                          //couter to check
unsigned long time2 ;                          //counter to check
unsigned long time3 ;                          //time1 - time2
unsigned long time4 = 1000;                     //click check maximum for click, minimum for long click

unsigned long any_button_timer ;               //couter to check
unsigned long back_to_on_delay_timer;          //mark switched off state to prevent turn on too soon

int pos = 0;

void setup() {
  //Serial.begin(9600);
  dht1.begin();
  dht2.begin();
  lcd.init();
  lcd.backlight();

  pinMode(18, OUTPUT);
  servo.attach(servoPin, 500, 2400);

  pinMode(on_off_button, INPUT_PULLUP);
  pinMode(Humidity_down_pin, INPUT);
  pinMode(timer_pin, INPUT);
  pinMode(Heaterandfanpin, OUTPUT);
  pinMode(buzzerPin, OUTPUT);
  pinMode(Servo_power_pin, OUTPUT);
  digitalWrite(Heaterandfanpin, relay_is_inverted);                 //TURN OFF

  EEPROM.begin(e_SIZE);
  EEPROM.get(10, e_max_temp);
  EEPROM.get(20, e_temp_lag);
  EEPROM.get(30, e_back_to_on_delay);
  EEPROM.get(40, e_backlight_timeout);
  EEPROM.get(50, e_Main_timeout);
  EEPROM.get(60, e_Default_to_prev_humidity);
  EEPROM.get(70, e_relay_is_inverted);
  EEPROM.get(80, e_max_motor_temp);

  if(e_max_temp > 0){
    max_temp = e_max_temp;
    temp_lag = e_temp_lag;
    back_to_on_delay = e_back_to_on_delay;
    backlight_timeout = e_backlight_timeout;
    Main_timeout= e_Main_timeout;
    Default_to_prev_humidity = e_Default_to_prev_humidity;
    relay_is_inverted = e_relay_is_inverted;
    max_motor_temp = e_max_motor_temp;
  }
} 

void loop() { 

  temperature = dht1.readTemperature();
  humidity = dht1.readHumidity();

  //Read on off button
  if(digitalRead(on_off_button) == LOW && on_off_pressed_once == LOW){
    on_off_pressed_once = HIGH;
    lcd.backlight();
    any_button_timer = millis();
    time1 = millis();
    state_changed = LOW;
    delay(100);
  }
  if(digitalRead(on_off_button) == HIGH && on_off_pressed_once == HIGH){
    on_off_pressed_once = LOW;
    time2 = millis();
    delay(100);
    time3 = time2 - time1; // DEFINITION OF time3 - DONT CHANGE THIS - for click and long click
  }

  //put into menu mode if long click
  if(time3 < time4 && state_changed == LOW){
    state_changed = HIGH;
    refresh = HIGH;
    if(mode >= 4 && mode <= 12){
      mode = mode + 1;
    }
    if(mode > 12){ // mode == 12 // reminder to find this when adding a new menu option
      mode = 4;
    }
  }

  //power off after main timer
  if(millis() - any_button_timer >= Main_timeout*60000*60){
    mode = 0;
  }

  //Backlight timeout
  if(millis() - any_button_timer >= backlight_timeout*60000){
    lcd.noBacklight();
  }

  //reset to mode 0 from mode 1, 2 or 3
  if(digitalRead(on_off_button) == LOW && (mode == 1 || mode == 2 || mode == 3)){
    mode = 0;
    refresh = HIGH;
  }

  //menu - put into menu mode
  if(time3 > time4 && state_changed == LOW && on_off_pressed_once == LOW){
    state_changed = HIGH;
    refresh = HIGH;
    if(mode >= 0 && mode <=3){
      mode = 4;
    } 
    else if( mode >=4){
      mode = 0;
    }
  }

  //Refresh dislay if TEMPERATURE value change
  if(savedtemp < temperature || savedtemp > temperature){
    savedtemp = temperature;
    refresh = HIGH;
  }
  //Refresh dislay if HUMIDITY value change
  if(savedhum < humidity || savedhum > humidity){
    savedhum = humidity;
    refresh = HIGH;
  }

  //LOW TEMPSTATE WHAT TO DO IN LOW TEMP STATE
  if(temperature <= max_temp){
    if(temperature_state == HIGH){
      temperature_state = LOW;
    }
    
    if(temperature <= max_temp - temp_lag){
      if(humidity > newhumiditytarget){
        if (mode == 1 || mode == 2 || mode == 3){
          if(on_off_state  == LOW){
            if(millis() - back_to_on_delay_timer > back_to_on_delay*1000){
              on_off_state = HIGH;
              digitalWrite(Heaterandfanpin, !relay_is_inverted);                    //TURN ON
              digitalWrite(Servo_power_pin, HIGH);
              //  for loop that decreases the angle by 1 from max_angle to 0 with a delay of 10 ms per angle
              for (pos = max_angle; pos >= 0; pos -= 1) {
                servo.write(pos);
                delay(10);
              }
              delay(2000);
              digitalWrite(Servo_power_pin, LOW);
              refresh = HIGH;
            }
          }
        }
      }
    }
  }

  //HIGH TEMPSTATE WHAT TO DO IN HIGH TEMP STATE
  if(temperature > max_temp && temperature_state == LOW){
    temperature_state = HIGH;
    digitalWrite(Heaterandfanpin, relay_is_inverted);                   //TURN OFF
    digitalWrite(Servo_power_pin, HIGH);
    //  for loop that increases the angle by 1 from 0 to max_angle with a delay of 10 ms per angle
    for (pos = 0; pos <= max_angle; pos += 1) {
      servo.write(pos);
      delay(10);
    }
    delay(2000);
    digitalWrite(Servo_power_pin, LOW);
    on_off_state = LOW;
    back_to_on_delay_timer = millis();
    refresh = HIGH;
  }

  //ALARM STATE
  if(temperature >= alarm_temp){
    tone(buzzerPin, 2300);
    on_off_state = LOW;
    delay(100);
    buzzer_state = HIGH;
  }
  if(temperature < max_temp && buzzer_state == HIGH){
    buzzer_state = LOW;
    noTone(buzzerPin);
    delay(100);
    servo.attach(servoPin, 500, 2400);
  }

  //MODE 0 - OFF
  if(mode == 0 && already_in_mode_0 == LOW){
    already_in_mode_0 = HIGH;
    already_in_mode_1 = LOW;
    already_in_mode_2 = LOW;
    already_in_mode_3 = LOW;
    digitalWrite(Heaterandfanpin, relay_is_inverted);               //TURN OFF
    digitalWrite(Servo_power_pin, HIGH);
    lcd.setCursor(0,0);
    lcd.print("CLOSING DAMPENER");
    //  for loop that increases the angle by 1 from 0 to max_angle with a delay of 10 ms per angle
    for (pos = 0; pos <= max_angle; pos += 1) {
      servo.write(pos);
      delay(10);
    }
    delay(2000);
    digitalWrite(Servo_power_pin, LOW);
    on_off_state = LOW;
    back_to_on_delay_timer = millis();
    newhumiditytarget = defaulthumiditytarget;
    timer_already_tripped = HIGH;
    refresh = HIGH;
  }

  //MODE 1 - STANDBY
  if(mode == 1){
    //GO TO MODE 2 IF HIGH HUMIDITY
    if(humidity > newhumiditytarget){
      mode = 2;
    }
    if(already_in_mode_1 == LOW){
      already_in_mode_0 = LOW;
      already_in_mode_1 = HIGH;
      already_in_mode_2 = LOW;
      already_in_mode_3 = LOW;
      digitalWrite(Heaterandfanpin, relay_is_inverted);                  //TURN OFF
      digitalWrite(Servo_power_pin, HIGH);
      lcd.setCursor(0,0);
      lcd.print("CLOSING DAMPENER");
      //  for loop that increases the angle by 1 from 0 to max_angle with a delay of 10 ms per angle
      for (pos = 0; pos <= max_angle; pos += 1) {
        servo.write(pos);
        delay(10);
      }
      delay(2000);
      digitalWrite(Servo_power_pin, LOW);
      on_off_state = LOW;
      back_to_on_delay_timer = millis();
      refresh = HIGH;
    }
  } 

  //DEHUMIDIFYING BUTTON
  if (digitalRead(Humidity_down_pin) == LOW && Humidity_down_pin_state == LOW){
    Humidity_down_pin_state = HIGH;
    lcd.backlight();
    any_button_timer = millis();
    refresh = HIGH;
    //PUT INTO MODE 2
    if(mode == 0 || mode == 3){
      mode = 2;
      newhumiditytarget = defaulthumiditytarget;
    }
    else if(mode == 1 || mode == 2){
      //REDUCE TARGET HUMIDITY - ONLY IF IN MODE 1 OR 2
      if(newhumiditytarget > min_humidity_target){                      //if the humidity above min humidity 
        newhumiditytarget = newhumiditytarget - 5;                      //subtract 5%
      }
      //GO BACK TO DEFAULT HUMIDITY
      else {
        newhumiditytarget = defaulthumiditytarget;                      //otherwise reset to default min
      }
    }
    delay(50);
  } 
  else if(digitalRead(Humidity_down_pin) == HIGH && Humidity_down_pin_state == HIGH){
    Humidity_down_pin_state = LOW;
    delay(50);
  }

  //MODE 2 - ACTION - MAINLY TRIGGER TURN ON RELAY AND RESET TIMER
  if(mode == 2){
    //GO TO MODE 1 IF LOW HUMIDITY
    if(humidity < newhumiditytarget){
      mode = 1;
    }
    if(already_in_mode_2 == LOW){
      already_in_mode_0 = LOW;
      already_in_mode_1 = LOW;
      already_in_mode_2 = HIGH;
      already_in_mode_3 = LOW;
      if(temperature < max_temp){
        if(millis() - back_to_on_delay_timer > back_to_on_delay*1000){
          if(on_off_state == LOW){
            on_off_state = HIGH;
            digitalWrite(Heaterandfanpin, !relay_is_inverted);               //TURN ON
            digitalWrite(Servo_power_pin, HIGH);
            lcd.setCursor(0,0);
            lcd.print("OPENING DAMPENER");
            //  for loop that decreases the angle by 1 from max_angle to 0 with a delay of 10 ms per angle
            for (pos = max_angle; pos >= 0; pos -= 1) {
              servo.write(pos);
              delay(10);
            }
            delay(2000);
            digitalWrite(Servo_power_pin, LOW);
          } 
        }
      }
      timer_already_tripped = LOW;
      refresh = HIGH;
      delay(500);
    }
  }

  //MODE 3 - TRIGGER TIMER ON BUTTON PRESS
  if(digitalRead(timer_pin) == LOW && (mode == 0 || mode == 1 || mode == 2 || mode == 3)){
    mode = 3;
    lcd.backlight();
    any_button_timer = millis();
    on_off_pressed_once = LOW;
    already_in_mode_0 = LOW;
    dehumidify_time1 = millis();
    timer_already_tripped = LOW;
    saved_dehumidify_time2 = 0;
    if(temperature < max_temp){
      if(millis() - back_to_on_delay_timer > back_to_on_delay*1000 && on_off_state == LOW){
        digitalWrite(Heaterandfanpin, !relay_is_inverted);                    //TURN ON
        digitalWrite(Servo_power_pin, HIGH);
        //  for loop that decreases the angle by 1 from max_angle to 0 with a delay of 10 ms per angle
        for (pos = max_angle; pos >= 0; pos -= 1) {
          servo.write(pos);
          delay(10);
        }        
        delay(2000);
        digitalWrite(Servo_power_pin, LOW);
        on_off_state = HIGH;
      }
    }
    if(newhumiditytarget != 0){
      before_timer_humidity = newhumiditytarget;
      newhumiditytarget = 0;
      refresh = HIGH;
    }
  }

  //MODE 3
  if(mode == 3){
    //RESET OTHER MODES
    if(already_in_mode_3 == LOW){
      already_in_mode_0 = LOW;
      already_in_mode_1 = LOW;
      already_in_mode_2 = LOW;
      already_in_mode_3 = HIGH;
    }
    //TIMER TIMING
    dehumidify_time2 = millis() - dehumidify_time1;
    if(dehumidify_time2 >= saved_dehumidify_time2 + 1000){
      saved_dehumidify_time2 = dehumidify_time2;
    }
    //TIMER EXPIRED
    if(dehumidify_time2 >= dry_timer*60000 && timer_already_tripped == LOW){
      timer_already_tripped = HIGH;
      newhumiditytarget = before_timer_humidity;                    // restore to prev humidity target
      refresh = HIGH;
      if(Default_to_prev_humidity == HIGH){
        mode = 2;
      }
      else{
        mode = 0;
        on_off_state = LOW;
      }
    }  
  }

  //MODE 4 - MENU - change max temp
  if (mode == 4){
    if(digitalRead(Humidity_down_pin) == LOW){
      max_temp = max_temp + 1;
      refresh = HIGH;
      delay(500);
    }
    if(digitalRead(timer_pin) == LOW){
      max_temp = max_temp - 1;
      refresh = HIGH;
      delay(500);
    }
  }

  //MODE 5 - MENU - change max temp
  if (mode == 5){
    if(digitalRead(Humidity_down_pin) == LOW){
      temp_lag = temp_lag + 1;
      refresh = HIGH;
      delay(500);
    }
    if(digitalRead(timer_pin) == LOW){
      temp_lag = temp_lag - 1;
      refresh = HIGH;
      delay(500);
    }
  }

  //MODE 6 - MENU - change switch on delay
  if (mode == 6){
    if(digitalRead(Humidity_down_pin) == LOW){
      back_to_on_delay = back_to_on_delay + 1;
      refresh = HIGH;
      delay(500);
    }
    if(digitalRead(timer_pin) == LOW){
      back_to_on_delay = back_to_on_delay - 1;
      refresh = HIGH;
      delay(500);
    }
  }

  //MODE 7 - MENU - change backlight timeout
  if(mode == 7){
    //increments of 1
    if(backlight_timeout >= 0 && backlight_timeout < 10){
      if(digitalRead(Humidity_down_pin) == LOW){
        backlight_timeout = backlight_timeout + 1;
        refresh = HIGH;
        delay(500);
      }
      if(digitalRead(timer_pin) == LOW){
        backlight_timeout = backlight_timeout - 1;
        refresh = HIGH;
        delay(500);
      }      
    }
    //increments of 10
    else if(backlight_timeout >= 10){
      if(digitalRead(Humidity_down_pin) == LOW){
        backlight_timeout = backlight_timeout + 10;
        refresh = HIGH;
        delay(500);
      }
      if(digitalRead(timer_pin) == LOW){
        backlight_timeout = backlight_timeout - 10;
        refresh = HIGH;
        delay(500);
      }
    }
  }

  //MODE 8 - MENU - change main timeout period (the long one)
  if(mode == 8){
    if(digitalRead(Humidity_down_pin) == LOW){
      Main_timeout = Main_timeout + 1;
      refresh = HIGH;
      delay(500);
    }
    if(digitalRead(timer_pin) == LOW && Main_timeout > 1){
      Main_timeout = Main_timeout - 1;
      refresh = HIGH;
      delay(500);
    }
  }

  //MODE 9 - MENU - change the default timeout behaviour
  if(mode == 9){
    if(digitalRead(Humidity_down_pin) == LOW){
      Default_to_prev_humidity = LOW;
      refresh = HIGH;
      delay(500);
    }
    if(digitalRead(timer_pin) == LOW && Main_timeout > 1){
      Default_to_prev_humidity = HIGH;
      refresh = HIGH;
      delay(500);
    }
  }

  //MODE 10 - MENU - change the output relay inversion
  if(mode == 10){
    if(digitalRead(Humidity_down_pin) == LOW){
      relay_is_inverted = LOW;
      refresh = HIGH;
      delay(500);
    }
    if(digitalRead(timer_pin) == LOW){
      relay_is_inverted = HIGH;
      refresh = HIGH;
      delay(500);
    }
  }

  //MODE 11 - MENU - OVERHEAT TEMP
  if(mode == 11){
    if(digitalRead(Humidity_down_pin) == LOW){
      max_motor_temp = max_motor_temp + 1;
      refresh = HIGH;
      delay(500);
    }
    if(digitalRead(timer_pin) == LOW){
      max_motor_temp = max_motor_temp - 1;
      refresh = HIGH;
      delay(500);
    }
  }

  //mode == 12 - MENU - save to eeprom
  if(mode == 12){
    if(digitalRead(Humidity_down_pin) == LOW){

      for (int i = 0; i < 512; i++) {
      EEPROM.write(i, 0);
      }
      EEPROM.commit();
      delay(500);   

      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("EEPROM WIPED!");

      EEPROM.put(10, max_temp);
      EEPROM.commit();
      delay(100);
      EEPROM.put(20, temp_lag);
      EEPROM.commit();
      delay(100);   
      EEPROM.put(30, back_to_on_delay);
      EEPROM.commit();
      delay(100);  
      EEPROM.put(40, backlight_timeout);
      EEPROM.commit();
      delay(100);   
      EEPROM.put(50, Main_timeout);
      EEPROM.commit();
      delay(100);   
      EEPROM.put(60, Default_to_prev_humidity);
      EEPROM.commit();
      delay(100);   
      EEPROM.put(70, relay_is_inverted);
      EEPROM.commit();
      delay(100); 
      EEPROM.put(80, max_motor_temp);
      EEPROM.commit();
      delay(100); 

      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("SAVED TO EEPROM!");
      delay(2000);
      mode = 0;
      already_in_mode_0 = LOW;
      refresh = HIGH;
    }
  }  

  //LCD
  if(refresh == HIGH){
    lcd.clear();
    refresh = LOW;

    if(mode == 0){
      lcd.setCursor(0,0);
      lcd.print("OFF");
      lcd.setCursor(0,1);
      lcd.print(temperature);
      lcd.print((char)223);
      lcd.print("C");
      if(temperature > max_temp){
        lcd.print("!");
      }
      lcd.setCursor(8,1);
      lcd.print(humidity);
      lcd.print("%");
    }

    if(mode == 1){
      lcd.setCursor(0,0);
      lcd.print("STANDBY");
      lcd.setCursor(0,1);
      lcd.print(temperature);
      lcd.print((char)223);
      lcd.print("C");
      if(temperature > max_temp){
        lcd.print("!");
      }
      lcd.setCursor(8,1);
      lcd.print(humidity);
      lcd.print("%");
      lcd.print((char)126);
      lcd.print(newhumiditytarget);
      lcd.print("%");
    }

    if(mode == 2){
      lcd.setCursor(0,0);
      lcd.print("DRYING FILAMENT");
      lcd.setCursor(0,1);
      lcd.print(temperature);
      lcd.print((char)223);
      lcd.print("C");
      if(temperature > max_temp){
        lcd.print("!");
      }
      lcd.setCursor(8,1);
      lcd.print(humidity);
      lcd.print("%");
      lcd.print((char)126);
      lcd.print(newhumiditytarget);
      lcd.print("%");
    }

    if(mode == 3){
      lcd.setCursor(0,0);
      lcd.print("TIMER");
      lcd.setCursor(8,0);
      lcd.print(dry_timer - dehumidify_time2/60000);
      lcd.print(" min");
      lcd.setCursor(0,1);
      lcd.print(temperature);
      lcd.print((char)223);
      lcd.print("C");
      if(temperature > max_temp){
        lcd.print("!");
      }
      lcd.setCursor(8,1);
      lcd.print(humidity);
      lcd.print("%");
      lcd.print((char)126);
      lcd.print(newhumiditytarget);
      lcd.print("%");
    }    

    if(mode == 4){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("MAX TEMP");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(1,1);
      lcd.print(max_temp);
      lcd.print((char)223); 
      lcd.print("C");           
    }  

    if(mode == 5){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("TEMP LAG");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(1,1);
      lcd.print(temp_lag);
      lcd.print((char)223); 
      lcd.print("C");       
    } 

    if(mode == 6){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("ON DELAY");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(1,1);
      lcd.print(back_to_on_delay);  
      lcd.print(" SECONDS");         
    }       

    if(mode == 7){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("LIGHT TIMEOUT");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(1,1);
      lcd.print(backlight_timeout);
      if(backlight_timeout == 1){
        lcd.print(" MINUTE");
      }
      else{
        lcd.print(" MINUTES");
      }
    } 

    if(mode == 8){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("MAIN TIMEOUT");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(1,1);
      lcd.print(Main_timeout);
      if(Main_timeout == 1){
        lcd.print(" HOUR");
      }
      else{
        lcd.print(" HOURS");
      }
    } 

    if(mode == 9){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("TIME END INTO");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(1,1);
      if(Default_to_prev_humidity == HIGH){
        lcd.print("DEHUMIDIFY");
      }
      else{
        lcd.print("OFF MODE");
      } 
    }

    if(mode == 10){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("RELAY MODE");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(1,1);
      if(relay_is_inverted == HIGH){
        lcd.print("INVERTED");
      }
      else{
        lcd.print("NORMAL");
      } 
    }

    if(mode == 11){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("OVERHEAT TEMP    ");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(1,1);
      lcd.print(max_motor_temp);
      lcd.print((char)223); 
      lcd.print("C");  
    }

    if(mode == 12){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("SAVE TO EEPROM");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(0,1);
      lcd.print("LONGCLICK = EXIT");
    }
  }
}