// LCD2004 and Pi Pico!
#define SKETCHVERSION "      V 0.40      "  // Make this 20 chars long

#include <SPI.h>  // Include SPI library (needed for the SD card)
#include <Wire.h>
#include <LCD_I2C.h>  // LCD display controller
#include <Keypad.h>
#include "table54.h"
#include "table1121.h"
#include <Arduino.h>

LCD_I2C lcd(0x27, 20, 4);  // Default address of most PCF8574 modules, change according

byte verticalLine[8] = { 0b00100, 0b00100, 0b00100, 0b00100, 0b00100, 0b00100, 0b00100, 0b00100 };
byte char1[8] = { 0b00000, 0b00000, 0b00000, 0b00111, 0b00100, 0b00100, 0b00100, 0b00100 };
byte char2[8] = { 0b00000, 0b00000, 0b00000, 0b11100, 0b00100, 0b00100, 0b00100, 0b00100 };
byte char3[8] = { 0b00100, 0b00100, 0b00100, 0b00111, 0b00000, 0b00000, 0b00000, 0b00000 };
byte char4[8] = { 0b00100, 0b00100, 0b00100, 0b11100, 0b00000, 0b00000, 0b00000, 0b00000 };
byte Cursor1[8] = { 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b11111, 0b00000 };
byte Cursor2[8] = { 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000 };
byte tick[8] = { 0b00000, 0b00000, 0b00001, 0b10010, 0b10100, 0b11000, 0b10000 };

const int row_B = 52, col_A = 75;
extern const float table54[row_B][col_A];
const int row_F = 92, col_E = 59;
extern const float table1121[row_F][col_E];

int arraySize1, arraySize2;
int maxIndex1, maxIndex2;

//Setup 4x4 keypad
const byte ROWS = 4;  //four rows
const byte COLS = 4;  //four columns
char customKey;

//define the cymbols on the buttons of the keypads
char hexaKeys[ROWS][COLS] = {
  { 'A', 'B', 'C', 'D' },
  { '7', '8', '9', '0' },
  { '4', '5', '6', '.' },
  { '1', '2', '3', '=' }
};
byte rowPins[ROWS] = { 8, 9, 10, 11 };  //connect to the row pinouts of the keypad
byte colPins[COLS] = { 12, 13, 14, 15 };  //connect to the column pinouts of the keypad

//initialize an instance of class NewKeypad
Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);

//int modeAddress = 80;                           // mode value address
int modeValue = 1;

void setup() {
  //Wire.setSDA(4);
  //Wire.setSCL(5);
  Wire.begin();
  //Wire1.begin();
  
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ;  // wait for serial port to connect. Needed for native USB port only
  }

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

  lcd.createChar(5, Cursor1);
  lcd.createChar(6, Cursor2);
  lcd.createChar(7, tick);

  for (int p = 0; p < 20; p++) {  // Test 16x2 LCD display
    for (int o = 0; o < 4; o++) {
      lcd.setCursor(p, o);
      lcd.write(255);
    }
  }
  delay(1000);
  lcd.clear();
  delay(200);

  //Welcome message frame
  createCustomCharacters();
  printFrame();

  // Welcome message on LCD
  lcd.setCursor(1, 1);
  lcd.print(F("    CALC TABLE    "));
  lcd.setCursor(1, 2);
  lcd.print(SKETCHVERSION);
  delay(1500);
  lcd.clear();
  delay(200);

  //int eeAddress = 0;                    // Address of EEPROM byte to get next

  //--------------
  arraySize1 = sizeof(table54);    // Gets the size of the array in bytes
  maxIndex1 = arraySize1 / 4 - 1;  // Size /2 (bytes in an int) /2 (for a bidimensional array) - 1 (as index starts at 0)

  arraySize2 = sizeof(table1121);  // Gets the size of the array in bytes
  maxIndex2 = arraySize2 / 4 - 1;  // Size /2 (bytes in an int) /2 (for a bidimensional array) - 1 (as index starts at 0)

  // Print dimensions of the array
  Serial.print(F("Table 54 Array Size (bytes): "));
  Serial.println(arraySize1);
  Serial.print(F("# of rows: "));
  Serial.println(maxIndex1 + 1);
  Serial.print(F("Table 11.2.1 Array Size (bytes): "));
  Serial.println(arraySize2);
  Serial.print(F("# of rows: "));
  Serial.println(maxIndex2 + 1);
  //---------------
}

