/* EEE20003 Project Progress - Part 1
  Group 39 Project G
  Authors: B Horvath, M Mahood, K Rhodes
  Program is a calculator that can complete basic operations, being:
  - addition, subtraction and multiplication
  - taking input of integers or doubles
  - can do calculation with previous result (or without)
  - can power on and off, clearing when turned off
  - can take up to 100 values (+-* count as a value)
*/

#include <LiquidCrystal.h> //includes library for lcd
#include <EEPROM.h> // include library for EEPROM
#include <dht.h>
#include <RTClib.h>
#include <Wire.h>
LiquidCrystal lcd(12, 11, 10, 9, 8, 7); //Initialises the LCD.

dht DHT;
#define DHT22_PIN 5

const uint8_t ROWS = 4;
const uint8_t COLS = 7; //gives the keypad 4 rows and 7 columns
char keys[ROWS][COLS] = {
  { '1', '2', '3', '+', 's', 'A', 'B'},
  { '4', '5', '6', '-', 'n', 'C', 'D'},
  { '7', '8', '9', '*', '%', 'E', 'F'},
  { 'P', '0', '.', '/', '=', 'G', 'H'} //specifies the possible 'keys' values, as characters.
};



String userin = ""; //sets userin to be a empty string.
#define arraylength 100 // length of array is constant.
String userinarray[arraylength] = {}; //100 'slot' long array for storing user input.
String hold[arraylength] = {}; //second array for holding user input, when above array is
// being cleared between operations.
int ArraySlot = 0; //array element ('slot') marking variable, used to find specific
// array slots for computation.
bool on = false; //whether or not the LCD is on (serves as a safety).
bool equalsPressed = false; //whether or not the user has pressed equals.
float ans = 0; //the answer for the expression the user has entered; 0 default.


//initialisei RTC module
RTC_DS1307 rtc;

//variable for checking which mode the calculator is in
int mode = 0;
double mem = 0;
String memory = "0";

bool passwordCorrect = false;
bool isCalcMode = false;
char msgChar;

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2); //specifies width and height of LCD.
  //lcd.noBacklight(); //turns off the backlight of the LCD.

  pinMode(4, OUTPUT);
  digitalWrite(4, LOW);

  //set the pins used for interrupts as pullup input pins
  pinMode(2, INPUT_PULLUP);
  pinMode(3, INPUT_PULLUP);
  pinMode(18, INPUT_PULLUP);
  pinMode(19, INPUT_PULLUP);

  // iterate through pins used to check button column and set as output and low
  for (int pin = 33; pin <= 39 ; pin++) {
    pinMode(pin, OUTPUT);
    digitalWrite(pin, LOW);
  }

  // attach interrupts to the row pins to check which row is pressed
  attachInterrupt(0, row1, FALLING);

  attachInterrupt(1, row2, FALLING);

  attachInterrupt(5, row3, FALLING);

  attachInterrupt(4, row4, FALLING);


  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    Serial.flush();
    abort(); //if the rtc fails to find computer time, the program will crash
  }

  char Buffer[8]; // store password
  // String password = "EEE20003"; //testing
  String passwordInput;
  int count = 0;

  //check if the memory has already been setup
  //if memory unaccessed then will return 255 for first
  if (EEPROM.read(0) == 255) {
    EEPROM.write(0, 'E');
    EEPROM.write(1, 'E');
    EEPROM.write(2, 'E');
    EEPROM.write(3, '2');
    EEPROM.write(4, '0');
    EEPROM.write(5, '0');
    EEPROM.write(6, '0');
    EEPROM.write(7, '3');
    EEPROM.write(8, '-');
    EEPROM.write(9, '-');
    EEPROM.write(10, 'W');
    EEPROM.write(11, 'e');
    EEPROM.write(12, 'l');
    EEPROM.write(13, 'c');
    EEPROM.write(14, 'o');
    EEPROM.write(15, 'm');
    EEPROM.write(16, 'e');
    EEPROM.write(17, '-');
    EEPROM.write(18, 'U');
    EEPROM.write(19, 's');
    EEPROM.write(20, 'e');
    EEPROM.write(21, 'r');
    EEPROM.write(22, '-');
    EEPROM.write(23, '-');
    //set default memory to 0
  }


  // for loop that iterates through length of password and stores in a Buffer
  for (int pwstored = 0; pwstored <= 7; pwstored++) {
    Buffer[pwstored] = EEPROM.read(pwstored);
  }

  Serial.println("Enter password to access program: ");
  while (passwordCorrect == false) {
    while (Serial.available() == 0) {}; //asks for input (once), and then waits for that input
    if (Serial.available() > 0) {
      Serial.flush();
      passwordInput = Serial.readString();
      passwordInput.remove(8);
      if (String(Buffer) == passwordInput) {
        passwordCorrect = true;
        Serial.print(passwordInput);
        Serial.println(" - Password Accepted!");
        for (int msgstored = 8; msgstored <= 24; msgstored++) {
          msgChar = EEPROM.read(msgstored);
          digitalWrite(4, HIGH);
          lcd.print(msgChar);
          delay(100);
        }
        delay(2000);
        lcd.clear();
        digitalWrite(4, LOW);
      }
      else {
        Serial.println("Incorrect Password, try again:");
      }
    }
  }

  // if (String(Buffer) == password) {
  //   Serial.println("unlocked");
  // }
  // //Serial.println(String(Buffer));
  // //Serial.println(password);
  if (passwordCorrect == true) {
    menu();
  }
}


