#include <stdio.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);

int L_R1 = 43;
int L_R2 = 37;
int L_R3 = 31;
int L_R4 = 42;
int L_R5 = 36;
int L_R6 = 30;

int L_A1 = 45;
int L_A2 = 39;
int L_A3 = 33;
int L_A4 = 44;
int L_A5 = 38;
int L_A6 = 32;

int L_G1 = 47;
int L_G2 = 41;
int L_G3 = 35;
int L_G4 = 46;
int L_G5 = 40;
int L_G6 = 34;

int sw_menu = 2; int state_menu = 0;
int sw_flash = 3; int state_flash = 0;

unsigned long previousMillis = 0;
const long interval = 1000;

unsigned long FlashingpreviousMillis = 0;
const long Flashinginterval = 500;

const int rows = 4;
const int cols = 4;
const int rowPins[rows] = {A7, A6, A5, A4}; 
const int colPins[cols] = {A3, A2, A1, A0}; 

const char buttonMap[4][4] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

//===== SETTINGS NODE =====
int Stg_Mode = 0;
int Stg_Stage = 1;
int Stg_Step = 0;
int OP_CurPhase = 1;
int OP_CurLightGR1 = 1; int OP_CurLightGR2 = 1;
int OP_CurLightGR3 = 1; int OP_CurLightGR4 = 1;
char BTNCOL = 0;
int TMP_NoOfGroupStep = 1;
int TempGrSet = 1;
int GrSetCountPS1 = 0; int GrSetCountPS2 = 0; int GrSetCountPS3 = 0; int GrSetCountPS4 = 0;
int GrSetCountPS5 = 0; int GrSetCountPS6 = 0;
int TempGrSetPos = 1;
boolean endofsetting = false;
boolean starter = true;
String accumulatedInput = "";
String accu_day = ""; String accu_hour = ""; String accu_min = ""; String accu_sec = "";
int Set_Day = 0;
int Set_Hour = 0; int Set_Min = 0; int Set_Sec = 0;
static String statusBuffer[4];
boolean F1, F2, F3, F4, F5, F6;
//=========================

//===== TMP SETTINGS DATA NODE/EEPROM DATA EMULATION =====
int TMP_NoOfGroup = 3;
int TMP_GR1_VAL1 = 1; int TMP_GR1_VAL2 = 2; int TMP_GR1_VAL3 = 0; int TMP_GR1_VAL4 = 0;
int TMP_GR2_VAL1 = 3; int TMP_GR2_VAL2 = 0; int TMP_GR2_VAL3 = 0; int TMP_GR2_VAL4 = 0;
int TMP_GR3_VAL1 = 4; int TMP_GR3_VAL2 = 0; int TMP_GR3_VAL3 = 0; int TMP_GR3_VAL4 = 0;
int TMP_GR4_VAL1 = 0; int TMP_GR4_VAL2 = 0; int TMP_GR4_VAL3 = 0; int TMP_GR4_VAL4 = 0;
int TMP_GR5_VAL1 = 0; int TMP_GR5_VAL2 = 0; int TMP_GR5_VAL3 = 0; int TMP_GR5_VAL4 = 0;
int TMP_GR6_VAL1 = 0; int TMP_GR6_VAL2 = 0; int TMP_GR6_VAL3 = 0; int TMP_GR6_VAL4 = 0;
int TMP_GRF_VAL1 = 0; int TMP_GRF_VAL2 = 0; int TMP_GRF_VAL3 = 0; int TMP_GRF_VAL4 = 0; int TMP_GRF_VAL5 = 0; int TMP_GRF_VAL6 = 0;

int TMP_PHASE1_GR1_R = 2; int TMP_PHASE1_GR1_A = 3; int TMP_PHASE1_GR1_G = 10;
int TMP_PHASE1_GR2_R = 2; int TMP_PHASE1_GR2_A = 3; int TMP_PHASE1_GR2_G = 5;
int TMP_PHASE1_GR3_R = 0; int TMP_PHASE1_GR3_A = 0; int TMP_PHASE1_GR3_G = 0;
int TMP_PHASE1_GR4_R = 0; int TMP_PHASE1_GR4_A = 0; int TMP_PHASE1_GR4_G = 0;

int TMP_PHASE2_GR1_R = 2; int TMP_PHASE2_GR1_A = 3; int TMP_PHASE2_GR1_G = 7;
int TMP_PHASE2_GR2_R = 0; int TMP_PHASE2_GR2_A = 0; int TMP_PHASE2_GR2_G = 0;
int TMP_PHASE2_GR3_R = 0; int TMP_PHASE2_GR3_A = 0; int TMP_PHASE2_GR3_G = 0;
int TMP_PHASE2_GR4_R = 0; int TMP_PHASE2_GR4_A = 0; int TMP_PHASE2_GR4_G = 0;

int TMP_PHASE3_GR1_R = 2; int TMP_PHASE3_GR1_A = 3; int TMP_PHASE3_GR1_G = 5;
int TMP_PHASE3_GR2_R = 0; int TMP_PHASE3_GR2_A = 0; int TMP_PHASE3_GR2_G = 0;
int TMP_PHASE3_GR3_R = 0; int TMP_PHASE3_GR3_A = 0; int TMP_PHASE3_GR3_G = 0;
int TMP_PHASE3_GR4_R = 0; int TMP_PHASE3_GR4_A = 0; int TMP_PHASE3_GR4_G = 0;

int TMP_PHASE4_GR1_R = 2; int TMP_PHASE4_GR1_A = 3; int TMP_PHASE4_GR1_G = 4;
int TMP_PHASE4_GR2_R = 0; int TMP_PHASE4_GR2_A = 0; int TMP_PHASE4_GR2_G = 0;
int TMP_PHASE4_GR3_R = 0; int TMP_PHASE4_GR3_A = 0; int TMP_PHASE4_GR3_G = 0;
int TMP_PHASE4_GR4_R = 0; int TMP_PHASE4_GR4_A = 0; int TMP_PHASE4_GR4_G = 0;

int TMP_PHASE5_GR1_R = 0; int TMP_PHASE5_GR1_A = 0; int TMP_PHASE5_GR1_G = 0;
int TMP_PHASE5_GR2_R = 0; int TMP_PHASE5_GR2_A = 0; int TMP_PHASE5_GR2_G = 0;
int TMP_PHASE5_GR3_R = 0; int TMP_PHASE5_GR3_A = 0; int TMP_PHASE5_GR3_G = 0;
int TMP_PHASE5_GR4_R = 0; int TMP_PHASE5_GR4_A = 0; int TMP_PHASE5_GR4_G = 0;

int TMP_PHASE6_GR1_R = 0; int TMP_PHASE6_GR1_A = 0; int TMP_PHASE6_GR1_G = 0;
int TMP_PHASE6_GR2_R = 0; int TMP_PHASE6_GR2_A = 0; int TMP_PHASE6_GR2_G = 0;
int TMP_PHASE6_GR3_R = 0; int TMP_PHASE6_GR3_A = 0; int TMP_PHASE6_GR3_G = 0;
int TMP_PHASE6_GR4_R = 0; int TMP_PHASE6_GR4_A = 0; int TMP_PHASE6_GR4_G = 0;