// Current time in milliseconds
unsigned long time;

float API = 38.00;
//float temp = 34.6;
float pressure = 30.0;
float density = 0.8000;
int i, j, k, l;
float a1, a2, b1, b2, b1a1, ba1, b2a1, b1a, dba, b2a, b1a2, ba2, b2a2, CTL;
float e1, e2, f1, f2, f1e1, fe1, f2e1, f1e, dfe, f2e, f1e2, fe2, f2e2, CPL;

static boolean setmodeActive = false;
static boolean presentValue = false;
static boolean final = false;
static boolean blinkCursor = true;
float temp54, temp11, cnv_temp11;
int DpCount = 0;
int charCount = 0;
String temp_num;

static boolean set_Den = false;
static boolean DenValue = false;
static boolean den_final = false;
static boolean Den_done = false;
int denCount = 0;
String Dnum;

static boolean set_API = false;
static boolean APIValue = false;
static boolean API_final = false;
static boolean API_done = false;
int APICount = 0;
String APInum;

static boolean set_Press = false;
static boolean PressValue = false;
static boolean Press_final = false;
static boolean Press_done = false;
int PressCount = 0;
String Pressnum;

float L54_temp = table54[1][0];
float H54_temp = table54[51][0];
float L11_temp = table1121[1][0];
float H11_temp = table1121[91][0];
float L_Den = table54[0][1];
float H_Den = table54[0][74];
float L_API = table1121[0][1];
float H_API = table1121[0][58];

void loop() {

  modeTable54();
  modeTable11_2_1();
  Set_mode();

}  //End main

/********************************************************
  Function for Table 54
********************************************************/
void modeTable54() {
  while (modeValue == 1 && setmodeActive == false) {

    lcd.setCursor(0, 0);
    lcd.print(F("______TABLE 54______"));
    lcd.setCursor(0, 1);
    lcd.print(F("Dens.: "));
    lcd.print(density, 4);
    lcd.setCursor(15, 1);
    lcd.print(F("kg/m3"));
        lcd.setCursor(0, 2);
    lcd.print(F("Temp.: "));
    lcd.setCursor(16, 2);
    lcd.print(F("DegC"));
    lcd.setCursor(0, 3);
    lcd.print(F("CTL  : "));

    customKey = customKeypad.getKey();
    if (customKey != NO_KEY && (customKey == '1' || customKey == '2' || customKey == '3' || customKey == '4' || customKey == '5' || customKey == '6' || customKey == '7' || customKey == '8' || customKey == '9' || customKey == '0' || customKey == '.')) {
      if (presentValue == false) {
        blinkCursor = true;
        temp_num = temp_num + customKey;
        if (blinkCursor == true) {
          charCount++;
        }
        for (int m = 0; m < temp_num.length(); m++) {
          if (customKey == '.') {
            DpCount++;
            break;
          } else if (temp_num.length() == 5) {
            presentValue = true;
            break;
          }
        }
        if (DpCount > 1 || (temp_num[0] == '.' && temp_num[1] == NO_KEY)) {
          final = false;
        } else {
          final = true;
        }
        lcd.setCursor(7, 2);
        lcd.print(temp_num);
        temp54 = temp_num.toFloat();

        if (temp54 < L54_temp || temp54 > H54_temp) {
          final = false;
        } else {
          final = true;
        }
      }
    } else if (final == true && customKey != NO_KEY && customKey == '=') {
      blinkCursor = false;
      //presentValue = true;
      //lcd.clear();
      lcd.setCursor(7, 2);
      lcd.print(F("         "));
      lcd.setCursor(7, 2);
      lcd.print(temp54);
      Table54_calc();

    } else if (final == false && customKey != NO_KEY && customKey == '=') {
      blinkCursor = false;
      presentValue = true;
      //lcd.clear();
      lcd.setCursor(7, 2);
      lcd.print(F("         "));
      lcd.setCursor(8, 3);
      lcd.print(F("Invalid"));
      time = millis();
    } else if (final == false && presentValue == true && ((millis() - time) > 2000L)) {
      lcd.setCursor(7, 3);
      lcd.print(F("            "));
      presentValue = false;
      final = false;
      temp_num = "";
      temp54 = 0;
      DpCount = 0;
      charCount = 0;
      blinkCursor = true;
    } else if (customKey != NO_KEY && customKey == 'D') {
      CLRpress();
      blinkCursor = true;
    } else if (customKey == 'B') {
      modeValue = 2;
      blinkCursor = true;
      CLRpress();
      break;
    } else if (customKey == 'C') {
      setmodeActive = true;
      CLRpress();
      break;
    } else if (blinkCursor == true) {
      lcd.setCursor(7 + charCount, 2);
      updateCursor();
    }
    //lcd.setCursor(0, 3);
    //lcd.print(DpCount);
  }
}