// function for if a button on row 1 is pressed
void row1() {
  detachInterrupt(0); // detach the interrupt to prevent multiple inputs
  //Serial.print("Row 1 ");
  checkbutton(2); // call function to check which column the button is in
  attachInterrupt(0, row1, FALLING); // reattach input

}

// same as row1
void row2() {
  detachInterrupt(1);
  //Serial.print("Row 2 ");
  checkbutton(3);
  attachInterrupt(1, row2, FALLING);
}
// same as row1
void row3() {
  detachInterrupt(5);
  //Serial.print("Row 3 ");
  checkbutton(18);
  attachInterrupt(5, row3, FALLING);
}
//same as row 1
void row4() {
  detachInterrupt(4);
  //Serial.print("Row 4 ");
  checkbutton(19);
  attachInterrupt(4, row4, FALLING);
}

void loop() {

  if (on == true) {
    tempcheck();
  }

  if (mode == 1) {
    Clock();
  }
  else if (mode == 2) {
    Temp();
  }
  else if (mode == 3) {
    Hum();
  }
  delay(500);
}

//function for checking which column the button that was pressed is in
// takes current row as input to know which row the button is in
void checkbutton(int currentRow) {
  if (passwordCorrect == true && isCalcMode == true) {
    int row = 0;
    //for loop that iterates through the columns
    for (int pin = 33; pin <= 39 ; pin++) {
      //sets the current column to high
      digitalWrite(pin, HIGH);
      // if the current row is high then the button pressed is in the current column and current row
      if (digitalRead(currentRow) == HIGH) {

        //Serial.print("Column ");
        //Serial.println(pin - 32);
        //switch statement to change from the row pin to the row number in the array

        switch (currentRow)
        {
          case 2:
            row = 0;
            break;

          case 3:
            row = 1;
            break;

          case 18:
            row = 2;
            break;

          case 19:
            row = 3;
            break;

          default:
            row = 0;
            break;
        }
        //call the input function with the corresponding array row and column to the button pressed
        input(row, pin - 33);
        // set the column back to low
        digitalWrite(pin, LOW);
        break;
        //exit the loop as dont need to check further
      }
      // set the column to low regardless as a failsafe
      digitalWrite(pin, LOW);

    }
  }
}


