/////////////////////////////////////////////////////////////////////////////////////////////////////
//REMINDER * relay_is_inverted to HIGH
//         * hold in select button to NOT LOAD EEPROM and save default values to EEPROM on first boot
//         * DHT11
//         * Version 1.0
/////////////////////////////////////////////////////////////////////////////////////////////////////

#include <math.h>
#include <DHT.h>
#include <LiquidCrystal_I2C.h>
#include <EEPROM.h>
#include <ESP32Servo.h>
#include <Adafruit_BMP280.h>
#include <Adafruit_AHTX0.h>

Adafruit_BMP280 bmp;
Adafruit_AHTX0 aht;

#define e_SIZE 256
#define DHT2PIN 27
#define DHT2TYPE DHT11

Servo servo;
DHT dht2(DHT2PIN, DHT2TYPE);
LiquidCrystal_I2C lcd(0x27, 16,2);

//inputs
byte select_button = 32;                       //pin for the on/off button
byte up_button = 34;                           //pin for the humidity down button
byte down_button = 35;                         //pin for the timer dry button

//outputs
byte heater_and_fan_pin = 12;                  //pin for the heater and fan output
byte buzzer_pin = 23;                          //pin for the buzzer
const int servo_pin = 18;                      //servo attatched to this pin
int servo_power_pin = 4;                       //2N2222 attatched to this pin

//configurable variables
int max_temp = 40;                             //1 - max temperature able to set
int temp_lag = 1;                              //2 - wait for temp to drop this value before trning on
unsigned long back_to_on_delay = 10;           //3 - seconds to wait to switch back on to (compressor)
unsigned long backlight_timeout = 60;          //4 - minutes
unsigned long main_timeout = 4;                //5 - hours
bool Default_to_prev_humidity = LOW;           //6 - HIGH = revert to previous humidity, LOW = revert to off
bool relay_is_inverted = HIGH;                 //7 - set to high if relay output is inverted
unsigned long humidity_stall_duration = 10;    //8 - minutes to wait before calling stall
int alarm_temp = 50;                           //9 - alarm temperature
int default_humidity_target = 50;              //10 - default humidity target in celcius
int min_humidity_target = 10;                  //11 - minimum humidity target in celcius
unsigned long dry_timer = 30;                  //12 - timer mode dry time in minutes
int min_angle = 0;                             //13 - minimum servo angle
int max_angle = 180;                           //14 - maximum servo angle
int smart_mode_delta = 5;                      //15 - difference in humidity for smatrt mode
//                                             //16 - save to eeprom
//                                             //17 - exit

//local variables
bool alarm_triggered = LOW;
unsigned long any_button_timer;
bool mode_triggered_once = LOW;
bool timer_already_tripped = LOW;
bool dampener = LOW;
bool heater_and_fan = LOW;
int pos = 0;
int display_mode = 0;
int box_temp;
int box_humidity;
int new_humidity_target;
int outside_temp;
int outside_humidity;
bool heater_and_fan_state = LOW;
unsigned long back_to_on_delay_timer;          //mark switched off state to prevent turn on too soon
int saved_temp;
int saved_hum;
unsigned long time1;
unsigned long time2;
unsigned long time3;
bool select_button_pressed_once;
bool up_button_pressed_once;
bool down_button_pressed_once;
bool refresh;
int mode = 0;
int settings_mode;
int mode_selector = 0;
unsigned long saved_timer1; //countingdown value
unsigned long saved_timer2; //saved counting down value
bool dampener_state = LOW;
unsigned long refresh_buffer = 0;
int new_min_humidity;                          //temp saved value of min humidity
int saved_minHumidity;                         //temp saved value of min humidity
unsigned long stalled_time_timestamp;          //the millis saved at the moment of reset
unsigned long stalled_time = 0;                //timer counting up from reset           
unsigned long drying_duration = 0;             //millis value of duration in mode 2 (for LCD timer)
unsigned long drying_duration_timestamp;       //time stamp of entering mode 2

//saved in eeprom
int e_max_temp;
int e_temp_lag;
unsigned long e_back_to_on_delay;
unsigned long e_backlight_timeout;
unsigned long e_main_timeout;
bool e_Default_to_prev_humidity;
bool e_relay_is_inverted;
unsigned long e_humidity_stall_duration;
int e_alarm_temp;
int e_default_humidity_target;
int e_min_humidity_target;
unsigned long e_dry_timer;
int e_min_angle;
int e_max_angle;
int e_smart_mode_delta;