/********************************************************
  Function for Table 11.2.1
********************************************************/
void modeTable11_2_1() {
  while (modeValue == 2 && setmodeActive == false) {
    lcd.setCursor(0, 0);
    lcd.print(F("____TABLE 11.2.1____"));
    lcd.setCursor(0, 1);
    lcd.print(F("API  : "));
    lcd.print(API);
    lcd.print(F(" ["));
    lcd.print(pressure, 1);
    lcd.setCursor(19, 1);
    lcd.print(F("]"));
    lcd.setCursor(0, 2);
    lcd.print(F("Temp.: "));
    lcd.setCursor(16, 2);
    lcd.print(F("DegC"));
    lcd.setCursor(0, 3);
    lcd.print(F("CPL  : "));
    customKey = customKeypad.getKey();
    if (customKey != NO_KEY && (customKey == '1' || customKey == '2' || customKey == '3' || customKey == '4' || customKey == '5' || customKey == '6' || customKey == '7' || customKey == '8' || customKey == '9' || customKey == '0' || customKey == '.')) {
      if (presentValue == false) {
        blinkCursor = true;
        temp_num = temp_num + customKey;
        if (blinkCursor == true) {
          charCount++;
        }
        for (int m = 0; m < temp_num.length(); m++) {
          if (customKey == '.') {
            DpCount++;
            break;
          } else if (temp_num.length() == 5) {
            presentValue = true;
            break;
          }
        }
        if (DpCount > 1 || (temp_num[0] == '.' && temp_num[1] == NO_KEY)) {
          final = false;
        } else {
          final = true;
        }
        lcd.setCursor(7, 2);
        lcd.print(temp_num);
        temp11 = temp_num.toFloat();
        cnv_temp11 = (temp11 * 1.8) + 32.0;

        if (cnv_temp11 < L11_temp || cnv_temp11 > H11_temp) {
          final = false;
        } else {
          final = true;
        }
      }
    } else if (final == true && customKey != NO_KEY && customKey == '=') {
      blinkCursor = false;
      //presentValue = true;
      //lcd.clear();
      lcd.setCursor(7, 2);
      lcd.print(F("         "));
      lcd.setCursor(7, 2);
      lcd.print(temp11);
      Table1121_calc();

    } else if (final == false && customKey != NO_KEY && customKey == '=') {
      blinkCursor = false;
      presentValue = true;
      //lcd.clear();
      lcd.setCursor(7, 2);
      lcd.print(F("         "));
      lcd.setCursor(7, 3);
      lcd.print(F("Invalid"));
      time = millis();
    } else if (final == false && presentValue == true && ((millis() - time) > 2000L)) {
      lcd.setCursor(7, 3);
      lcd.print(F("            "));
      presentValue = false;
      final = false;
      temp_num = "";
      temp11 = 0;
      cnv_temp11 = 0;
      DpCount = 0;
      charCount = 0;
      blinkCursor = true;
    } else if (customKey != NO_KEY && customKey == 'D') {
      CLRpress();
      blinkCursor = true;
    } else if (customKey == 'A') {
      modeValue = 1;
      blinkCursor = true;
      CLRpress();
      break;
    } else if (customKey == 'C') {
      setmodeActive = true;
      CLRpress();
      break;
    } else if (blinkCursor == true) {
      lcd.setCursor(7 + charCount, 2);
      updateCursor();
    }
    //lcd.setCursor(0, 3);
    //lcd.print(DpCount);
  }
}