//main function that controls what key is pressed and what it should do
void input(int row, int column) {
  char key = keys[row][column]; //sets 'key' equal to the ASCII code equivalent to
  // the key being pressed by the user.
  //Serial.println(key);
  if (on == true && key != "") { //if a key is pressed, AND the LCD is on:
    if (equalsPressed == true) { //if the equals key is pressed:
      userin = ""; //user input string is cleared.
      for (int clearSlot = 0; clearSlot <= arraylength; clearSlot++) { //iterates through
        // the user input, and second hold array, setting each slot to be blank.
        userinarray[clearSlot] = {""};
        hold[clearSlot] = {""};
      }
      ArraySlot = 0; //goes back to the start of the user input array.
      lcd.clear(); //LCD contents are cleared.
      equalsPressed = false; //sets equalsPressed to false, breaking the if statement.

      if (key == '+' || key == '-' || key == '*' || key == '/') {
        Serial.println(ans); //if an operator is pressed after the equals key, the answer
        // previously calculated is displayed, so user knows the value they're operating.
      }
    }

    Serial.print(key); //key entered by user is displayed.
    if (key != 'A' && key != 'B' && key != 'C' && key != 'D' && key != 'E' && key != 'F' && key != 'G' && key != 'H' && key != 'n' && key != '=' && key != 'P') {
      lcd.print(key);
    }
    on = true; //bool for LCD power is set 'on' (relevent later).

    if (key == '=') { //if equals is pressed:
      Serial.println(userinarray[1]);
      lcd.clear(); //LCD screen is cleared.

      userinarray[ArraySlot] = userin.toDouble(); //arrayslot outputs of the user in array
      // are set to be double datatype numbers (for extra precision).

      // for(int i = 0; i< 10; i++){
      //   Serial.println(userinarray[i]);
      // }

      for (int ArraySlot = 0; ArraySlot <= arraylength; ArraySlot++) {
        // Serial.println(userinarray[ArraySlot]);
        if (userinarray[ArraySlot] == "s") {
          // Serial.println("test4");
          squarerootFunc(ArraySlot);
          ArraySlot--;
        } else if (userinarray[ArraySlot] == "%") {
          percentFunc(ArraySlot);
          ArraySlot--;
        }
      }

      for (int ArraySlot = 0; ArraySlot <= arraylength; ArraySlot++) {
        if (userinarray[ArraySlot] == "*") {
          multiplicationFunc(ArraySlot);
          ArraySlot--; // resets the array slot so that on next run restarts for loop
          // so that calculator can handle numerous operations of the same type in
          //one equatin and in the correct order of operations
        } else if (userinarray[ArraySlot] == "/") {
          divisionFunc(ArraySlot);
          ArraySlot--;
        }
      }

      for (int ArraySlot = 0; ArraySlot <= arraylength; ArraySlot++) { //identical to the previous
        // multiplication section starting on line 72 above, except this one checks for
        // and completes addition and subtraction (+ and -).
        if (userinarray[ArraySlot] == "+") {
          additionFunc(ArraySlot);
          ArraySlot--;
        } else if (userinarray[ArraySlot] == "-") {
          subtractionFunc(ArraySlot);
          ArraySlot--;

        }
      }

      ans = userinarray[0].toDouble(); //answer is set to the first value of the user input array,
      // thus saving this value if the user wants to further operate on it.
      Serial.println(ans);
      lcd.clear();
      lcd.print(ans);
      Serial.println(""); //the first slot of the user input array (the answer)
      // is displayed to the user.
      equalsPressed = true; //sets equals pressed true, thus preparing for the next
      // equals press.
    }
    else if (key == 'P') { //if the power button is pressed (ie not the equals button):
      on = false; //LCD on bool is set false
      lcd.clear(); //LCD display is cleared.
      digitalWrite(4, LOW);
      //lcd.noBacklight(); //LCD backlight is turned off.
      userin = ""; //user input is cleared (set empty).
      for (int clearSlot = 0; clearSlot <= arraylength; clearSlot++) {
        userinarray[clearSlot] = {""};
        hold[clearSlot] = {""}; //both the storage arrays are cleared.
      }
      ArraySlot = 0; //user in array slot marker is set back to the beginning of the array,
      // making it ready for next use.
      equalsPressed = false; //equals pressed is set to false, ensureing the calculator
      // cannot continue to be used after it has bee "turned off".
    }
    else if (key == 'n') {

      if (userin == "") {
        userinarray[ArraySlot - 1] = userinarray[ArraySlot - 1].toDouble() * -1;
        lcd.clear();
        for (int i = 0; i <= ArraySlot; i++) {
          lcd.print(userinarray[i]);
        }
      } else {
        userinarray[ArraySlot] = userin.toDouble() * -1;
        userin = "";
        lcd.clear();
        for (int i = 0; i <= ArraySlot; i++) {
          lcd.print(userinarray[i]);
        }
        ArraySlot++;
      }

      Serial.println(userinarray[ArraySlot]);
    }
    else if (key == '+' || key == '-' || key == '*' || key == '/') { //if operation buttons have been
      // pressed (ie not the equals or power buttons):
      if (userinarray[ArraySlot - 1] == "%") {

      }
      else if (userin == "") { //if the user input is empty:
        userinarray[ArraySlot] = ans;
        ArraySlot++; //the user input array is has it's current slot set to the
        // pervious answer, and then moves directly to the next slot for more entries
        // (thus allowing the old answer to be saved as a value the user can operate on).
      } else { //if the user input isn't empty:
        userinarray[ArraySlot] = userin.toDouble();
        ArraySlot++; //the user input is saved to the current array slot, and the array
        // marker is then moved to the next slot.
      }
      userinarray[ArraySlot] = key; //the operator is then saved in this new (empty) slot.
      ArraySlot++; //moves to next array slot, preventint 2 operators being grouped.
      userin = ""; //user input is cleared, ready for more entries.
    }
    else if (key == 's') {
      if (userinarray[ArraySlot - 1] == "+" || userinarray[ArraySlot - 1] == "-" || ArraySlot == 0) {
        userinarray[ArraySlot] = 1.00;
        ArraySlot++;
        userinarray[ArraySlot] = "*";
        ArraySlot++;
      } else if (userinarray[ArraySlot - 1] == "*" || userinarray[ArraySlot - 1] == "/") {

      } else {
        userinarray[ArraySlot] = userin.toDouble();
        ArraySlot++;
        userinarray[ArraySlot] = "*";
        ArraySlot++;
      }
      userinarray[ArraySlot] = key;
      ArraySlot++;
      userin = "";
    }
    else if (key == '%') {
      Serial.println("test1");
      userinarray[ArraySlot] = userin.toDouble();
      ArraySlot++;
      userinarray[ArraySlot] = key;
      ArraySlot++;
      userin = "";
    }

    //Memory Clear
    else if (key == 'A') {
      mem = 0;
    }
    //Memory Recall
    else if (key == 'B') {
      Serial.println(userin);
      userin = userin + mem;
      lcd.print(mem);
    }
    //Memory Subtract
    else if (key == 'C') {
      if (userin == "") {
        Serial.println("empty");
        mem -= ans;
      }
      else {
        mem -= userin.toDouble();
      }
      Serial.println(mem);
    }

    //Memory add
    else if (key == 'D') {
      if (userin == "") {
        Serial.println("empty");
        mem += ans;
      }
      else {
        mem += userin.toDouble();
      }
      Serial.println(mem);
    }

    // clear function
    else if (key == 'E') {
      if (mode == 0) {
        clearfunc();
      }
    }

    //clock
    else if (key == 'F') {
      lcd.clear();
      if (mode == 1) {
        clearfunc();
        mode = 0;
      }
      else {
        mode = 1;
      }
    }
    //temperature
    else if (key == 'G') {
      Serial.println(mode);
      lcd.clear();
      if (mode == 2) {
        clearfunc();
        mode = 0;
      }
      else {
        mode = 2;
      }
      Serial.println(mode);
    }

    //Humidity
    else if (key == 'H') {
      lcd.clear();
      if (mode == 3) {
        clearfunc();
        mode = 0;
      }
      else {
        mode = 3;
      }
    }

    else {
      if (userinarray[ArraySlot - 1] == "%") {
        userinarray[ArraySlot] = "*";
        ArraySlot++;
      }
      userin = userin + key;
    }
  } else if (key == 'P') { //if the power button is pressed and its not currently on
    on = true; //LCD on bool set true.
    //lcd.backlight(); //LCD is turned on.
    digitalWrite(4, HIGH);
    ans = 0; //any previous answer stored is cleared.
  }
}