void loadEEPROMdata(){
  TMP_NoOfGroup = 3;

  TMP_PHASE1_GR1_R = 2; TMP_PHASE1_GR1_A = 3; TMP_PHASE1_GR1_G = 10;
  TMP_PHASE1_GR2_R = 2; TMP_PHASE1_GR2_A = 3; TMP_PHASE1_GR2_G = 5;
  TMP_PHASE1_GR3_R = 0; TMP_PHASE1_GR3_A = 0; TMP_PHASE1_GR3_G = 0;
  TMP_PHASE1_GR4_R = 0; TMP_PHASE1_GR4_A = 0; TMP_PHASE1_GR4_G = 0;

  TMP_PHASE2_GR1_R = 2; TMP_PHASE2_GR1_A = 3; TMP_PHASE2_GR1_G = 7;
  TMP_PHASE2_GR2_R = 0; TMP_PHASE2_GR2_A = 0; TMP_PHASE2_GR2_G = 0;
  TMP_PHASE2_GR3_R = 0; TMP_PHASE2_GR3_A = 0; TMP_PHASE2_GR3_G = 0;
  TMP_PHASE2_GR4_R = 0; TMP_PHASE2_GR4_A = 0; TMP_PHASE2_GR4_G = 0;

  TMP_PHASE3_GR1_R = 2; TMP_PHASE3_GR1_A = 3; TMP_PHASE3_GR1_G = 5;
  TMP_PHASE3_GR2_R = 0; TMP_PHASE3_GR2_A = 0; TMP_PHASE3_GR2_G = 0;
  TMP_PHASE3_GR3_R = 0; TMP_PHASE3_GR3_A = 0; TMP_PHASE3_GR3_G = 0;
  TMP_PHASE3_GR4_R = 0; TMP_PHASE3_GR4_A = 0; TMP_PHASE3_GR4_G = 0;

  TMP_PHASE4_GR1_R = 0; TMP_PHASE4_GR1_A = 0; TMP_PHASE4_GR1_G = 0;
  TMP_PHASE4_GR2_R = 0; TMP_PHASE4_GR2_A = 0; TMP_PHASE4_GR2_G = 0;
  TMP_PHASE4_GR3_R = 0; TMP_PHASE4_GR3_A = 0; TMP_PHASE4_GR3_G = 0;
  TMP_PHASE4_GR4_R = 0; TMP_PHASE4_GR4_A = 0; TMP_PHASE4_GR4_G = 0;

  TMP_PHASE5_GR1_R = 0; TMP_PHASE5_GR1_A = 0; TMP_PHASE5_GR1_G = 0;
  TMP_PHASE5_GR2_R = 0; TMP_PHASE5_GR2_A = 0; TMP_PHASE5_GR2_G = 0;
  TMP_PHASE5_GR3_R = 0; TMP_PHASE5_GR3_A = 0; TMP_PHASE5_GR3_G = 0;
  TMP_PHASE5_GR4_R = 0; TMP_PHASE5_GR4_A = 0; TMP_PHASE5_GR4_G = 0;

  TMP_PHASE6_GR1_R = 0; TMP_PHASE6_GR1_A = 0; TMP_PHASE6_GR1_G = 0;
  TMP_PHASE6_GR2_R = 0; TMP_PHASE6_GR2_A = 0; TMP_PHASE6_GR2_G = 0;
  TMP_PHASE6_GR3_R = 0; TMP_PHASE6_GR3_A = 0; TMP_PHASE6_GR3_G = 0;
  TMP_PHASE6_GR4_R = 0; TMP_PHASE6_GR4_A = 0; TMP_PHASE6_GR4_G = 0;
}


void UI(){
  lcd.setCursor(0, 0);
  lcd.print("Sun, 12:50:50"); //Phase name
  if (state_flash == LOW){
    lcd.setCursor(14, 0);
    lcd.print("FL");
    lcd.setCursor(0, 1);
    lcd.print("FLASHING  AX=000");
  }
}

void CountGrSet(){
  GrSetCountPS1 = GrSetCountPS2 = GrSetCountPS3 = GrSetCountPS4 = GrSetCountPS5 = GrSetCountPS6 = 0;
  if (TMP_GR1_VAL1 != 0){GrSetCountPS1++;} if (TMP_GR1_VAL2 != 0){GrSetCountPS1++;} if (TMP_GR1_VAL3 != 0){GrSetCountPS1++;} if (TMP_GR1_VAL4 != 0){GrSetCountPS1++;}
  if (TMP_GR2_VAL1 != 0){GrSetCountPS2++;} if (TMP_GR2_VAL2 != 0){GrSetCountPS2++;} if (TMP_GR2_VAL3 != 0){GrSetCountPS2++;} if (TMP_GR2_VAL4 != 0){GrSetCountPS2++;}
  if (TMP_GR3_VAL1 != 0){GrSetCountPS3++;} if (TMP_GR3_VAL2 != 0){GrSetCountPS3++;} if (TMP_GR3_VAL3 != 0){GrSetCountPS3++;} if (TMP_GR3_VAL4 != 0){GrSetCountPS3++;}
  if (TMP_GR4_VAL1 != 0){GrSetCountPS4++;} if (TMP_GR4_VAL2 != 0){GrSetCountPS4++;} if (TMP_GR4_VAL3 != 0){GrSetCountPS4++;} if (TMP_GR4_VAL4 != 0){GrSetCountPS4++;}
  if (TMP_GR5_VAL1 != 0){GrSetCountPS5++;} if (TMP_GR5_VAL2 != 0){GrSetCountPS5++;} if (TMP_GR5_VAL3 != 0){GrSetCountPS5++;} if (TMP_GR5_VAL4 != 0){GrSetCountPS5++;}
  if (TMP_GR6_VAL1 != 0){GrSetCountPS6++;} if (TMP_GR6_VAL2 != 0){GrSetCountPS6++;} if (TMP_GR6_VAL3 != 0){GrSetCountPS6++;} if (TMP_GR6_VAL4 != 0){GrSetCountPS6++;}
  Serial.println("GrSet: "+String(GrSetCountPS1)+"-"+String(GrSetCountPS2)+"-"+String(GrSetCountPS3)+"-"+String(GrSetCountPS4)+"-"+String(GrSetCountPS5)+"-"+String(GrSetCountPS6));
}

void clearStatusBuffer() {
  for (int i = 0; i < 6; i++) {
    statusBuffer[i] = ""; // Clear each entry
    }
}

int onTimes[7][2] = {
  {0, 0},    // Sunday (always on)
  {5, 0},    // Monday
  {4, 35},   // Tuesday
  {0, 0},    // Wednesday (always on)
  {0, 0},    // Thursday (always on)
  {0, 0},    // Friday (always on)
  {0, 0}     // Saturday (always on)
};

int offTimes[7][2] = {
  {23, 59},  // Sunday (always on)
  {21, 59},  // Monday
  {23, 59},  // Tuesday
  {23, 59},  // Wednesday (always on)
  {23, 59},  // Thursday (always on)
  {23, 59},  // Friday (always on)
  {23, 59}   // Saturday (always on)
};

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

  lcd.init();
  lcd.backlight();
  pinMode(L_A1, OUTPUT); pinMode(L_A2, OUTPUT);
  pinMode(L_A3, OUTPUT); pinMode(L_A4, OUTPUT);
  pinMode(L_A5, OUTPUT); pinMode(L_A6, OUTPUT);
  pinMode(L_R1, OUTPUT); pinMode(L_R2, OUTPUT);
  pinMode(L_R3, OUTPUT); pinMode(L_R4, OUTPUT);
  pinMode(L_R5, OUTPUT); pinMode(L_R6, OUTPUT);
  pinMode(L_G1, OUTPUT); pinMode(L_G2, OUTPUT);
  pinMode(L_G3, OUTPUT); pinMode(L_G4, OUTPUT);
  pinMode(L_G5, OUTPUT); pinMode(L_G6, OUTPUT);

  pinMode(sw_menu, INPUT_PULLUP); pinMode(sw_flash, INPUT_PULLUP);

  for (int i = 0; i < rows; i++) {
    pinMode(rowPins[i], INPUT_PULLUP);
  }
  for (int i = 0; i < cols; i++) {
    pinMode(colPins[i], OUTPUT);
    digitalWrite(colPins[i], HIGH);
  }
  CountGrSet();
}

void getyellowflashing() {
  unsigned long currentMillis = millis();
  
  if (currentMillis - FlashingpreviousMillis >= Flashinginterval) {
          // save the last time you blinked the LEDs
          FlashingpreviousMillis = currentMillis;
          
            offallleds(); starter = true;
            // Toggle the state of LEDs
            static bool state = false;
            digitalWrite(L_A1, state ? HIGH : LOW);
            digitalWrite(L_A2, state ? HIGH : LOW);
            digitalWrite(L_A3, state ? HIGH : LOW);
            digitalWrite(L_A4, state ? HIGH : LOW);
            digitalWrite(L_A5, state ? HIGH : LOW);
            digitalWrite(L_A6, state ? HIGH : LOW);

            state = !state;  // Toggle state
        }
}