/********************************************************
  Function setup mode
********************************************************/
void Set_mode() {

  lcd.setCursor(0, 0);
  lcd.print(F("_______SETUP________"));

  while (setmodeActive == true) {
    customKey = customKeypad.getKey();  // Button read

    lcd.setCursor(0, 1);
    lcd.print(F("[1] Dens. : "));
    lcd.print(density, 4);
    lcd.setCursor(19, 1);
    lcd.write((byte)7);
    lcd.setCursor(0, 2);
    lcd.print(F("[2] API   : "));
    lcd.print(API);
    lcd.setCursor(19, 2);
    lcd.write((byte)7);
    lcd.setCursor(0, 3);
    lcd.print(F("[3] Press.: "));
    lcd.print(pressure);
    lcd.setCursor(19, 3);
    lcd.write((byte)7);

    switch (customKey) {
      case '1':
        set_Den = true;
        set_API = false;
        set_Press = false;
        DenValue = false;
        den_final = false;
        Den_done = false;
        blinkCursor = true;
        Dnum = "";
        density = 0;
        //lcd.clear();
        lcd.setCursor(0, 1);
        lcd.print(F("                    "));
        lcd.setCursor(0, 2);
        lcd.print(F("                    "));
        lcd.setCursor(0, 3);
        lcd.print(F("                    "));
        lcd.setCursor(0, 1);
        lcd.print(F("Dens. : "));
        lcd.setCursor(0, 2);
        lcd.print(F("[kg/m3]"));
        lcd.setCursor(0, 3);
        lcd.print(F("Range: 0.635 - 1.000"));
        Den_param();
        break;

      case '2':
        set_API = true;
        set_Den = false;
        set_Press = false;
        APIValue = false;
        API_final = false;
        API_done = false;
        blinkCursor = true;
        APInum = "";
        API = 0;
        //lcd.clear();
        lcd.setCursor(0, 1);
        lcd.print(F("                    "));
        lcd.setCursor(0, 2);
        lcd.print(F("                    "));
        lcd.setCursor(0, 3);
        lcd.print(F("                    "));
        lcd.setCursor(0, 1);
        lcd.print(F("API   : "));
        lcd.setCursor(0, 3);
        lcd.print(F("Range: 31.5 - 60.0  "));
        API_param();
        break;

      case '3':
        set_Press = true;
        set_API = false;
        set_Den = false;
        PressValue = false;
        Press_final = false;
        Press_done = false;
        blinkCursor = true;
        Pressnum = "";
        pressure = 0;
        //lcd.clear();
        lcd.setCursor(0, 1);
        lcd.print(F("                    "));
        lcd.setCursor(0, 2);
        lcd.print(F("                    "));
        lcd.setCursor(0, 3);
        lcd.print(F("                    "));
        lcd.setCursor(0, 1);
        lcd.print(F("Press.: "));
        lcd.setCursor(0, 2);
        lcd.print(F("[psig]"));
        lcd.setCursor(0, 3);
        lcd.print(F("Range: 0.0 - 300.0  "));
        Press_param();
        break;

      case 'D':
        lcd.clear();
        setmodeActive = false;
        Den_done = false;
        set_Den = false;
        API_done = false;
        set_API = false;
        Press_done = false;
        set_Press = false;
        blinkCursor = true;
        Dnum = "";
        break;
    }
    break;
  }
}