void squarerootFunc(int ArraySlot) {
  double squareroot = sqrt(userinarray[ArraySlot + 1].toDouble());
  int HoldSlot = 0;

  while (HoldSlot < ArraySlot) {
    hold[HoldSlot] = userinarray[HoldSlot];
    HoldSlot++;
  }

  hold[HoldSlot] = squareroot;
  HoldSlot++;

  while (HoldSlot <= arraylength) {
    hold[HoldSlot] = userinarray[HoldSlot + 1];
    HoldSlot++;
  }

  for (int slot = 0; slot < arraylength - 1; slot++) {
    userinarray[slot] = hold[slot];
  }


}

void percentFunc(int ArraySlot) {
  double percent = userinarray[ArraySlot - 1].toDouble() / 100;

  int HoldSlot = 0;

  while (HoldSlot < ArraySlot - 1) {
    hold[HoldSlot] = userinarray[HoldSlot];
    HoldSlot++;
  }

  hold[HoldSlot] = percent;
  HoldSlot++;

  while (HoldSlot <= arraylength) {
    hold[HoldSlot] = userinarray[HoldSlot + 1];
    HoldSlot++;
  }

  for (int slot = 0; slot < arraylength - 1; slot++) {
    userinarray[slot] = hold[slot];
    Serial.println(userinarray[slot]);
  }

}