// Humidity Calculation
float calculateMinHumidity(float outside_temp, float outside_humidity, float max_temp) {
  // Handle invalid temperatures
  if (isnan(outside_temp) || isnan(max_temp) || outside_temp < -40 || max_temp < -40) {
    return NAN;
  }
  
  // Magnus formula calculation
  float termOut = outside_temp / (outside_temp + 243.5);
  float termIn = max_temp / (max_temp + 243.5);
  float exponent = 17.67 * (termOut - termIn);
  float minRH = outside_humidity * exp(exponent);
  
  // Constrain to physical limits
  return constrain(minRH, 0.0, 100.0);
}

///////////////////////////////////////////////////////////////////////////////////////////////////////

void setup() {
  Serial.begin(115200);

  //DONT REMOVE THIS//DONT REMOVE THIS//DONT REMOVE THIS//
  if (! aht.begin()) {
    Serial.println("Could not find AHT? Check wiring");
    while (1) delay(10);
  }
  ////////////////////////////////////////////////////////

  Serial.println("AHT10 or AHT20 found");

  dht2.begin();
  lcd.init();
  lcd.backlight();

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

  pinMode(select_button, INPUT_PULLDOWN);
  pinMode(up_button, INPUT_PULLDOWN);
  pinMode(down_button, INPUT_PULLDOWN);

  pinMode(heater_and_fan_pin, OUTPUT);
  pinMode(buzzer_pin, OUTPUT);
  pinMode(servo_power_pin, OUTPUT);

  digitalWrite(heater_and_fan_pin, relay_is_inverted);                 //turn off heater
  digitalWrite(servo_power_pin, HIGH);                                 //power to servo on
  delay(1000);                                                         //wait for servo power on
  for (pos = min_angle; pos <= max_angle; pos += 1) {
    servo.write(pos);
    delay(10);
  }
  digitalWrite(servo_power_pin, LOW);                                 //power to servo off

  EEPROM.begin(e_SIZE);
  EEPROM.get(5, e_max_temp);
  EEPROM.get(10, e_temp_lag);
  EEPROM.get(15, e_back_to_on_delay);
  EEPROM.get(20, e_backlight_timeout);
  EEPROM.get(25, e_main_timeout);
  EEPROM.get(30, e_Default_to_prev_humidity);
  EEPROM.get(35, e_relay_is_inverted);
  EEPROM.get(40, e_humidity_stall_duration);
  EEPROM.get(45, e_alarm_temp);
  EEPROM.get(50, e_default_humidity_target);
  EEPROM.get(55, e_min_humidity_target);
  EEPROM.get(60, e_dry_timer);
  EEPROM.get(65, e_min_angle);
  EEPROM.get(70, e_max_angle);
  EEPROM.get(75, e_smart_mode_delta);


  //hold in select button to NOT LOAD EEPROM and save default values to EEPROM on first boot
  if(digitalRead(select_button) == LOW){
    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;
    humidity_stall_duration  = e_humidity_stall_duration;
    alarm_temp = e_alarm_temp;
    default_humidity_target = e_default_humidity_target;
    min_humidity_target = e_min_humidity_target;
    dry_timer = e_dry_timer;
    min_angle = e_min_angle;
    max_angle = e_max_angle;
    smart_mode_delta = e_smart_mode_delta;

    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("EEPROM LOADED");
    delay(1000);
  }
  else if(digitalRead(select_button) == HIGH){
    for (int i = 0; i < 512; i++) {
    EEPROM.write(i, 0);
    }
    EEPROM.commit();
    delay(500);   

    EEPROM.put(5, max_temp);
    EEPROM.commit();
    delay(100);
    EEPROM.put(10, temp_lag);
    EEPROM.commit();
    delay(100);   
    EEPROM.put(15, back_to_on_delay);
    EEPROM.commit();
    delay(100);  
    EEPROM.put(20, backlight_timeout);
    EEPROM.commit();
    delay(100);   
    EEPROM.put(25, main_timeout);
    EEPROM.commit();
    delay(100);   
    EEPROM.put(30, Default_to_prev_humidity);
    EEPROM.commit();
    delay(100);   
    EEPROM.put(35, relay_is_inverted);
    EEPROM.commit();
    delay(100); 
    EEPROM.put(40, humidity_stall_duration);
    EEPROM.commit();
    delay(100); 
    EEPROM.put(45, alarm_temp);
    EEPROM.commit();
    delay(100); 
    EEPROM.put(50, default_humidity_target);
    EEPROM.commit();
    delay(100); 
    EEPROM.put(55, min_humidity_target);
    EEPROM.commit();
    delay(100); 
    EEPROM.put(60, dry_timer);
    EEPROM.commit();
    delay(100); 
    EEPROM.put(65, min_angle);
    EEPROM.commit();
    delay(100); 
    EEPROM.put(70, max_angle);
    EEPROM.commit();
    delay(100); 
    EEPROM.put(75, smart_mode_delta);
    EEPROM.commit();
    delay(100); 

    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("EEPROM SAVED");
    delay(1000);
  }
  while(max_temp == -1){
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("ERROR!");
    lcd.setCursor(0,1);
    lcd.print("NO EEPROM VALUE");
    delay(2000);
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("HOLD SELECT");
    lcd.setCursor(0,1);
    lcd.print("WHILE REBOOT");
    delay(2000);
  }
} 