/********************************************************
  Function set Density
********************************************************/
void Den_param() {

  while (set_Den == true && setmodeActive == true) {

    customKey = customKeypad.getKey();
    if (customKey != NO_KEY && (customKey == '1' || customKey == '2' || customKey == '3' || customKey == '4' || customKey == '5' || customKey == '6' || customKey == '7' || customKey == '8' || customKey == '9' || customKey == '0' || customKey == '.')) {
      if (DenValue == false) {
        blinkCursor = true;
        Dnum = Dnum + customKey;
        if (blinkCursor == true) {
          denCount++;
        }
        for (int m = 0; m < Dnum.length(); m++) {
          if (customKey == '.') {
            DpCount++;
            break;
          } else if (Dnum.length() == 6) {
            DenValue = true;
            break;
          }
        }
        if (DpCount > 1 || (Dnum[0] == '.' && Dnum[1] == NO_KEY)) {
          den_final = false;
        } else {
          den_final = true;
        }
        lcd.setCursor(8, 1);
        lcd.print(Dnum);
        density = Dnum.toFloat();

        if (density < L_Den || density > H_Den || density == 0) {
          den_final = false;
        } else {
          den_final = true;
        }
      }
    } else if (den_final == true && customKey != NO_KEY && customKey == '=') {
      blinkCursor = false;
      DenValue = true;
      Den_done = true;
      DpCount = 0;
      denCount = 0;
      lcd.clear();
      lcd.setCursor(8, 1);
      lcd.print(F("            "));
      lcd.setCursor(8, 1);
      lcd.print(density, 4);
      lcd.setCursor(19, 1);
      lcd.write((byte)7);
      break;
    } else if (den_final == false && customKey != NO_KEY && customKey == '=') {
      blinkCursor = false;
      DenValue = true;
      DpCount = 0;
      denCount = 0;
      //lcd.clear();
      lcd.setCursor(8, 1);
      lcd.print(F("            "));
      lcd.setCursor(8, 1);
      lcd.print(F("Invalid"));
      time = millis();
    } else if (den_final == false && DenValue == true && ((millis() - time) > 2000L)) {
      lcd.setCursor(8, 1);
      lcd.print(F("           "));
      DenValue = false;
      den_final = false;
      Dnum = "";
      density = 0;
      DpCount = 0;
      denCount = 0;
      blinkCursor = true;
    } else if (customKey != NO_KEY && customKey == 'D') {
      lcd.setCursor(8, 1);
      lcd.print(F("            "));
      DenValue = false;
      den_final = false;
      Dnum = "";
      density = 0;
      DpCount = 0;
      denCount = 0;
      blinkCursor = true;

    } else if (blinkCursor == true) {
      lcd.setCursor(8 + denCount, 1);
      updateCursor();
    }
  }
}

/********************************************************
  Function set API
********************************************************/
void API_param() {

  while (set_API == true && setmodeActive == true) {

    customKey = customKeypad.getKey();
    if (customKey != NO_KEY && (customKey == '1' || customKey == '2' || customKey == '3' || customKey == '4' || customKey == '5' || customKey == '6' || customKey == '7' || customKey == '8' || customKey == '9' || customKey == '0' || customKey == '.')) {
      if (APIValue == false) {
        blinkCursor = true;
        APInum = APInum + customKey;
        if (blinkCursor == true) {
          APICount++;
        }
        for (int m = 0; m < APInum.length(); m++) {
          if (customKey == '.') {
            DpCount++;
            break;
          } else if (APInum.length() == 5) {
            APIValue = true;
            break;
          }
        }
        if (DpCount > 1 || (APInum[0] == '.' && APInum[1] == NO_KEY)) {
          API_final = false;
        } else {
          API_final = true;
        }
        lcd.setCursor(8, 1);
        lcd.print(APInum);
        API = APInum.toFloat();

        if (API < L_API || API > H_API || API == 0) {
          API_final = false;
        } else {
          API_final = true;
        }
      }
    } else if (API_final == true && customKey != NO_KEY && customKey == '=') {
      blinkCursor = false;
      APIValue = true;
      API_done = true;
      DpCount = 0;
      APICount = 0;
      lcd.clear();
      lcd.setCursor(8, 1);
      lcd.print(F("            "));
      lcd.setCursor(8, 1);
      lcd.print(API);
      lcd.setCursor(19, 1);
      lcd.write((byte)7);
      break;
    } else if (API_final == false && customKey != NO_KEY && customKey == '=') {
      blinkCursor = false;
      APIValue = true;
      DpCount = 0;
      APICount = 0;
      //lcd.clear();
      lcd.setCursor(8, 1);
      lcd.print(F("            "));
      lcd.setCursor(8, 1);
      lcd.print(F("Invalid"));
      time = millis();
    } else if (API_final == false && APIValue == true && ((millis() - time) > 2000L)) {
      lcd.setCursor(8, 1);
      lcd.print(F("            "));
      APIValue = false;
      API_final = false;
      APInum = "";
      API = 0;
      DpCount = 0;
      APICount = 0;
      blinkCursor = true;
    } else if (customKey != NO_KEY && customKey == 'D') {
      lcd.setCursor(8, 1);
      lcd.print(F("            "));
      APIValue = false;
      API_final = false;
      APInum = "";
      API = 0;
      DpCount = 0;
      APICount = 0;
      blinkCursor = true;
    } else if (blinkCursor == true) {
      lcd.setCursor(8 + APICount, 1);
      updateCursor();
    }
  }
}