void multiplicationFunc(int ArraySlot) {
  double multiply = (userinarray[ArraySlot - 1].toDouble() * userinarray[ArraySlot + 1].toDouble());
  //^^once an * is found in some array 'slot', the slots immediately to the left
  // and right of the slot with '*' are multiplied; this is saved in the variable
  // called 'multiply' (datatype double).^^
  int HoldSlot = 0; //second storage array 'slot' marking variable, is set to
  // equal 0 (meaning it will start searching through the array from the first
  // slot in the array).

  while (HoldSlot < ArraySlot - 1) { //while the HoldSlot is less than the current
    // Array slot - 1 then the following lines run.
    // eg if userinarray = 11 - 5 * 7 + 2, array slot would equal 3 as that is
    // determined in the if statement in line 73 therefore loop runs for 0 1 2
    hold[HoldSlot] = userinarray[HoldSlot]; //value at slot the loop is up to
    // within the user array, set to the value for the hold array at the same slot
    HoldSlot++;//increases increment for array slot to continue through the loop
    // eg if userinarray = 11 - 5 * 7 + 2
    // would set hold = 11 -
  }

  hold[HoldSlot] = multiply; // sets the next hold value in array to the result of
  // the multiplication completed above
  // eg if userinarray = 11 - 5 * 7 + 2 would take the 5 * 7 = 35 and add
  // 35 to end of hold array, therefore hold = 11 - 35
  HoldSlot++; // increases increment of position in hold array

  while (HoldSlot <= arraylength) { //while the hold array is not full
    hold[HoldSlot] = userinarray[HoldSlot + 2]; // hold value is set to the value
    //in user in array that is beyond the section of calculation taking place
    //eg if userinarray = 11 - 5 * 7 + 2 and hold already set to 11 - 35 then
    //now hold = 11 - 35 - 2
    HoldSlot++; // increments hold slot to continue through while loop
  }

  for (int slot = 0; slot < arraylength - 1; slot++) { //sets a new variable to increment through slots
    userinarray[slot] = hold[slot]; //sets the values in hold array to the user in
    // array slot for slot.
  }


}

