final_code.ino

#include <LiquidCrystal_I2C.h>  //Header file for LCD from https://www.arduino.cc/en/Reference/LiquidCrystal
#include <Wire.h>
#include <Keypad.h>
 
// Rotary encoder pins
#define ENCODER_CLK 10
#define ENCODER_DT  9
#define ENCODER_BTN 8
 
// Keypad pins
const uint8_t ROWS = 4;
const uint8_t COLS = 4;
char keys[ROWS][COLS] = {
  { '1', '2', '3', '+' },
  { '4', '5', '6', '-' },
  { '7', '8', '9', '.' },
  { '*', '0', '/', '=' }
};
uint8_t colPins[COLS] = { 4, 5, 6, 7 }; // Pins connected to C1, C2, C3, C4
uint8_t rowPins[ROWS] = { 0, 1, 2, 3 }; // Pins connected to R1, R2, R3, R4
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
 
// Define display pins
LiquidCrystal_I2C lcd(0x27, 16, 2);
 
void setup() {
  pinMode(ENCODER_CLK, INPUT);
  pinMode(ENCODER_DT, INPUT);
  pinMode(ENCODER_BTN, INPUT_PULLUP);
  lcd.init();
  lcd.backlight();
}
 
char inputs[16] = ""; // input of user
int inputIdx = 0; // which index are we inputting right now
int lastClk = HIGH; // makes sure that rotary encoder is not called too many times
bool reset = false; // this is true once we have calculated a result
long int lastPress = 0; // how long since we pressed the rotary encoder button
 
void updateCursor() { // blinking cursor
  if (millis() / 250 % 2 == 0 ) {
    lcd.cursor();
  } else {
    lcd.noCursor();
  }
}
 
void clearAll(){ // clears the variables once results have been calculated
  memset(inputs,'\0',strlen(inputs));
  inputIdx = 0;
  lastClk = HIGH;
  reset = true;
  lastPress = 0;
  lcd.setCursor(0,0);
}
 