///////////////////////////////////////////////////////////////////////////////////////////////////////

void loop() {


  sensors_event_t humidity, temp;
  aht.getEvent(&humidity, &temp);// populate temp and humidity objects with fresh data

  //read box temp and humidity
  box_temp = (int)(temp.temperature);
  box_humidity = (int)(humidity.relative_humidity);

  //read outside temp and humidity
  outside_temp = dht2.readTemperature();
  outside_humidity = dht2.readHumidity();

  // Calculate minimum achievable humidity
  float minHumidity = calculateMinHumidity(outside_temp, outside_humidity, max_temp);

  Serial.println((back_to_on_delay_timer - millis())/1000);

  //Read select button
  if(digitalRead(select_button) == HIGH && select_button_pressed_once == LOW){
    select_button_pressed_once = HIGH;
    time1 = millis();
    Serial.println("select pressed");
    delay(100);
  }
  else if(digitalRead(select_button) == LOW && select_button_pressed_once == HIGH){
    select_button_pressed_once = LOW;
    time2 = millis();
    Serial.println("select released");
    delay(100);
    time3 = time2 - time1; // DEFINITION OF time3 - DONT CHANGE THIS - for click and long click
  }
  
  //Read up button
  if(digitalRead(up_button) == HIGH && up_button_pressed_once == LOW){
    up_button_pressed_once = HIGH;
    Serial.println("up pressed");
    delay(100);
  }
  else if(digitalRead(up_button) == LOW && up_button_pressed_once == HIGH){
    up_button_pressed_once = LOW;
    Serial.println("up released");
    delay(100);
  }

  //Read down button
  if(digitalRead(down_button) == HIGH && down_button_pressed_once == LOW){
    down_button_pressed_once = HIGH;
    Serial.println("down pressed");
    delay(100);
  }
  else if(digitalRead(down_button) == LOW && down_button_pressed_once == HIGH){
    down_button_pressed_once = LOW;
    Serial.println("down released");
    delay(100);
  }

  //Read any button to reset timer
  if(select_button_pressed_once == HIGH|| up_button_pressed_once == HIGH || down_button_pressed_once == HIGH){
    any_button_timer = millis();
    lcd.backlight();
    refresh = HIGH;
    new_min_humidity = box_humidity;
    stalled_time_timestamp = millis();
    drying_duration_timestamp = millis();
    drying_duration = 0;
  }

  //alarm state
  if(box_temp >= alarm_temp && alarm_triggered == LOW){
    alarm_triggered = HIGH;
    tone(buzzer_pin, 2300);
    mode = 0;
    Serial.println("Alarm triggered");
  }
  if(box_temp < max_temp && alarm_triggered == HIGH){
    alarm_triggered = LOW;
    noTone(buzzer_pin);
    delay(100);
    servo.attach(servo_pin, 500, 2400);
    Serial.println("Alarm reset");
  }

  //Wait a second before refreshing
  if(millis() > refresh_buffer + 1000){
    refresh_buffer = millis();
    //Refresh dislay if box_temp value change
    if(saved_temp < box_temp || saved_temp > box_temp){
      saved_temp = box_temp;
      refresh = HIGH;
    }
    //Refresh dislay if humidity value change
    if(saved_hum < box_humidity || saved_hum > box_humidity){
      saved_hum = box_humidity;
      refresh = HIGH;
    }
  }

  //power off after main timer
  if(millis() - any_button_timer >= main_timeout*60000*60 && (mode == 1 || mode == 2)){
    mode = 0;
  }

  //power off after humidity stalled (only for standard and timer dry)
  if(mode ==1 || mode == 2){
    //timer used for showin how long it was drying
    drying_duration = millis() - drying_duration_timestamp;
    //timer used for resetting stalled time (when new low humidity)
    stalled_time = millis() - stalled_time_timestamp;
    //save the lowest humidity
    if(new_min_humidity >= box_humidity){
      new_min_humidity = box_humidity;
      stalled_time_timestamp = millis();
      Serial.print("new min humidity: ");
      Serial.println(new_min_humidity);
    }
    //if humidity is no longer dropping turn off
    if(millis() > stalled_time_timestamp + humidity_stall_duration*1000*60){
      if(timer_already_tripped == LOW){
        timer_already_tripped = HIGH;
        mode = 0;
        mode_triggered_once = LOW;
      }
    }
  }

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

  //open dampener
  if(dampener == HIGH && pos != max_angle && dampener_state == LOW){
    dampener_state = HIGH;
    digitalWrite(servo_power_pin, HIGH);
    delay(1000);
    //  for loop that increases the angle by 1 from 0 to max_angle with a delay of 10 ms per angle
    for (pos = max_angle; pos >= min_angle; pos -= 1) {
      servo.write(pos);
      delay(10);
    }
    digitalWrite(servo_power_pin, LOW);
  }
  //close dampener
  else if(dampener == LOW && pos != min_angle && dampener_state == HIGH){
    dampener_state = LOW;
    digitalWrite(servo_power_pin, HIGH);
    delay(1000);
    //  for loop that decreases the angle by 1 from max_angle to 0 with a delay of 10 ms per angle
    for (pos = min_angle; pos <= max_angle; pos += 1) {
      servo.write(pos);
      delay(10);
    }
    digitalWrite(servo_power_pin, LOW);
  }

  //turn on heater and fan
  if(heater_and_fan == LOW && heater_and_fan_state == HIGH){
    heater_and_fan_state = LOW;
    digitalWrite(heater_and_fan_pin, relay_is_inverted);                    //TURN ON
    Serial.print("relay is inverted: ");
    Serial.println(relay_is_inverted);
  }
  //turn off heater and fan
  if(heater_and_fan == HIGH && heater_and_fan_state == LOW){
    heater_and_fan_state = HIGH;
    digitalWrite(heater_and_fan_pin, !relay_is_inverted);                    //TURN OFF
  }

  //mode selector - if mode = 0(off), change mode option
  if(mode == 0){
    if(up_button_pressed_once == HIGH && mode_selector < 4){
      mode_selector++;
      display_mode = mode_selector;
      delay(200);
      refresh = HIGH;
      Serial.print("mode_selector increased: ");
      Serial.println(mode_selector);
    }
    if(down_button_pressed_once == HIGH && mode_selector > 0){
      mode_selector--;
      display_mode = mode_selector;
      delay(200);
      refresh = HIGH;
      Serial.print("mode_selector decreased: ");
      Serial.println(mode_selector);
    }
    if(select_button_pressed_once == HIGH){
      mode = mode_selector;
      delay(200);
      refresh = HIGH;
      Serial.print("mode: ");
      Serial.println(mode);
    }
  }

  //if ever in mode 0(off), reset target humidity and the back on timer
  if(mode == 0 && new_humidity_target != default_humidity_target){
    new_humidity_target = default_humidity_target;
  }
  //if mode = (1)auto, use the up and down buttons to lower or raise taraget humidity
  if(mode == 1){
    if(down_button_pressed_once == HIGH && new_humidity_target >= min_humidity_target){
      new_humidity_target--;
      refresh = HIGH;
    }
    if(up_button_pressed_once == HIGH){
      new_humidity_target++;
      refresh = HIGH;
    }
  }

  //change mode
  if(mode_selector != 0 && select_button_pressed_once == HIGH){
    mode = mode_selector;
    mode_triggered_once = LOW;
    mode_selector = 0;
    select_button_pressed_once = LOW;
    refresh = HIGH;
  }
  else if(mode != 0 && mode_selector == 0 && select_button_pressed_once == HIGH){
    mode = 0;
    mode_triggered_once = LOW;
    refresh = HIGH;
  }

  //mode 0 - off
  if(mode == 0 && mode_triggered_once == LOW && mode_selector == 0){
   mode_triggered_once = HIGH;
   dampener = LOW;
   heater_and_fan = LOW;
   display_mode = 0;
   refresh = HIGH;
   back_to_on_delay_timer = millis();
  }

  //mode 1 - auto dehumidify (go on and off according to temp and humidity)
  if(mode == 1){
    //go off if dry
    if(box_humidity < new_humidity_target && display_mode != 5 || (box_temp > max_temp && dampener == HIGH)){ //using display_mode instead of heater_and_fan to trigger once
      dampener = LOW;
      heater_and_fan = LOW;
      display_mode = 5; // standby 
      refresh = HIGH;
    }
    if(box_temp < max_temp - temp_lag){
      //go on if humid
      if(box_humidity > new_humidity_target && display_mode != 6){
        dampener = HIGH;
        heater_and_fan = HIGH;
        display_mode = 6; //auto - on
        refresh = HIGH;
      }
    }
  }

  //mode 2 - timer
  if(mode == 2){
    if(new_humidity_target != min_humidity_target){
      new_humidity_target = min_humidity_target;
    }
    //timer value in minutes
    saved_timer1 = dry_timer - ((millis() - any_button_timer)/1000)/60;
    //refresh only after one second
    if(saved_timer1 != saved_timer2){
      saved_timer2 = saved_timer1;
      refresh = HIGH;
    }
    //if main timer times out
    if(saved_timer1 > dry_timer){
      if(timer_already_tripped == LOW){
        timer_already_tripped = HIGH;
        mode = 0; // TIMER EXPIRED - OFF
        mode_triggered_once = LOW;
      }
    }
    else if(box_temp < max_temp - temp_lag){
      //wait for on delay timer
      if(millis() > back_to_on_delay*1000 + back_to_on_delay_timer){
        mode_triggered_once = LOW;
        dampener = HIGH;
        heater_and_fan = HIGH;
        display_mode = 7; // timer on
      }
    }
    else if(box_temp > max_temp){
      mode_triggered_once = LOW;
      dampener = LOW;
      heater_and_fan = LOW;
      display_mode = 5; // standby     
    }
  }

  // mode 3 - smart mode - if outside is very dry, start drying
  if(mode == 3){
    //if 5% more humid inside box
    if(box_humidity > minHumidity + smart_mode_delta && box_temp < max_temp){
      //wait for on delay timer
      if((millis() > back_to_on_delay_timer) && mode_triggered_once == LOW){
        mode_triggered_once = HIGH;
        dampener = HIGH;
        heater_and_fan = HIGH;
        display_mode = 19; // drying filament
        refresh = HIGH;
        saved_minHumidity = minHumidity;
      }
    }
    //target humidity reached - log wait before on again
    else if(box_humidity <= saved_minHumidity + smart_mode_delta && mode_triggered_once == HIGH){
      mode_triggered_once = LOW;
      dampener = LOW;
      heater_and_fan = LOW;
      display_mode = 18; // standby
      refresh = HIGH;
      back_to_on_delay_timer = millis() + (1000 *60 * 60); //milliseconds x 1000 to get seconds x 60 to get mintes x 60 to get 1 hour
    }
    //max temp reached - short wait before on again
    else if(box_temp >= max_temp && mode_triggered_once == HIGH){
      mode_triggered_once = LOW;
      dampener = LOW;
      heater_and_fan = LOW;
      display_mode = 18; // standby
      refresh = HIGH;
      back_to_on_delay_timer = millis() + (1000*(back_to_on_delay)); //milliseconds x 1000 to get seconds x 10 to get 10 seconds
    }
    //if in mode 0 but low humidity just change the display
    else if(display_mode == 0){
      display_mode = 18; // standby
    }
  }

  // mode 4 - settings
  if(mode == 4){
    if(settings_mode == 0){
      settings_mode = 1;
    }
  }
  if(select_button_pressed_once == HIGH && settings_mode != 0){
    if(settings_mode < 17){
      settings_mode++;
    }
    else{
      settings_mode = 1;
    }
  }

  //settings mode 1 - menu - change max temp
  if (settings_mode == 1){
    display_mode = 8;
    if(up_button_pressed_once == HIGH){
      max_temp++;
      refresh = HIGH;
      delay(500);
    }
    if(down_button_pressed_once == HIGH){
      max_temp--;
      refresh = HIGH;
      delay(500);
    }
  }

  //settings mode 2 - menu - change temp lag
  if (settings_mode == 2){
    display_mode = 9;
    if(up_button_pressed_once == HIGH){
      temp_lag++;
      refresh = HIGH;
      delay(500);
    }
    if(down_button_pressed_once == HIGH){
      temp_lag--;
      refresh = HIGH;
      delay(500);
    }
  }

  //settings mode 3 - menu - change switch on delay
  if (settings_mode == 3){
    display_mode = 10;
    if(up_button_pressed_once == HIGH){
      back_to_on_delay++;
      refresh = HIGH;
      delay(500);
    }
    if(down_button_pressed_once == HIGH){
      back_to_on_delay--;
      refresh = HIGH;
      delay(500);
    }
  }

  //settings mode 4 - menu - change backlight timeout
  if(settings_mode == 4){
    display_mode = 11;
    //increments of 1
    if(backlight_timeout >= 0 && backlight_timeout < 10){
      if(up_button_pressed_once == HIGH){
        backlight_timeout++;
        refresh = HIGH;
        delay(500);
      }
      if(down_button_pressed_once == HIGH){
        backlight_timeout--;
        refresh = HIGH;
        delay(500);
      }      
    }
    //increments of 10
    else if(backlight_timeout >= 10){
      if(up_button_pressed_once == HIGH){
        backlight_timeout = backlight_timeout + 10;
        refresh = HIGH;
        delay(500);
      }
      if(down_button_pressed_once == HIGH){
        backlight_timeout = backlight_timeout - 10;
        refresh = HIGH;
        delay(500);
      }
    }
  }

  //settings mode 5 - menu - change main timeout period (the long one)
  if(settings_mode == 5){
    display_mode = 12;
    if(up_button_pressed_once == HIGH){
      main_timeout++;
      refresh = HIGH;
      delay(500);
    }
    if(down_button_pressed_once == HIGH && main_timeout > 1){
      main_timeout--;
      refresh = HIGH;
      delay(500);
    }
  }

  //settings mode 6 - menu - change the default timeout behaviour
  if(settings_mode == 6){
    display_mode = 13;
    if(up_button_pressed_once == HIGH){
      Default_to_prev_humidity = LOW;
      refresh = HIGH;
      delay(500);
    }
    if(down_button_pressed_once == HIGH && main_timeout > 1){
      Default_to_prev_humidity = HIGH;
      refresh = HIGH;
      delay(500);
    }
  }

  //settings mode 7 - menu - change the output relay inversion
  if(settings_mode == 7){
    display_mode = 14;
    if(up_button_pressed_once == HIGH){
      relay_is_inverted = LOW;
      refresh = HIGH;
      delay(500);
    }
    if(down_button_pressed_once == HIGH){
      relay_is_inverted = HIGH;
      refresh = HIGH;
      delay(500);
    }
  }

  //settings mode 8 - menu - stall duration
  if(settings_mode == 8){
    display_mode = 15;
    if(up_button_pressed_once == HIGH){
      humidity_stall_duration++;
      refresh = HIGH;
      delay(500);
    }
    if(down_button_pressed_once == HIGH){
      humidity_stall_duration--;
      refresh = HIGH;
      delay(500);
    }
  }

  //settings mode 9 - menu - alarm temperature
  if(settings_mode == 9){
    display_mode = 20;
    if(up_button_pressed_once == HIGH){
      alarm_temp++;
      refresh = HIGH;
      delay(500);
    }
    if(down_button_pressed_once == HIGH){
      alarm_temp--;
      refresh = HIGH;
      delay(500);
    }
  }

  //settings mode 10 - menu - default humidity target
  if(settings_mode == 10){
    display_mode = 21;
    if(up_button_pressed_once == HIGH){
      default_humidity_target++;
      refresh = HIGH;
      delay(500);
    }
    if(down_button_pressed_once == HIGH){
      default_humidity_target--;
      refresh = HIGH;
      delay(500);
    }
  }

  //settings mode 11 - menu - minimum humidity target
  if(settings_mode == 11){
    display_mode = 22;
    if(up_button_pressed_once == HIGH){
      min_humidity_target++;
      refresh = HIGH;
      delay(500);
    }
    if(down_button_pressed_once == HIGH){
      min_humidity_target--;
      refresh = HIGH;
      delay(500);
    }
  }

  //settings mode 12 - menu - dry timer
  if(settings_mode == 12){
    display_mode = 23;
    if(up_button_pressed_once == HIGH){
      dry_timer++;
      refresh = HIGH;
      delay(500);
    }
    if(down_button_pressed_once == HIGH){
      dry_timer--;
      refresh = HIGH;
      delay(500);
    }
  }

  //settings mode 13 - menu - minimum servo angle
  if(settings_mode == 13){
    display_mode = 24;
    if(up_button_pressed_once == HIGH){
      min_angle++;
      refresh = HIGH;
      delay(500);
    }
    if(down_button_pressed_once == HIGH){
      min_angle--;
      refresh = HIGH;
      delay(500);
    }
  }

  //settings mode 14 - menu - maximum servo angle
  if(settings_mode == 14){
    display_mode = 25;
    if(up_button_pressed_once == HIGH){
      max_angle++;
      refresh = HIGH;
      delay(500);
    }
    if(down_button_pressed_once == HIGH){
      max_angle--;
      refresh = HIGH;
      delay(500);
    }
  }

  //settings mode 15 - menu - smart mode delta
  if(settings_mode == 15){
    display_mode = 26;
    if(up_button_pressed_once == HIGH){
      smart_mode_delta++;
      refresh = HIGH;
      delay(500);
    }
    if(down_button_pressed_once == HIGH){
      smart_mode_delta--;
      refresh = HIGH;
      delay(500);
    }
  }  

  //settings mode 16 - menu - save to eeprom
  if(settings_mode == 16){
    display_mode = 16;
    if(up_button_pressed_once == HIGH){

      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(5, max_temp);
      EEPROM.commit();
      delay(100);
      EEPROM.put(10, temp_lag);
      EEPROM.commit();
      delay(100);   
      EEPROM.put(15, back_to_on_delay);
      EEPROM.commit();
      delay(100);  
      EEPROM.put(20, backlight_timeout);
      EEPROM.commit();
      delay(100);   
      EEPROM.put(25, main_timeout);
      EEPROM.commit();
      delay(100);   
      EEPROM.put(30, Default_to_prev_humidity);
      EEPROM.commit();
      delay(100);   
      EEPROM.put(35, relay_is_inverted);
      EEPROM.commit();
      delay(100); 
      EEPROM.put(40, humidity_stall_duration);
      EEPROM.commit();
      delay(100); 
      EEPROM.put(45, alarm_temp);
      EEPROM.commit();
      delay(100); 
      EEPROM.put(50, default_humidity_target);
      EEPROM.commit();
      delay(100); 
      EEPROM.put(55, min_humidity_target);
      EEPROM.commit();
      delay(100); 
      EEPROM.put(60, dry_timer);
      EEPROM.commit();
      delay(100); 
      EEPROM.put(65, min_angle);
      EEPROM.commit();
      delay(100); 
      EEPROM.put(70, max_angle);
      EEPROM.commit();
      delay(100); 
      EEPROM.put(75, smart_mode_delta);
      EEPROM.commit();
      delay(100); 

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

  //settings mode 17 - menu - exit menu
  if(settings_mode == 17){
    display_mode = 17;
    if(up_button_pressed_once == HIGH){
      mode = 0;
      display_mode = 0;
      settings_mode = 0;
      refresh = HIGH;
    }
  }

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

    if(display_mode == 0){
      lcd.setCursor(0,0);
      lcd.print("OFF");
      if(drying_duration > 0){
        lcd.setCursor(0,0);
        lcd.print("STALLED");
        lcd.setCursor(12,0);
        lcd.print(drying_duration/3600000)%24;
        lcd.print(":");
        lcd.print(drying_duration/60000)%60;
      }
      lcd.setCursor(0,1);
      lcd.print(box_temp);
      lcd.print((char)223);
      lcd.print("C");
      if(box_temp > max_temp){
        lcd.print("!");
      }
      lcd.setCursor(8,1);
      lcd.print(box_humidity);
      lcd.print("%");
    }

    if(display_mode == 1){
      lcd.setCursor(0,0);
      lcd.print("STANDARD DRY");
      lcd.setCursor(0,1);
      lcd.print(box_temp);
      lcd.print((char)223);
      lcd.print("C");
      if(box_temp > max_temp){
        lcd.print("!");
      }
      lcd.setCursor(8,1);
      lcd.print(box_humidity);
      lcd.print("%");
    }

    if(display_mode == 2){
      lcd.setCursor(0,0);
      lcd.print("TIMER DRY");
      lcd.setCursor(0,1);
      lcd.print(box_temp);
      lcd.print((char)223);
      lcd.print("C");
      if(box_temp > max_temp){
        lcd.print("!");
      }
      lcd.setCursor(8,1);
      lcd.print(box_humidity);
      lcd.print("%");
    }

    if(display_mode == 3){
      lcd.setCursor(0,0);
      lcd.print("SMART DRY");
      lcd.setCursor(0,1);
      lcd.print(box_temp);
      lcd.print((char)223);
      lcd.print("C");
      if(box_temp > max_temp){
        lcd.print("!");
      }
      lcd.setCursor(8,1);
      lcd.print(box_humidity);
      lcd.print("%");
    }

    if(display_mode == 4){
      lcd.setCursor(0,0);
      lcd.print("SETTINGS");
      lcd.setCursor(0,1);
      lcd.print(box_temp);
      lcd.print((char)223);
      lcd.print("C");
      if(box_temp > max_temp){
        lcd.print("!");
      }
      lcd.setCursor(8,1);
      lcd.print(box_humidity);
      lcd.print("%");
    }

    if(display_mode == 5){
      lcd.setCursor(0,0);
      lcd.print("STANDBY");
      lcd.setCursor(0,1);
      lcd.print(box_temp);
      lcd.print((char)223);
      lcd.print("C");
      if(box_temp > max_temp){
        lcd.print("!");
      }
      lcd.setCursor(8,1);
      lcd.print(box_humidity);
      lcd.print("%");
      lcd.print((char)126);
      lcd.print(new_humidity_target);
      lcd.print("%");
    }

    if(display_mode == 6){
      lcd.setCursor(0,0);
      lcd.print("DRYING FILAMENT");
      lcd.setCursor(0,1);
      lcd.print(box_temp);
      lcd.print((char)223);
      lcd.print("C");
      if(box_temp > max_temp){
        lcd.print("!");
      }
      lcd.setCursor(8,1);
      lcd.print(box_humidity);
      lcd.print("%");
      lcd.print((char)126);
      lcd.print(new_humidity_target);
      lcd.print("%");
    }

    if(display_mode == 7){
      lcd.setCursor(0,0);
      lcd.print("TIMER");
      lcd.setCursor(8,0);
      lcd.print(saved_timer1);
      lcd.print(" min");
      lcd.setCursor(0,1);
      lcd.print(box_temp);
      lcd.print((char)223);
      lcd.print("C");
      if(box_temp > max_temp){
        lcd.print("!");
      }
      lcd.setCursor(8,1);
      lcd.print(box_humidity);
      lcd.print("%");
      lcd.print((char)126);
      lcd.print(new_humidity_target);
      lcd.print("%");
    }  

    if(display_mode == 8){
      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(display_mode == 9){
      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(display_mode == 10){
      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(display_mode == 11){
      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(display_mode == 12){
      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(display_mode == 13){
      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(display_mode == 14){
      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(display_mode == 15){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("STALL TIME");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(1,1);
      lcd.print(humidity_stall_duration);
      lcd.print(" MINUTES");  
    }

    if(display_mode == 16){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("SAVE TO EEPROM");
      lcd.setCursor(15,0);
      lcd.print((char)126);
    }    

    if(display_mode == 17){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("EXIT");
      lcd.setCursor(15,0);
      lcd.print((char)126);
    } 

    if(display_mode == 18){
      lcd.setCursor(0,0);
      lcd.print("SMART-WAIT");
      lcd.setCursor(12,0);
      lcd.print(box_temp);
      lcd.print((char)223);
      lcd.print("C");
      if(box_temp > max_temp){
        lcd.setCursor(10,0);
        lcd.print("!");
      }
      lcd.setCursor(0,1);
      lcd.print("OUT");
      lcd.print(outside_humidity);
      lcd.print("%");
      lcd.setCursor(9,1);
      lcd.print(box_humidity);
      lcd.print("%");
      if(box_humidity > minHumidity + smart_mode_delta){
        lcd.print((char)126);
      }
      lcd.setCursor(13,1);
      lcd.print(int(minHumidity + smart_mode_delta));
      lcd.print("%");
    }

    if(display_mode == 19){
      lcd.setCursor(0,0);
      lcd.print("SMART-ON");
      lcd.setCursor(9,0);
      lcd.print(box_temp);
      lcd.print("C");
      lcd.print((char)126);
      lcd.setCursor(13,0);
      lcd.print(max_temp);
      lcd.print("C");
      lcd.setCursor(0,1);
      lcd.print("OUT");
      lcd.print(outside_humidity);
      lcd.print("%");
      lcd.setCursor(9,1);
      lcd.print(box_humidity);
      lcd.print("%");
      if(box_humidity > saved_minHumidity + smart_mode_delta){
        lcd.print((char)126);
      }
      lcd.setCursor(13,1);
      lcd.print(int(saved_minHumidity + smart_mode_delta));
      lcd.print("%");
    }

    if(display_mode == 20){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("ALARM TEMP");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(1,1);
      lcd.print(alarm_temp);
      lcd.print((char)223); 
      lcd.print("C");  
    }

    if(display_mode == 21){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("HUMID. TARGET");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(1,1);
      lcd.print(default_humidity_target);
      lcd.print("%");  
    }

    if(display_mode == 22){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("MIN HUMIDITY");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(1,1);
      lcd.print(min_humidity_target);
      lcd.print("%");  
    }
    
    if(display_mode == 23){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("DRY TIMER");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(1,1);
      lcd.print(dry_timer);  
      lcd.print(" MINUTES");         
    } 

    if(display_mode == 24){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("MIN SERVO");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(1,1);
      lcd.print(min_angle);
      lcd.print((char)223); 
    }

    if(display_mode == 25){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("MAX SERVO");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(1,1);
      lcd.print(max_angle);
      lcd.print((char)223); 
    }

    if(display_mode == 26){
      lcd.setCursor(0,0);
      lcd.print((char)127);
      lcd.print("SMART DELTA");
      lcd.setCursor(15,0);
      lcd.print((char)126);
      lcd.setCursor(1,1);
      lcd.print(smart_mode_delta);
      lcd.print("%"); 
    }
  }
}