void divisionFunc(int ArraySlot) {
  double division = (userinarray[ArraySlot - 1].toDouble() / userinarray[ArraySlot + 1].toDouble());
  int HoldSlot = 0;

  while (HoldSlot < ArraySlot - 1) {
    hold[HoldSlot] = userinarray[HoldSlot];
    HoldSlot++;
  }

  hold[HoldSlot] = division;
  HoldSlot++;

  while (HoldSlot <= arraylength) {
    hold[HoldSlot] = userinarray[HoldSlot + 2];
    HoldSlot++;
  }

  for (int slot = 0; slot < arraylength - 1; slot++) {
    userinarray[slot] = hold[slot];
  }

}

void additionFunc(int ArraySlot) {
  //Serial.println("test 8");
  double addition = (userinarray[ArraySlot - 1].toDouble() + userinarray[ArraySlot + 1].toDouble());

  int HoldSlot = 0;

  while (HoldSlot < ArraySlot - 1) {
    //Serial.println("test 9");
    hold[HoldSlot] = userinarray[HoldSlot];
    HoldSlot++;
  }

  hold[HoldSlot] = addition;
  HoldSlot++;

  while (HoldSlot <= arraylength) {
    hold[HoldSlot] = userinarray[HoldSlot + 2];
    HoldSlot++;
  }

  for (int slot = 0; slot < arraylength - 1; slot++) {
    //Serial.println("test 10");
    userinarray[slot] = hold[slot];
  }

}

void subtractionFunc(int ArraySlot) {
  double subtract = (userinarray[ArraySlot - 1].toDouble() - userinarray[ArraySlot + 1].toDouble());
  int HoldSlot = 0;

  while (HoldSlot < ArraySlot - 1) {
    hold[HoldSlot] = userinarray[HoldSlot];
    HoldSlot++;
  }

  hold[HoldSlot] = subtract;
  HoldSlot++;

  while (HoldSlot <= arraylength) {
    hold[HoldSlot] = userinarray[HoldSlot + 2];
    HoldSlot++;
  }

  for (int slot = 0; slot < arraylength - 1; slot++) {
    userinarray[slot] = hold[slot];
  }

}

void Clock() { //digital clock function (called above)
  lcd.clear();
  DateTime now = rtc.now(); //initialises 'now' as the rtc reference variable
  char timearray[10]; //initialises array, to hold digital clock info (to be displayed)
  sprintf(timearray, "%d : %d : %d", now.hour(), now.minute(), now.second());
  //^maps rtc clock info, into timearray array.
  lcd.print(timearray);
  Serial.println(timearray);
}

void Temp() {
  DHT.read22(DHT22_PIN); //reads from the dht22
  float currenttemp = DHT.temperature; //saves temp from dht22 as variable
  lcd.clear();
  lcd.print(currenttemp); //display temp on OLED display
  Serial.println(currenttemp);
}

void Hum() {
  DHT.read22(DHT22_PIN); //reads from the dht22
  float currenthum = DHT.humidity; //saves temp from dht22 as variable
  lcd.clear();
  lcd.print(currenthum); //display temp on OLED display
  Serial.println(currenthum);
}


void clearfunc() {
  ans = 0; // answer cleared.
  userin = ""; //user input string is cleared.
  for (int clearSlot = 0; clearSlot <= ArraySlot; clearSlot++) { //iterates through
    // the user input, and second hold array, setting each slot to be blank.
    userinarray[clearSlot] = {""};
  }
  ArraySlot = 0; //goes back to the start of the user input array.
  lcd.clear(); //LCD contents are cleared.
  equalsPressed = false;

}