/********************************************************
  Function set Pressure
********************************************************/
void Press_param() {

  while (set_Press == true && setmodeActive == true) {

    customKey = customKeypad.getKey();
    if (customKey != NO_KEY && (customKey == '1' || customKey == '2' || customKey == '3' || customKey == '4' || customKey == '5' || customKey == '6' || customKey == '7' || customKey == '8' || customKey == '9' || customKey == '0' || customKey == '.')) {
      if (PressValue == false) {
        blinkCursor = true;
        Pressnum = Pressnum + customKey;
        if (blinkCursor == true) {
          PressCount++;
        }
        for (int m = 0; m < Pressnum.length(); m++) {
          if (customKey == '.') {
            DpCount++;
            break;
          } else if (Pressnum.length() == 5) {
            PressValue = true;
            break;
          }
        }
        if (DpCount > 1 || (Pressnum[0] == '.' && Pressnum[1] == NO_KEY)) {
          Press_final = false;
        } else {
          Press_final = true;
        }
        lcd.setCursor(8, 1);
        lcd.print(Pressnum);
        pressure = Pressnum.toFloat();
        if (pressure > 300.0) {
          Press_final = false;
        } else {
          Press_final = true;
        }
      }
    } else if (Press_final == true && customKey != NO_KEY && customKey == '=') {
      blinkCursor = false;
      PressValue = true;
      Press_done = true;
      DpCount = 0;
      PressCount = 0;
      lcd.clear();
      lcd.setCursor(8, 1);
      lcd.print(F("            "));
      lcd.setCursor(8, 1);
      lcd.print(pressure);
      lcd.setCursor(19, 1);
      lcd.write((byte)7);
      break;
    } else if (Press_final == false && customKey != NO_KEY && customKey == '=') {
      blinkCursor = false;
      PressValue = true;
      DpCount = 0;
      PressCount = 0;
      //lcd.clear();
      lcd.setCursor(8, 1);
      lcd.print(F("            "));
      lcd.setCursor(8, 1);
      lcd.print(F("Invalid"));
      time = millis();
    } else if (Press_final == false && PressValue == true && ((millis() - time) > 2000L)) {
      lcd.setCursor(8, 1);
      lcd.print(F("            "));
      PressValue = false;
      Press_final = false;
      Pressnum = "";
      pressure = 0;
      DpCount = 0;
      PressCount = 0;
      blinkCursor = true;
    } else if (customKey != NO_KEY && customKey == 'D') {
      lcd.setCursor(8, 1);
      lcd.print(F("            "));
      PressValue = false;
      Press_final = false;
      Pressnum = "";
      pressure = 0;
      DpCount = 0;
      PressCount = 0;
      blinkCursor = true;
    } else if (blinkCursor == true) {
      lcd.setCursor(8 + PressCount, 1);
      updateCursor();
    }
    // lcd.setCursor(0, 2);
    // lcd.print(DpCount);
  }
}