// Loop and print the time every second.
void loop() {
  state_menu = digitalRead(sw_menu);
  state_flash = digitalRead(sw_flash);

  if (state_menu == HIGH){
    unsigned long currentMillis = millis();


    if (state_flash == LOW){
      getyellowflashing();
      
      }
    UI();
    //delay(interval);

    if (currentMillis - previousMillis >= interval) {
      // save the last time you blinked the LEDs
      previousMillis = currentMillis;

        if (starter == true && state_flash == 1){
          offallleds(); OP_CurPhase = 1; OP_CurLightGR1 = 1; OP_CurLightGR2 = 1;
          OP_CurLightGR3 = 1; OP_CurLightGR4 = 1; loadEEPROMdata(); lcd.clear();
          int ScanGR1[4] = {TMP_GR1_VAL1, TMP_GR1_VAL2, TMP_GR1_VAL3, TMP_GR1_VAL4};
          int ScanGR2[4] = {TMP_GR2_VAL1, TMP_GR2_VAL2, TMP_GR2_VAL3, TMP_GR2_VAL4};
          int ScanGR3[4] = {TMP_GR3_VAL1, TMP_GR3_VAL2, TMP_GR3_VAL3, TMP_GR3_VAL4};
          int ScanGR4[4] = {TMP_GR4_VAL1, TMP_GR4_VAL2, TMP_GR4_VAL3, TMP_GR4_VAL4};
          int ScanGR5[4] = {TMP_GR5_VAL1, TMP_GR5_VAL2, TMP_GR5_VAL3, TMP_GR5_VAL4};
          int ScanGR6[4] = {TMP_GR6_VAL1, TMP_GR6_VAL2, TMP_GR6_VAL3, TMP_GR6_VAL4};
          int scanX = 0;

          while (scanX <= 3){
            if (ScanGR1[scanX] == 2 || ScanGR2[scanX] == 2 || ScanGR3[scanX] == 2
             || ScanGR4[scanX] == 2 || ScanGR5[scanX] == 2 || ScanGR6[scanX] == 2){digitalWrite(L_R2, HIGH);}

            if (ScanGR1[scanX] == 3 || ScanGR2[scanX] == 3 || ScanGR3[scanX] == 3
             || ScanGR4[scanX] == 3 || ScanGR5[scanX] == 3 || ScanGR6[scanX] == 3){digitalWrite(L_R3, HIGH);}
            
            if (ScanGR1[scanX] == 4 || ScanGR2[scanX] == 4 || ScanGR3[scanX] == 4
             || ScanGR4[scanX] == 4 || ScanGR5[scanX] == 4 || ScanGR6[scanX] == 4){digitalWrite(L_R4, HIGH);}
            
            if (ScanGR1[scanX] == 5 || ScanGR2[scanX] == 5 || ScanGR3[scanX] == 5
             || ScanGR4[scanX] == 5 || ScanGR5[scanX] == 5 || ScanGR6[scanX] == 5){digitalWrite(L_R5, HIGH);}
            
            if (ScanGR1[scanX] == 6 || ScanGR2[scanX] == 6 || ScanGR3[scanX] == 6
             || ScanGR4[scanX] == 6 || ScanGR5[scanX] == 6 || ScanGR6[scanX] == 6){digitalWrite(L_R6, HIGH);}
            
            scanX++;

            int ScanGRF[6] = {TMP_GRF_VAL1, TMP_GRF_VAL2, TMP_GRF_VAL3, TMP_GRF_VAL4, TMP_GRF_VAL5, TMP_GRF_VAL6};

            int scanY = 0;

              while (scanY <= 5){
                if (ScanGRF[scanY] == 1){F1 = true;}

                if (ScanGRF[scanY] == 2){F2 = true;}
                
                if (ScanGRF[scanY] == 3){F3 = true;}
                
                if (ScanGRF[scanY] == 4){F4 = true;}
                
                if (ScanGRF[scanY] == 5){F5 = true;}

                if (ScanGRF[scanY] == 6){F6 = true;}
                
                scanY++;
              }
          }

          starter = false; 
        }

        if (state_flash == 1){
          static bool state2 = false;
          if (F1 == true){digitalWrite(L_A1, state2 ? HIGH : LOW);}
          if (F2 == true){digitalWrite(L_A2, state2 ? HIGH : LOW);}
          if (F3 == true){digitalWrite(L_A3, state2 ? HIGH : LOW);}
          if (F4 == true){digitalWrite(L_A4, state2 ? HIGH : LOW);}
          if (F5 == true){digitalWrite(L_A5, state2 ? HIGH : LOW);}
          if (F6 == true){digitalWrite(L_A6, state2 ? HIGH : LOW);}

          state2 = !state2;
        
        int GR1, GR2, GR3, GR4;
        int *R1, *A1, *G1, *R2, *A2, *G2, *R3, *A3, *G3, *R4, *A4, *G4;

        // Select the groups and timer variables for the current phase
        switch (OP_CurPhase) {
            case 1:
                GR1 = TMP_GR1_VAL1; GR2 = TMP_GR1_VAL2; GR3 = TMP_GR1_VAL3; GR4 = TMP_GR1_VAL4;
                R1 = &TMP_PHASE1_GR1_R; A1 = &TMP_PHASE1_GR1_A; G1 = &TMP_PHASE1_GR1_G;
                R2 = &TMP_PHASE1_GR2_R; A2 = &TMP_PHASE1_GR2_A; G2 = &TMP_PHASE1_GR2_G;
                R3 = &TMP_PHASE1_GR3_R; A3 = &TMP_PHASE1_GR3_A; G3 = &TMP_PHASE1_GR3_G;
                R4 = &TMP_PHASE1_GR4_R; A4 = &TMP_PHASE1_GR4_A; G4 = &TMP_PHASE1_GR4_G;
                break;
            case 2:
                GR1 = TMP_GR2_VAL1; GR2 = TMP_GR2_VAL2; GR3 = TMP_GR2_VAL3; GR4 = TMP_GR2_VAL4;
                R1 = &TMP_PHASE2_GR1_R; A1 = &TMP_PHASE2_GR1_A; G1 = &TMP_PHASE2_GR1_G;
                R2 = &TMP_PHASE2_GR2_R; A2 = &TMP_PHASE2_GR2_A; G2 = &TMP_PHASE2_GR2_G;
                R3 = &TMP_PHASE2_GR3_R; A3 = &TMP_PHASE2_GR3_A; G3 = &TMP_PHASE2_GR3_G;
                R4 = &TMP_PHASE2_GR4_R; A4 = &TMP_PHASE2_GR4_A; G4 = &TMP_PHASE2_GR4_G;
                break;
            case 3:
                GR1 = TMP_GR3_VAL1; GR2 = TMP_GR3_VAL2; GR3 = TMP_GR3_VAL3; GR4 = TMP_GR3_VAL4;
                R1 = &TMP_PHASE3_GR1_R; A1 = &TMP_PHASE3_GR1_A; G1 = &TMP_PHASE3_GR1_G;
                R2 = &TMP_PHASE3_GR2_R; A2 = &TMP_PHASE3_GR2_A; G2 = &TMP_PHASE3_GR2_G;
                R3 = &TMP_PHASE3_GR3_R; A3 = &TMP_PHASE3_GR3_A; G3 = &TMP_PHASE3_GR3_G;
                R4 = &TMP_PHASE3_GR4_R; A4 = &TMP_PHASE3_GR4_A; G4 = &TMP_PHASE3_GR4_G;
                break;
            case 4:
                GR1 = TMP_GR4_VAL1; GR2 = TMP_GR4_VAL2; GR3 = TMP_GR4_VAL3; GR4 = TMP_GR4_VAL4;
                R1 = &TMP_PHASE4_GR1_R; A1 = &TMP_PHASE4_GR1_A; G1 = &TMP_PHASE4_GR1_G;
                R2 = &TMP_PHASE4_GR2_R; A2 = &TMP_PHASE4_GR2_A; G2 = &TMP_PHASE4_GR2_G;
                R3 = &TMP_PHASE4_GR3_R; A3 = &TMP_PHASE4_GR3_A; G3 = &TMP_PHASE4_GR3_G;
                R4 = &TMP_PHASE4_GR4_R; A4 = &TMP_PHASE4_GR4_A; G4 = &TMP_PHASE4_GR4_G;
                break;
            case 5:
                GR1 = TMP_GR5_VAL1; GR2 = TMP_GR5_VAL2; GR3 = TMP_GR5_VAL3; GR4 = TMP_GR5_VAL4;
                R1 = &TMP_PHASE5_GR1_R; A1 = &TMP_PHASE5_GR1_A; G1 = &TMP_PHASE5_GR1_G;
                R2 = &TMP_PHASE5_GR2_R; A2 = &TMP_PHASE5_GR2_A; G2 = &TMP_PHASE5_GR2_G;
                R3 = &TMP_PHASE5_GR3_R; A3 = &TMP_PHASE5_GR3_A; G3 = &TMP_PHASE5_GR3_G;
                R4 = &TMP_PHASE5_GR4_R; A4 = &TMP_PHASE5_GR4_A; G4 = &TMP_PHASE5_GR4_G;
                break;
            case 6:
                GR1 = TMP_GR6_VAL1; GR2 = TMP_GR6_VAL2; GR3 = TMP_GR6_VAL3; GR4 = TMP_GR6_VAL4;
                R1 = &TMP_PHASE6_GR1_R; A1 = &TMP_PHASE6_GR1_A; G1 = &TMP_PHASE6_GR1_G;
                R2 = &TMP_PHASE6_GR2_R; A2 = &TMP_PHASE6_GR2_A; G2 = &TMP_PHASE6_GR2_G;
                R3 = &TMP_PHASE6_GR3_R; A3 = &TMP_PHASE6_GR3_A; G3 = &TMP_PHASE6_GR3_G;
                R4 = &TMP_PHASE6_GR4_R; A4 = &TMP_PHASE6_GR4_A; G4 = &TMP_PHASE6_GR4_G;
                break;
        }

        int L_R[6] = {L_R1, L_R2, L_R3, L_R4, L_R5, L_R6};
        int L_A[6] = {L_A1, L_A2, L_A3, L_A4, L_A5, L_A6};
        int L_G[6] = {L_G1, L_G2, L_G3, L_G4, L_G5, L_G6};

        // Function to handle a single group's light transitions
        auto handleGroup = [&](int group, int &curLight, int *R, int *G, int *A) {
          lcd.setCursor(14, 0);
          lcd.print("P"+String(OP_CurPhase));

            if (curLight == 1) {
                digitalWrite(L_R[group-1], HIGH);
                Serial.println("R" + String(group) + ": " + String(*R) + " | CurLight: " + String(curLight));
                statusBuffer[group-1] = "R" + String(group) + ": " + String(*R);
                if (*R > 0) {
                    (*R)--;
                } else {
                    curLight = 3;
                }
            } else if (curLight == 3) {
                digitalWrite(L_R[group-1], LOW);  digitalWrite(L_G[group-1], HIGH); 
                Serial.println("G" + String(group) + ": " + String(*G) + " | CurLight: " + String(curLight));
                statusBuffer[group-1] = "G" + String(group) + ": " + String(*G);
                if (*G > 0) {
                    (*G)--;
                } else {
                    curLight = 2;
                }
            } else if (curLight == 2) {
                digitalWrite(L_G[group-1], LOW); digitalWrite(L_A[group-1], HIGH);
                Serial.println("A" + String(group) + ": " + String(*A) + " | CurLight: " + String(curLight));
                statusBuffer[group-1] = "A" + String(group) + ": " + String(*A);
                if (*A > 0) {
                    (*A)--;
                } else {
                    digitalWrite(L_A[group-1], LOW); digitalWrite(L_R[group-1], HIGH);
                    curLight = 0;
                }
            } 
            lcd.setCursor(0, 1);
            String displayString = "";
            for (int i = 0; i < 6; i++) {
                if (statusBuffer[i] != "") {
                    displayString += statusBuffer[i] + " ";
                }
            }
            lcd.print(displayString);
        };

        // Handle all groups simultaneously based on current phase
        bool allGroupsDone = true;
        if (GR1 != 0) {
            handleGroup(GR1, OP_CurLightGR1, R1, G1, A1);
            if (OP_CurLightGR1 != 0) allGroupsDone = false;
        }
        if (GR2 != 0) {
            handleGroup(GR2, OP_CurLightGR2, R2, G2, A2);
            if (OP_CurLightGR2 != 0) allGroupsDone = false;
        }
        if (GR3 != 0) {
            handleGroup(GR3, OP_CurLightGR3, R3, G3, A3);
            if (OP_CurLightGR3 != 0) allGroupsDone = false;
        }
        if (GR4 != 0) {
            handleGroup(GR4, OP_CurLightGR4, R4, G4, A4);
            if (OP_CurLightGR4 != 0) allGroupsDone = false;
        }

        // Check if all groups are done with their cycles
        if (allGroupsDone) {
            lcd.setCursor(0, 1);
            lcd.print("                "); // Clear the entire line
            OP_CurPhase++;
            if (OP_CurPhase > TMP_NoOfGroup) {
                OP_CurPhase = 1; // Loop back to the first phase
            }
            OP_CurLightGR1 = OP_CurLightGR2 = OP_CurLightGR3 = OP_CurLightGR4 = 1;
            loadEEPROMdata(); // Load new phase settings and timers
            clearStatusBuffer();
        }
        
        }  
    }
  } else {
    offallleds(); starter = true;
    for (int c = 0; c < cols; c++) {
    digitalWrite(colPins[c], LOW); // Set the current column low
    for (int r = 0; r < rows; r++) {
      if (digitalRead(rowPins[r]) == LOW) { // Check if the button in the current row is pressed
        Serial.print("Button pressed: ");
        Serial.print(buttonMap[r][c]); // Print the corresponding character
        Serial.print(" | ");
        Serial.print(Stg_Mode);
        Serial.print(" | ");
        Serial.println(TMP_NoOfGroup);
        BTNCOL = buttonMap[r][c];

        if (buttonMap[r][c] == 'A' && Stg_Mode == 0) {
          Stg_Mode = 1; lcd.clear();
        } else if (buttonMap[r][c] == 'B' && Stg_Mode == 0) {
          Stg_Mode = 3; CountGrSet(); lcd.clear();
        } else if (buttonMap[r][c] == 'C' && Stg_Mode == 0) {
          Stg_Mode = 4; lcd.clear();
        } else if (buttonMap[r][c] == 'D' && Stg_Mode == 0) {
          Stg_Mode = 5; lcd.clear();
        } else if (buttonMap[r][c] == '*' && Stg_Mode == 0) {
          Stg_Mode = 6; lcd.clear();
        } 

        if (buttonMap[r][c] == '*' && Stg_Mode == 1) {
          BTNCOL = '0'; 
        }

        if (buttonMap[r][c] >= '0' && buttonMap[r][c] <= '6' && Stg_Mode == 2) {
          if (Stg_Step <= 3){Stg_Step++;}else{Stg_Step = 1;}
        }

        if (buttonMap[r][c] >= '0' && buttonMap[r][c] <= '9' && Stg_Mode == 5) {
          if (Stg_Step < 7){Stg_Step++;}else{Stg_Step = 7;}
          if (Stg_Step == 1){accu_day += BTNCOL; Set_Day = accu_day.toInt();} else
          if (Stg_Step == 2 || Stg_Step == 3){accu_hour += BTNCOL; Set_Hour = accu_hour.toInt();} else
          if (Stg_Step == 4 || Stg_Step == 5){accu_min += BTNCOL; Set_Min = accu_min.toInt();} else
          if (Stg_Step == 6 || Stg_Step == 7){accu_sec += BTNCOL; Set_Sec = accu_sec.toInt();}
        }

        if (buttonMap[r][c] >= '0' && buttonMap[r][c] <= '6' && Stg_Mode == 6) {
          if (Stg_Step <= 5){Stg_Step++;}else{Stg_Step = 1;}
        }

        if (buttonMap[r][c] == '#' && Stg_Mode == 1 && TMP_NoOfGroup != 0) {
          Stg_Mode = 2; lcd.clear();
        } else if (buttonMap[r][c] == '#' && Stg_Mode == 2 && TMP_NoOfGroupStep >= TMP_NoOfGroup) {
          Stg_Step = 0; Stg_Mode = 0; Stg_Stage = 1; TMP_NoOfGroupStep = 1; lcd.clear(); 
          lcd.setCursor(0, 0);
          lcd.print("Saving to EEPROM");
          Serial.println("Setting Val: ");
          Serial.println("No Of Group: "+String(TMP_NoOfGroup));
          Serial.println(String(TMP_GR1_VAL1)+"-"+String(TMP_GR1_VAL2)+"-"+String(TMP_GR1_VAL3)+"-"+String(TMP_GR1_VAL4));
          Serial.println(String(TMP_GR2_VAL1)+"-"+String(TMP_GR2_VAL2)+"-"+String(TMP_GR2_VAL3)+"-"+String(TMP_GR2_VAL4));
          Serial.println(String(TMP_GR3_VAL1)+"-"+String(TMP_GR3_VAL2)+"-"+String(TMP_GR3_VAL3)+"-"+String(TMP_GR3_VAL4));
          Serial.println(String(TMP_GR4_VAL1)+"-"+String(TMP_GR4_VAL2)+"-"+String(TMP_GR4_VAL3)+"-"+String(TMP_GR4_VAL4));
          Serial.println(String(TMP_GR5_VAL1)+"-"+String(TMP_GR5_VAL2)+"-"+String(TMP_GR5_VAL3)+"-"+String(TMP_GR5_VAL4));
          Serial.println(String(TMP_GR6_VAL1)+"-"+String(TMP_GR6_VAL2)+"-"+String(TMP_GR6_VAL3)+"-"+String(TMP_GR6_VAL4));
          delay(2500); lcd.clear(); CountGrSet(); 
        } else if (buttonMap[r][c] == '#' && Stg_Mode == 6) {
          Stg_Step = 0; Stg_Mode = 0; Stg_Stage = 1; TMP_NoOfGroupStep = 1; lcd.clear(); 
          lcd.setCursor(0, 0);
          lcd.print("Saving to EEPROM");
          Serial.println("Setting Val: ");
          Serial.println(String(TMP_GRF_VAL1)+"-"+String(TMP_GRF_VAL2)+"-"+String(TMP_GRF_VAL3)+"-"+String(TMP_GRF_VAL4)+"-"+String(TMP_GRF_VAL5)+"-"+String(TMP_GRF_VAL6));
          delay(2500); lcd.clear();
        } else if (buttonMap[r][c] == '#' && Stg_Mode == 6 && TMP_NoOfGroupStep <= 6) {
          Stg_Step = 0; TMP_NoOfGroupStep++; Stg_Stage++; lcd.clear();
          Serial.println("Step: "+String(Stg_Step));
        } else if (buttonMap[r][c] == '#' && Stg_Mode == 2 && TMP_NoOfGroupStep <= TMP_NoOfGroup) {
          Stg_Step = 0; TMP_NoOfGroupStep++; Stg_Stage++; lcd.clear();
          Serial.println("Step: "+String(Stg_Step));
        } else if (buttonMap[r][c] == '#' && Stg_Mode == 3) {
          if (Stg_Stage == 1){
            if (TempGrSetPos < 3){TempGrSetPos++;} else{
                GrSetCountPS1--; if (GrSetCountPS1 != 0){TempGrSet++;}else{
                if (Stg_Stage < TMP_NoOfGroup){Stg_Stage++; TempGrSet = 1;}else{endofsetting = true;}}
                TempGrSetPos = 1;
            }
            accumulatedInput = "";
            Serial.println("Stage: "+String(Stg_Stage)+" | GrSetCountPS1: "+String(GrSetCountPS1));
          } else if (Stg_Stage == 2){
            if (TempGrSetPos < 3){TempGrSetPos++;} else{
                GrSetCountPS2--; if (GrSetCountPS2 != 0){TempGrSet++;}else{
                if (Stg_Stage < TMP_NoOfGroup){Stg_Stage++; TempGrSet = 1;}else{endofsetting = true;}}
                TempGrSetPos = 1;
            }
            accumulatedInput = "";
            Serial.println("Stage: "+String(Stg_Stage)+" | GrSetCountPS2: "+String(GrSetCountPS2));
          } else if (Stg_Stage == 3){
            if (TempGrSetPos < 3){TempGrSetPos++;} else{
                GrSetCountPS3--; if (GrSetCountPS3 != 0){TempGrSet++;}else{
                if (Stg_Stage < TMP_NoOfGroup){Stg_Stage++; TempGrSet = 1;}else{endofsetting = true;}}
                TempGrSetPos = 1;
            }
            accumulatedInput = "";
            Serial.println("Stage: "+String(Stg_Stage)+" | GrSetCountPS3: "+String(GrSetCountPS3));
          } else if (Stg_Stage == 4){
            if (TempGrSetPos < 3){TempGrSetPos++;} else{
                GrSetCountPS4--; if (GrSetCountPS4 != 0){TempGrSet++;}else{
                if (Stg_Stage < TMP_NoOfGroup){Stg_Stage++; TempGrSet = 1;}else{endofsetting = true;}}
                TempGrSetPos = 1;
            }
            accumulatedInput = "";
            Serial.println("Stage: "+String(Stg_Stage)+" | GrSetCountPS4: "+String(GrSetCountPS4));
          } else if (Stg_Stage == 5){
            if (TempGrSetPos < 3){TempGrSetPos++;} else{
                GrSetCountPS5--; if (GrSetCountPS5 != 0){TempGrSet++;}else{
                if (Stg_Stage < TMP_NoOfGroup){Stg_Stage++; TempGrSet = 1;}else{endofsetting = true;}}
                TempGrSetPos = 1;
            }
            accumulatedInput = "";
            Serial.println("Stage: "+String(Stg_Stage)+" | GrSetCountPS5: "+String(GrSetCountPS5));
          } else if (Stg_Stage == 6){
            if (TempGrSetPos < 3){TempGrSetPos++;} else{
                GrSetCountPS6--; if (GrSetCountPS6 != 0){TempGrSet++;}else{
                if (Stg_Stage < TMP_NoOfGroup){Stg_Stage++; TempGrSet = 1;}else{endofsetting = true;}}
                TempGrSetPos = 1;
            }
            accumulatedInput = "";
            Serial.println("Stage: "+String(Stg_Stage)+" | GrSetCountPS6: "+String(GrSetCountPS6));
          } 


          if (endofsetting == true){
            TempGrSet = 1; Stg_Step = 0; Stg_Mode = 0; Stg_Stage = 1; lcd.clear(); accumulatedInput = "";
            lcd.setCursor(0, 0);
            lcd.print("Saving to EEPROM");
            delay(2500); lcd.clear(); endofsetting = false;
          } 
          
        } else if (buttonMap[r][c] == '#' && Stg_Mode == 4 && Stg_Step == 8) {
          Stg_Mode = 0; Stg_Step = 0; lcd.clear();
          lcd.print("Saving to EEPROM");
          //Time t(2024, 7, 11, Set_Hour, Set_Min, Set_Sec, daySelection(Set_Day));
          //rtc.time(t);
          Set_Hour = 0; Set_Min = 0; Set_Sec = 0; Set_Day = 0;
          delay(2500); lcd.clear();
        } else if (buttonMap[r][c] == '#' && Stg_Mode == 5 && Stg_Step == 7) {
          Stg_Mode = 0; Stg_Step = 0; lcd.clear();
          lcd.print("Saving to RTC...");
          //Time t(2024, 7, 11, Set_Hour, Set_Min, Set_Sec, daySelection(Set_Day));
          //rtc.time(t);
          Set_Hour = 0; Set_Min = 0; Set_Sec = 0; Set_Day = 0;
          delay(2500); lcd.clear();
        } 

        if (Stg_Mode == 1 && BTNCOL >= '0' && BTNCOL <= '6'){ TMP_NoOfGroup = numberbtnpress(BTNCOL); if (TMP_NoOfGroup >= 7){TMP_NoOfGroup = 6;}} else
        if (Stg_Mode == 2){ 
          if (numberbtnpress(BTNCOL) >= 6){BTNCOL = '6';}
          if (Stg_Stage == 1 && Stg_Step == 1){TMP_GR1_VAL1 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 1 && Stg_Step == 2){TMP_GR1_VAL2 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 1 && Stg_Step == 3){TMP_GR1_VAL3 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 1 && Stg_Step == 4){TMP_GR1_VAL4 = numberbtnpress(BTNCOL);} else

          if (Stg_Stage == 2 && Stg_Step == 1){TMP_GR2_VAL1 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 2 && Stg_Step == 2){TMP_GR2_VAL2 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 2 && Stg_Step == 3){TMP_GR2_VAL3 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 2 && Stg_Step == 4){TMP_GR2_VAL4 = numberbtnpress(BTNCOL);} else

          if (Stg_Stage == 3 && Stg_Step == 1){TMP_GR3_VAL1 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 3 && Stg_Step == 2){TMP_GR3_VAL2 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 3 && Stg_Step == 3){TMP_GR3_VAL3 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 3 && Stg_Step == 4){TMP_GR3_VAL4 = numberbtnpress(BTNCOL);} else

          if (Stg_Stage == 4 && Stg_Step == 1){TMP_GR4_VAL1 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 4 && Stg_Step == 2){TMP_GR4_VAL2 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 4 && Stg_Step == 3){TMP_GR4_VAL3 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 4 && Stg_Step == 4){TMP_GR4_VAL4 = numberbtnpress(BTNCOL);} else

          if (Stg_Stage == 5 && Stg_Step == 1){TMP_GR5_VAL1 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 5 && Stg_Step == 2){TMP_GR5_VAL2 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 5 && Stg_Step == 3){TMP_GR5_VAL3 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 5 && Stg_Step == 4){TMP_GR5_VAL4 = numberbtnpress(BTNCOL);} else

          if (Stg_Stage == 6 && Stg_Step == 1){TMP_GR6_VAL1 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 6 && Stg_Step == 2){TMP_GR6_VAL2 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 6 && Stg_Step == 3){TMP_GR6_VAL3 = numberbtnpress(BTNCOL);} else
          if (Stg_Stage == 6 && Stg_Step == 4){TMP_GR6_VAL4 = numberbtnpress(BTNCOL);}
          Serial.println("Step: "+String(Stg_Step));
        }

        if (Stg_Mode == 6){ 
          if (numberbtnpress(BTNCOL) >= 6){BTNCOL = '6';}
          if (Stg_Step == 1){TMP_GRF_VAL1 = numberbtnpress(BTNCOL);} else
          if (Stg_Step == 2){TMP_GRF_VAL2 = numberbtnpress(BTNCOL);} else
          if (Stg_Step == 3){TMP_GRF_VAL3 = numberbtnpress(BTNCOL);} else
          if (Stg_Step == 4){TMP_GRF_VAL4 = numberbtnpress(BTNCOL);} else
          if (Stg_Step == 5){TMP_GRF_VAL5 = numberbtnpress(BTNCOL);} else
          if (Stg_Step == 6){TMP_GRF_VAL6 = numberbtnpress(BTNCOL);}
        }
        if (Stg_Mode == 3 && BTNCOL >= '0' && BTNCOL <= '9'){
          if (Stg_Stage == 1){
            accumulatedInput += BTNCOL;
            if (TempGrSet == 1){
              if (TempGrSetPos == 1){TMP_PHASE1_GR1_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE1_GR1_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE1_GR1_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 2){
              if (TempGrSetPos == 1){TMP_PHASE1_GR2_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE1_GR2_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE1_GR2_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 3){
              if (TempGrSetPos == 1){TMP_PHASE1_GR3_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE1_GR3_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE1_GR3_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 4){
              if (TempGrSetPos == 1){TMP_PHASE1_GR4_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE1_GR4_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE1_GR4_G = accumulatedInput.toInt();} 
            } 
          } else if (Stg_Stage == 2){
            accumulatedInput += BTNCOL;
            if (TempGrSet == 1){
              if (TempGrSetPos == 1){TMP_PHASE2_GR1_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE2_GR1_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE2_GR1_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 2){
              if (TempGrSetPos == 1){TMP_PHASE2_GR2_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE2_GR2_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE2_GR2_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 3){
              if (TempGrSetPos == 1){TMP_PHASE2_GR3_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE2_GR3_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE2_GR3_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 4){
              if (TempGrSetPos == 1){TMP_PHASE2_GR4_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE2_GR4_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE2_GR4_G = accumulatedInput.toInt();} 
            } 
          } else if (Stg_Stage == 3){
            accumulatedInput += BTNCOL;
            if (TempGrSet == 1){
              if (TempGrSetPos == 1){TMP_PHASE3_GR1_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE3_GR1_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE3_GR1_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 2){
              if (TempGrSetPos == 1){TMP_PHASE3_GR2_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE3_GR2_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE3_GR2_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 3){
              if (TempGrSetPos == 1){TMP_PHASE3_GR3_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE3_GR3_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE3_GR3_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 4){
              if (TempGrSetPos == 1){TMP_PHASE3_GR4_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE3_GR4_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE3_GR4_G = accumulatedInput.toInt();} 
            } 
          } else if (Stg_Stage == 4){
            accumulatedInput += BTNCOL;
            if (TempGrSet == 1){
              if (TempGrSetPos == 1){TMP_PHASE4_GR1_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE4_GR1_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE4_GR1_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 2){
              if (TempGrSetPos == 1){TMP_PHASE4_GR2_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE4_GR2_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE4_GR2_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 3){
              if (TempGrSetPos == 1){TMP_PHASE4_GR3_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE4_GR3_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE4_GR3_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 4){
              if (TempGrSetPos == 1){TMP_PHASE4_GR4_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE4_GR4_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE4_GR4_G = accumulatedInput.toInt();} 
            } 
          } else if (Stg_Stage == 5){
            accumulatedInput += BTNCOL;
            if (TempGrSet == 1){
              if (TempGrSetPos == 1){TMP_PHASE5_GR1_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE5_GR1_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE5_GR1_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 2){
              if (TempGrSetPos == 1){TMP_PHASE5_GR2_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE5_GR2_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE5_GR2_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 3){
              if (TempGrSetPos == 1){TMP_PHASE5_GR3_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE5_GR3_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE5_GR3_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 4){
              if (TempGrSetPos == 1){TMP_PHASE5_GR4_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE5_GR4_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE5_GR4_G = accumulatedInput.toInt();} 
            } 
          } else if (Stg_Stage == 6){
            accumulatedInput += BTNCOL;
            if (TempGrSet == 1){
              if (TempGrSetPos == 1){TMP_PHASE6_GR1_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE6_GR1_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE6_GR1_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 2){
              if (TempGrSetPos == 1){TMP_PHASE6_GR2_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE6_GR2_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE6_GR2_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 3){
              if (TempGrSetPos == 1){TMP_PHASE6_GR3_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE6_GR3_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE6_GR3_G = accumulatedInput.toInt();} 
            } else if (TempGrSet == 4){
              if (TempGrSetPos == 1){TMP_PHASE6_GR4_R = accumulatedInput.toInt();} else
              if (TempGrSetPos == 2){TMP_PHASE6_GR4_A = accumulatedInput.toInt();} else
              if (TempGrSetPos == 3){TMP_PHASE6_GR4_G = accumulatedInput.toInt();} 
            } 
          } 
          } 
        
        delay(200); // Debounce delay
      }
    }
    digitalWrite(colPins[c], HIGH); // Set the current column back to high
  }

    if (Stg_Mode == 0){
      lcd.setCursor(0, 0);
      lcd.print("SETTINGS MODE   "); //Phase name
      
      lcd.setCursor(0, 1);
      lcd.print("A.B.C.D.*       ");

      } else if (Stg_Mode == 1){ //SETTING 1: Number of Group
        lcd.setCursor(0, 0);
        lcd.print("SIGNAL PHASE    "); //Phase name

        if (TMP_NoOfGroup != 0){
          lcd.setCursor(0, 1);
          lcd.print("PHASE QTY = ");
          lcd.setCursor(12, 1);
          lcd.print(TMP_NoOfGroup+String("       "));
        } else {
          lcd.setCursor(0, 1);
          lcd.print("PHASE QTY = -      ");
        }
        
      } else if (Stg_Mode == 2){ //SETTING 2: Set PHASE
        if (TMP_NoOfGroupStep == 1){
          lcd.setCursor(0, 0);
          lcd.print("PHASE 1         ");
          lcd.setCursor(0, 1);
          lcd.print(TMP_GR1_VAL1);
          lcd.print("-");
          lcd.print(TMP_GR1_VAL2);
          lcd.print("-");
          lcd.print(TMP_GR1_VAL3);
          lcd.print("-");
          lcd.print(TMP_GR1_VAL4);
          lcd.print("            ");
          } else if (TMP_NoOfGroupStep == 2){
          lcd.setCursor(0, 0);
          lcd.print("PHASE 2         ");
          lcd.setCursor(0, 1);
          lcd.print(TMP_GR2_VAL1);
          lcd.print("-");
          lcd.print(TMP_GR2_VAL2);
          lcd.print("-");
          lcd.print(TMP_GR2_VAL3);
          lcd.print("-");
          lcd.print(TMP_GR2_VAL4);
          lcd.print("            ");
          } else if (TMP_NoOfGroupStep == 3){
          lcd.setCursor(0, 0);
          lcd.print("PHASE 3         ");
          lcd.setCursor(0, 1);
          lcd.print(TMP_GR3_VAL1);
          lcd.print("-");
          lcd.print(TMP_GR3_VAL2);
          lcd.print("-");
          lcd.print(TMP_GR3_VAL3);
          lcd.print("-");
          lcd.print(TMP_GR3_VAL4);
          lcd.print("            ");
          } else if (TMP_NoOfGroupStep == 4){
          lcd.setCursor(0, 0);
          lcd.print("PHASE 4         ");
          lcd.setCursor(0, 1);
          lcd.print(TMP_GR4_VAL1);
          lcd.print("-");
          lcd.print(TMP_GR4_VAL2);
          lcd.print("-");
          lcd.print(TMP_GR4_VAL3);
          lcd.print("-");
          lcd.print(TMP_GR4_VAL4);
          lcd.print("            ");
          } else if (TMP_NoOfGroupStep == 5){
          lcd.setCursor(0, 0);
          lcd.print("PHASE 5         ");
          lcd.setCursor(0, 1);
          lcd.print(TMP_GR5_VAL1);
          lcd.print("-");
          lcd.print(TMP_GR5_VAL2);
          lcd.print("-");
          lcd.print(TMP_GR5_VAL3);
          lcd.print("-");
          lcd.print(TMP_GR5_VAL4);
          lcd.print("            ");
          } else if (TMP_NoOfGroupStep == 6){
          lcd.setCursor(0, 0);
          lcd.print("PHASE 6         ");
          lcd.setCursor(0, 1);
          lcd.print(TMP_GR6_VAL1);
          lcd.print("-");
          lcd.print(TMP_GR6_VAL2);
          lcd.print("-");
          lcd.print(TMP_GR6_VAL3);
          lcd.print("-");
          lcd.print(TMP_GR6_VAL4);
          lcd.print("            ");
          }
          
      } else if (Stg_Mode == 3){ //SETTING 3: Duration Setting
        if (Stg_Stage == 1){
          lcd.setCursor(0, 0);
          lcd.print("PHASE 1 | GRUP "+String(TempGrSet)); //Phase name
          lcd.setCursor(0, 1);
          if (TempGrSet == 1){
            if (TMP_PHASE1_GR1_R == 0 && TMP_PHASE1_GR1_A == 0 && TMP_PHASE1_GR1_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE1_GR1_R)+" A:"+String(TMP_PHASE1_GR1_A)+" G:"+String(TMP_PHASE1_GR1_G)+String("      "));}
          } else if (TempGrSet == 2){
            if (TMP_PHASE1_GR2_R == 0 && TMP_PHASE1_GR2_A == 0 && TMP_PHASE1_GR2_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE1_GR2_R)+" A:"+String(TMP_PHASE1_GR2_A)+" G:"+String(TMP_PHASE1_GR2_G)+String("      "));}
          } else if (TempGrSet == 3){
            if (TMP_PHASE1_GR3_R == 0 && TMP_PHASE1_GR3_A == 0 && TMP_PHASE1_GR3_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE1_GR3_R)+" A:"+String(TMP_PHASE1_GR3_A)+" G:"+String(TMP_PHASE1_GR3_G)+String("      "));}
          } else if (TempGrSet == 4){
            if (TMP_PHASE1_GR4_R == 0 && TMP_PHASE1_GR4_A == 0 && TMP_PHASE1_GR4_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE1_GR4_R)+" A:"+String(TMP_PHASE1_GR4_A)+" G:"+String(TMP_PHASE1_GR4_G)+String("      "));}
          }
        } else if (Stg_Stage == 2){
          lcd.setCursor(0, 0);
          lcd.print("PHASE 2 | GRUP "+String(TempGrSet)); //Phase name
          lcd.setCursor(0, 1);
          if (TempGrSet == 1){
            if (TMP_PHASE2_GR1_R == 0 && TMP_PHASE2_GR1_A == 0 && TMP_PHASE2_GR1_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE2_GR1_R)+" A:"+String(TMP_PHASE2_GR1_A)+" G:"+String(TMP_PHASE2_GR1_G)+String("      "));}
          } else if (TempGrSet == 2){
            if (TMP_PHASE2_GR2_R == 0 && TMP_PHASE2_GR2_A == 0 && TMP_PHASE2_GR2_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE2_GR2_R)+" A:"+String(TMP_PHASE2_GR2_A)+" G:"+String(TMP_PHASE2_GR2_G)+String("      "));}
          } else if (TempGrSet == 3){
            if (TMP_PHASE2_GR3_R == 0 && TMP_PHASE2_GR3_A == 0 && TMP_PHASE2_GR3_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE2_GR3_R)+" A:"+String(TMP_PHASE2_GR3_A)+" G:"+String(TMP_PHASE2_GR3_G)+String("      "));}
          } else if (TempGrSet == 4){
            if (TMP_PHASE2_GR4_R == 0 && TMP_PHASE2_GR4_A == 0 && TMP_PHASE2_GR4_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE2_GR4_R)+" A:"+String(TMP_PHASE2_GR4_A)+" G:"+String(TMP_PHASE2_GR4_G)+String("      "));}
          }
        } else if (Stg_Stage == 3){
          lcd.setCursor(0, 0);
          lcd.print("PHASE 3 | GRUP "+String(TempGrSet)); //Phase name
          lcd.setCursor(0, 1);
          if (TempGrSet == 1){
            if (TMP_PHASE3_GR1_R == 0 && TMP_PHASE3_GR1_A == 0 && TMP_PHASE3_GR1_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE3_GR1_R)+" A:"+String(TMP_PHASE3_GR1_A)+" G:"+String(TMP_PHASE3_GR1_G)+String("      "));}
          } else if (TempGrSet == 2){
            if (TMP_PHASE3_GR2_R == 0 && TMP_PHASE3_GR2_A == 0 && TMP_PHASE3_GR2_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE3_GR2_R)+" A:"+String(TMP_PHASE3_GR2_A)+" G:"+String(TMP_PHASE3_GR2_G)+String("      "));}
          } else if (TempGrSet == 3){
            if (TMP_PHASE3_GR3_R == 0 && TMP_PHASE3_GR3_A == 0 && TMP_PHASE3_GR3_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE3_GR3_R)+" A:"+String(TMP_PHASE3_GR3_A)+" G:"+String(TMP_PHASE3_GR3_G)+String("      "));}
          } else if (TempGrSet == 4){
            if (TMP_PHASE3_GR4_R == 0 && TMP_PHASE3_GR4_A == 0 && TMP_PHASE3_GR4_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE3_GR4_R)+" A:"+String(TMP_PHASE3_GR4_A)+" G:"+String(TMP_PHASE3_GR4_G)+String("      "));}
          }
        } else if (Stg_Stage == 4){
          lcd.setCursor(0, 0);
          lcd.print("PHASE 4 | GRUP "+String(TempGrSet)); //Phase name
          lcd.setCursor(0, 1);
          if (TempGrSet == 1){
            if (TMP_PHASE4_GR1_R == 0 && TMP_PHASE4_GR1_A == 0 && TMP_PHASE4_GR1_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE4_GR1_R)+" A:"+String(TMP_PHASE4_GR1_A)+" G:"+String(TMP_PHASE4_GR1_G)+String("      "));}
          } else if (TempGrSet == 2){
            if (TMP_PHASE4_GR2_R == 0 && TMP_PHASE4_GR2_A == 0 && TMP_PHASE4_GR2_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE4_GR2_R)+" A:"+String(TMP_PHASE4_GR2_A)+" G:"+String(TMP_PHASE4_GR2_G)+String("      "));}
          } else if (TempGrSet == 3){
            if (TMP_PHASE4_GR3_R == 0 && TMP_PHASE4_GR3_A == 0 && TMP_PHASE4_GR3_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE4_GR3_R)+" A:"+String(TMP_PHASE4_GR3_A)+" G:"+String(TMP_PHASE4_GR3_G)+String("      "));}
          } else if (TempGrSet == 4){
            if (TMP_PHASE4_GR4_R == 0 && TMP_PHASE4_GR4_A == 0 && TMP_PHASE4_GR4_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE4_GR4_R)+" A:"+String(TMP_PHASE4_GR4_A)+" G:"+String(TMP_PHASE4_GR4_G)+String("      "));}
          }
        } else if (Stg_Stage == 5){
          lcd.setCursor(0, 0);
          lcd.print("PHASE 5 | GRUP "+String(TempGrSet)); //Phase name
          lcd.setCursor(0, 1);
          if (TempGrSet == 1){
            if (TMP_PHASE5_GR1_R == 0 && TMP_PHASE5_GR1_A == 0 && TMP_PHASE5_GR1_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE5_GR1_R)+" A:"+String(TMP_PHASE5_GR1_A)+" G:"+String(TMP_PHASE5_GR1_G)+String("      "));}
          } else if (TempGrSet == 2){
            if (TMP_PHASE5_GR2_R == 0 && TMP_PHASE5_GR2_A == 0 && TMP_PHASE5_GR2_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE5_GR2_R)+" A:"+String(TMP_PHASE5_GR2_A)+" G:"+String(TMP_PHASE5_GR2_G)+String("      "));}
          } else if (TempGrSet == 3){
            if (TMP_PHASE5_GR3_R == 0 && TMP_PHASE5_GR3_A == 0 && TMP_PHASE5_GR3_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE5_GR3_R)+" A:"+String(TMP_PHASE5_GR3_A)+" G:"+String(TMP_PHASE5_GR3_G)+String("      "));}
          } else if (TempGrSet == 4){
            if (TMP_PHASE5_GR4_R == 0 && TMP_PHASE5_GR4_A == 0 && TMP_PHASE5_GR4_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE5_GR4_R)+" A:"+String(TMP_PHASE5_GR4_A)+" G:"+String(TMP_PHASE5_GR4_G)+String("      "));}
          }
        } else if (Stg_Stage == 6){
          lcd.setCursor(0, 0);
          lcd.print("PHASE 6 | GRUP "+String(TempGrSet)); //Phase name
          lcd.setCursor(0, 1);
          if (TempGrSet == 1){
            if (TMP_PHASE6_GR1_R == 0 && TMP_PHASE6_GR1_A == 0 && TMP_PHASE6_GR1_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE6_GR1_R)+" A:"+String(TMP_PHASE6_GR1_A)+" G:"+String(TMP_PHASE6_GR1_G)+String("      "));}
          } else if (TempGrSet == 2){
            if (TMP_PHASE6_GR2_R == 0 && TMP_PHASE6_GR2_A == 0 && TMP_PHASE6_GR2_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE6_GR2_R)+" A:"+String(TMP_PHASE6_GR2_A)+" G:"+String(TMP_PHASE6_GR2_G)+String("      "));}
          } else if (TempGrSet == 3){
            if (TMP_PHASE6_GR3_R == 0 && TMP_PHASE6_GR3_A == 0 && TMP_PHASE6_GR3_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE6_GR3_R)+" A:"+String(TMP_PHASE6_GR3_A)+" G:"+String(TMP_PHASE6_GR3_G)+String("      "));}
          } else if (TempGrSet == 4){
            if (TMP_PHASE6_GR4_R == 0 && TMP_PHASE6_GR4_A == 0 && TMP_PHASE6_GR4_G == 0){lcd.print("R:--- A:-- G:---");} else
            {lcd.print("R:"+String(TMP_PHASE6_GR4_R)+" A:"+String(TMP_PHASE6_GR4_A)+" G:"+String(TMP_PHASE6_GR4_G)+String("      "));}
          }
        } 
        
      }  else if (Stg_Mode == 4){ //SETTING 4: Schedule setting
        lcd.setCursor(0, 0);
        lcd.print("SET SCHEDULE    "); //Phase name

        if (TMP_NoOfGroup != 0){
          lcd.setCursor(0, 1);
          lcd.print("PHASE QTY = ");
          lcd.setCursor(12, 1);
          lcd.print(TMP_NoOfGroup+String("       "));
        } else {
          lcd.setCursor(0, 1);
          lcd.print("PHASE QTY = -      ");
        }
        
      } else if (Stg_Mode == 5){ //SETTING 5: Today datetime setting
        lcd.setCursor(0, 0);
        lcd.print("SET DATETIME    "); //Phase name
        
        lcd.setCursor(0, 1);
        if (Set_Day == 0){lcd.print("DAY - | --:--:--");}else{
          char buffer[6];
          sprintf(buffer, "%02d:%02d:%02d", Set_Hour, Set_Min, Set_Sec);
          String Time = String(buffer);
          lcd.print("DAY "+String(Set_Day)+" | "+String(Time)+"     ");
        }
        
        
      } else if (Stg_Mode == 6){ //SETTING 6: Set flashing state
        if (TMP_NoOfGroupStep == 1){
          lcd.setCursor(0, 0);
          lcd.print("FLASHING GROUP  ");
          lcd.setCursor(0, 1);
          lcd.print(TMP_GRF_VAL1);
          lcd.print("-");
          lcd.print(TMP_GRF_VAL2);
          lcd.print("-");
          lcd.print(TMP_GRF_VAL3);
          lcd.print("-");
          lcd.print(TMP_GRF_VAL4);
          lcd.print("-");
          lcd.print(TMP_GRF_VAL5);
          lcd.print("-");
          lcd.print(TMP_GRF_VAL6);
          lcd.print("            ");
          } 

        }
       }
      }

void offallleds(){
  digitalWrite(L_R1, LOW); digitalWrite(L_R2, LOW); digitalWrite(L_R3, LOW);
  digitalWrite(L_R4, LOW); digitalWrite(L_R5, LOW); digitalWrite(L_R6, LOW);

  digitalWrite(L_A1, LOW); digitalWrite(L_A2, LOW); digitalWrite(L_A3, LOW);
  digitalWrite(L_A4, LOW); digitalWrite(L_A5, LOW); digitalWrite(L_A6, LOW);

  digitalWrite(L_G1, LOW); digitalWrite(L_G2, LOW); digitalWrite(L_G3, LOW);
  digitalWrite(L_G4, LOW); digitalWrite(L_G5, LOW); digitalWrite(L_G6, LOW);
}

int numberbtnpress(char button) {
  if (button >= '0' && button <= '9') {
    return button - '0'; // Convert numeric characters directly
  } else {
    /*switch(button) {
      case 'A': return 10;
      case 'B': return 11;
      case 'C': return 12;
      case 'D': return 13;
      case '*': return 14;
      case '#': return 15;
      default: return -1; */// Return an invalid group number for unknown buttons
    }
  }