void loop() {
 
 // handles rotary encoder button press, deletes a digit when pressed
  if (digitalRead(ENCODER_BTN) == LOW  && millis() - lastPress > 300) { // button was pressed
    lastPress = millis();
    memmove(inputs+inputIdx, inputs+inputIdx+1, strlen(inputs) - inputIdx);
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print(inputs);
    lcd.setCursor(inputIdx,0);
  }
 
  // handles rotary encoder rotation
  int newClk = digitalRead(ENCODER_CLK);
  if (newClk != lastClk) { // There was a change on the CLK pin
      lastClk = newClk;
      int dtValue = digitalRead(ENCODER_DT);
      if (newClk == LOW && dtValue == LOW) { // clockwise, move to right
        if (inputs[inputIdx] != '\0'){ // don't move cursor when we are at rightmost digit
            inputIdx++;
            lcd.setCursor(inputIdx, 0);
        }
      }
      if (newClk == LOW && dtValue == HIGH) { // counterclockwise, move to left
        if (inputIdx > 0){ // don't go to negative indexes
          inputIdx--;
          lcd.setCursor(inputIdx, 0);
        }
      }
  }
 
  updateCursor(); // blinking cursor
 

  // handles keypad input
  char key = keypad.getKey();
  if (key != NO_KEY) {

    if (key == '='){ // calculate results

      char currNum[16] = "";
      int currNumIdx = 0;
      double nums[8] = {0,0,0,0,0,0,0,0};
      int numsIdx = 0;
      char operators[8] = {'e','e','e','e','e','e','e','e'};
      int opsIdx = 0;
      bool doBreak = false;

      for (int i = 0; i <= 16; i++) { // parse string input to numbers and operators
        char currInput = inputs[i];
        switch (currInput){
          case '.': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
            currNum[currNumIdx] = currInput;
            currNumIdx++;
            break;
          case '+': case '-': case '*': case '/':
            if (currNumIdx != 0){ // there is a number that hasn't been added to nums array yet
              currNumIdx = 0;
              nums[numsIdx] = strtod(currNum, (char **)NULL);
              memset(currNum,"",sizeof(currNum));
              numsIdx++;
            }
            operators[opsIdx] = currInput;
            opsIdx++;
            break;
          default: // no more inputs, end of string
            if (currNumIdx != 0){ // there is a number that hasn't been added to nums array yet
              currNumIdx = 0;
              nums[numsIdx] = strtod(currNum, (char **)NULL);
              memset(currNum,"",sizeof(currNum));
              numsIdx++;
            }
            doBreak = true;
            break;
        }
        if(doBreak){break;}
      }

      // do the mathematical calculations for our input
      for (int phase = 0; phase < 2; phase++) { // 0 means multiplication phase, 1 means sum phase
        for (int i = 0; i < opsIdx; i++) { // loop through operations

          double firstnum = nums[i];
          double secondnum = nums[i+1];
          double newResult = 0.0;

          switch(phase){
            case 0: // we only multiply and divide in phase 0
              switch(operators[i]){

                case '*':
                  newResult = firstnum * secondnum;
                  nums[i] = newResult;
                  nums[i+1] = newResult;
                  // This following section updates results
                  if (i < numsIdx){ // avoid going over list bounds
                    for (int j = i+1; j <= numsIdx; j++) {
                      if (operators[j] == 'e'){
                        nums[j+1] = newResult;
                      }
                      else{
                        break;
                      }
                    }
                  }
                  if (i > 0){
                    for (int j = i-1; j >= 0; j--) {
                      if (operators[j] == 'e'){
                        nums[j] = newResult;
                      }
                      else{
                        break;
                      }
                    }
                  }
                  operators[i] = 'e'; // this operation has been calculated
                  break;

                case '/':
                  newResult = firstnum / secondnum;
                  nums[i] = newResult;
                  nums[i+1] = newResult;
                  // This following section updates results
                  if (i < numsIdx){ // avoid going over list bounds
                    for (int j = i+1; j <= numsIdx; j++) {
                      if (operators[j] == 'e'){
                        nums[j+1] = newResult;
                      }
                      else{
                        break;
                      }
                    }
                  }
                  if (i > 0){
                    for (int j = i-1; j >= 0; j--) {
                      if (operators[j] == 'e'){
                        nums[j] = newResult;
                      }
                      else{
                        break;
                      }
                    }
                  }
                  operators[i] = 'e'; // this operation has been calculated
                  break;
              }
              break; 
              
            case 1: // we only add and subtract in phase 1
              switch(operators[i]){

                case '+':
                  newResult = firstnum + secondnum;
                  nums[i] = newResult;
                  nums[i+1] = newResult;
                  // This following section updates results
                  if (i < numsIdx){ // avoid going over list bounds
                    for (int j = i+1; j <= numsIdx; j++) {
                      if (operators[j] == 'e'){
                        nums[j+1] = newResult;
                      }
                      else{
                        break;
                      }
                    }
                  }
                  if (i > 0){
                    for (int j = i-1; j >= 0; j--) {
                      if (operators[j] == 'e'){
                        nums[j] = newResult;
                      }
                      else{
                        break;
                      }
                    }
                  }
                  operators[i] = 'e'; // this operation has been calculated
                  break;
                  
                case '-':
                  newResult = firstnum - secondnum;
                  nums[i] = newResult;
                  nums[i+1] = newResult;
                  // This following section updates results
                  if (i < numsIdx){ // avoid going over list bounds
                    for (int j = i+1; j <= numsIdx; j++) {
                      if (operators[j] == 'e'){
                        nums[j+1] = newResult;
                      }
                      else{
                        break;
                      }
                    }
                  }
                  if (i > 0){
                    for (int j = i-1; j >= 0; j--) {
                      if (operators[j] == 'e'){
                        nums[j] = newResult;
                      }
                      else{
                        break;
                      }
                    }
                  }
                  operators[i] = 'e'; // this operation has been calculated
                  break;
              }
              break;
          }
        }
      }
      lcd.setCursor(0, 1);
      lcd.print('=');
      lcd.print(String(nums[0]));
      clearAll();
    }


    else{ // any other button was pressed (add digits to input string)
      if(reset){ // after results calculation we clear the screen
        lcd.clear();
        reset = false;
      }
      lcd.print(key);
      inputs[inputIdx] = key;
      inputIdx++;
    }

  }
}