/********************************************************
  Function Table 54 calculation
********************************************************/
void Table54_calc() {
  for (i = 0; (i < row_B && presentValue == false); i++) {
    for (j = 0; (j < col_A && presentValue == false); j++) {
      if ((temp54 >= table54[i][0] && temp54 <= table54[i + 2][0]) && (density >= table54[0][j] && density <= table54[0][j + 2])) {
        // Serial.print("Temp: ");
        // Serial.println(temp, 1);
        // Serial.print("Density:  ");
        // Serial.println(density, 4);
        // Serial.println("\n");

        b1 = table54[i + 1][0];
        b2 = table54[i + 2][0];
        a1 = table54[0][j + 1];
        a2 = table54[0][j + 2];
        b1a1 = table54[i + 1][j + 1];
        b2a1 = table54[i + 2][j + 1];
        b1a2 = table54[i + 1][j + 2];
        b2a2 = table54[i + 2][j + 2];
        ba1 = (temp54 - b1) / (b2 - b1) * (b2a1 - b1a1) + b1a1;
        ba2 = (temp54 - b1) / (b2 - b1) * (b2a2 - b1a2) + b1a2;
        dba = (density - a1) / (a2 - a1) * (ba2 - ba1) + ba1;
        CTL = dba;
        Serial.println(dba, 6);
        lcd.setCursor(7, 3);
        lcd.print(CTL, 6);
        presentValue = true;
        break;
      }
    }
  }
}

/********************************************************
  Function Table 11.2.1 calculation
********************************************************/
void Table1121_calc() {

  for (k = 0; (k < row_F && presentValue == false); k++) {
    for (l = 0; (l < col_E && presentValue == false); l++) {
      if ((cnv_temp11 >= table1121[k][0] && cnv_temp11 <= table1121[k + 2][0]) && (API >= table1121[0][l] && API <= table1121[0][l + 2])) {
        //Serial.print("Temp: ");
        //Serial.println(temp, 1);
        //Serial.print("API:  ");
        //Serial.println(API, 4);
        //Serial.println("\n");

        f1 = table1121[k + 1][0];
        f2 = table1121[k + 2][0];
        e1 = table1121[0][l + 1];
        e2 = table1121[0][l + 2];
        f1e1 = table1121[k + 1][l + 1];
        f2e1 = table1121[k + 2][l + 1];
        f1e2 = table1121[k + 1][l + 2];
        f2e2 = table1121[k + 2][l + 2];
        fe1 = (cnv_temp11 - f1) / (f2 - f1) * (f2e1 - f1e1) + f1e1;
        fe2 = (cnv_temp11 - f1) / (f2 - f1) * (f2e2 - f1e2) + f1e2;
        dfe = (API - e1) / (e2 - e1) * (fe2 - fe1) + fe1;
        CPL = (dfe / 100000.0 * pressure) + 1.0;
        Serial.println(CPL, 6);
        lcd.setCursor(7, 3);
        lcd.print(CPL, 6);
        presentValue = true;
        break;
      }
    }
  }
}

/********************************************************
  Function Clear press
********************************************************/
void CLRpress() {
  lcd.clear();
  //lcd.setCursor(8, 2);
  //lcd.print(F("           "));
  //lcd.setCursor(8, 3);
  //lcd.print(F("           "));
  presentValue = false;
  final = false;
  temp_num = "";
  temp54 = 0;
  temp11 = 0;
  cnv_temp11 = 0;
  DpCount = 0;
  charCount = 0;
}

/********************************************************
  Function Update Cursor
********************************************************/
void updateCursor() {
  if (millis() / 250 % 2 == 0) {
    lcd.write((byte)5);
  } else {
    lcd.write((byte)6);
  }
}



/********************************************************
  Function welcome frame
********************************************************/
void printFrame() {
  lcd.setCursor(1, 0);
  lcd.print("------------------");
  lcd.setCursor(1, 3);
  lcd.print("------------------");
  lcd.setCursor(0, 1);
  lcd.write(byte(0));
  lcd.setCursor(0, 2);
  lcd.write(byte(0));
  lcd.setCursor(19, 1);
  lcd.write(byte(0));
  lcd.setCursor(19, 2);
  lcd.write(byte(0));
  lcd.setCursor(0, 0);
  lcd.write(byte(1));
  lcd.setCursor(19, 0);
  lcd.write(byte(2));
  lcd.setCursor(0, 3);
  lcd.write(byte(3));
  lcd.setCursor(19, 3);
  lcd.write(byte(4));
}

/********************************************************
  Function create custom character (frame)
********************************************************/
void createCustomCharacters() {
  lcd.createChar(0, verticalLine);
  lcd.createChar(1, char1);
  lcd.createChar(2, char2);
  lcd.createChar(3, char3);
  lcd.createChar(4, char4);
}