String menuInput;
String optionOneInput;
String optionFourInput;
void menu() {
  Serial.println("====OPTION-MENU====");
  Serial.println("Enter [1] to: Change LCD display default startup message. ");
  Serial.println("Enter [2] to: Display start temp (+turn off calculator if overheating). ");
  Serial.println("Enter [3] to: Start main program (calculator). ");
  Serial.println("Enter [4] to: Change default password. ");
  while (Serial.available() == 0) {}; //asks for input (once), and then waits for that input
  if (Serial.available() > 0) {
    Serial.flush();
    menuInput = Serial.readString();

    if (menuInput == "1\n") {
      isCalcMode = false;
      msgChar = '\0';
      Serial.flush();
      Serial.println("Previous default message: ");
      for (int M = 8; M < 24; M++) {
        Serial.print((char(EEPROM.read(M))));
      }
      Serial.println("");
      Serial.println("Enter new default message (Max 16 char, spaces included): ");
      while (Serial.available() == 0) {};
      if (Serial.available() > 0) {
        Serial.flush();
        optionOneInput = Serial.readString();
        for (int O = 0; O < 16; O++) {
          char optionOneToEeprom = optionOneInput.charAt(O);
          Serial.print(optionOneToEeprom);
          EEPROM.write(O + 8, optionOneToEeprom);
        }
      }
      menu();
    }

    else if (menuInput == "2\n") {
      isCalcMode = false;
      Serial.flush();
      digitalWrite(4, HIGH);
      tempcheck();
      tempsave();

      delay(3000);
      lcd.clear();
      digitalWrite(4, LOW);
      menu();
    }

    else if (menuInput == "3\n") {
      isCalcMode = true;
      Serial.flush();
      digitalWrite(4, HIGH);
      lcd.print("Calc Mode");
      lcd.setCursor(0, 1);
      lcd.print("Chosen:");
      lcd.setCursor(0, 0);
      delay(1500);
      lcd.clear();
      digitalWrite(4, LOW);
      //menu();

    }

    else if (menuInput == "4\n") {
      isCalcMode = false;
      Serial.flush();
      Serial.println("Previous Password: ");
      for (int P = 0; P < 8; P++) {
        Serial.print((EEPROM.read(P)));
      }
      Serial.println("");
      Serial.println("Enter new password");
      while (Serial.available() == 0) {};
      if (Serial.available() > 0) {
        Serial.flush();
        optionFourInput = Serial.readString();
        for (int NP = 0; NP <= 7; NP++) {
          char optionFourToEeprom = optionFourInput.charAt(NP);
          EEPROM.write(NP, optionFourToEeprom);
        }
      }
      menu();
    }
    else{
      Serial.println("invalid entry");
      menu();
    }

  }
}

void tempcheck() {
  DHT.read22(DHT22_PIN); //reads from the dht22
  float initTemp = DHT.temperature; //saves temp from dht22 as variable

  if (isCalcMode == false) {
    lcd.clear();
    lcd.print(initTemp); //display temp on OLED display

    if (initTemp < 50 && initTemp > -20) {
      lcd.print("C; calc is");
      lcd.setCursor(0, 1);
      lcd.print("operable.");
      lcd.setCursor(0, 0);
    } else {
      passwordCorrect = false; //makes calc inoperable (im lazy & it works lol)
      lcd.print("C; calc NOT");
      lcd.setCursor(0, 1);
      lcd.print("operable!");
      lcd.setCursor(0, 0);
    }

  }

  else {

    if (initTemp > 50 || initTemp < -20) {
      lcd.clear();
      lcd.print(initTemp);
      on = false;
      lcd.print("C; calc NOT");
      lcd.setCursor(0, 1);
      lcd.print("operable!");
      lcd.setCursor(0, 0);
      delay(2000);
      lcd.clear();
      digitalWrite(4, LOW);
    }

  }
}

void tempsave()
{
  DHT.read22(DHT22_PIN);
  float initTemp = DHT.temperature;
  char buffer [5];
  dtostrf(initTemp, 3, 1, buffer);


  //printing previous recorded temperature
  if (EEPROM.read(24) == 255) {
    Serial.println("no previous temperature saved");
  }
  else {
    Serial.print("previous recorded temp is: ");
    for (int u = 24; u <= 28; u++) {
      Serial.print(char(EEPROM.read(u)));
    }
    Serial.println("C");
  }

  Serial.print("new recorded temperature is: ");
  Serial.print(initTemp);
  Serial.println("C");

  //Saving new initial temperature to EEPROM
  for (int h = 0; h <= 4; h++) {
    EEPROM.write(h + 24, buffer[h]);
  }

}