//Vanica 
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
#include <EEPROM.h>
#include <Bounce2.h> // Biblioteca pentru debouncing

// Configurarea LCD
#define I2C_ADDR    0x27
#define LCD_COLUMNS 16
#define LCD_LINES   2
LiquidCrystal_I2C lcd(I2C_ADDR, LCD_COLUMNS, LCD_LINES);

// Definirea pinilor butoanelor
const int buttonPins[] = {14, 15, 16, 17}; // Up, Down, OK, Back
Bounce buttons[4]; // Obiecte Bounce pentru fiecare buton

// Variabile pentru debounce CLAPAN_SIGNAL
bool lastClapanSignalState = LOW; // Starea anterioară a semnalului
bool clapanSignalState = LOW; // Starea curentă a semnalului
unsigned long clapanLastDebounceTime = 0; // Ultima actualizare a semnalului
unsigned long clapanDebounceDelay = 20; // Timpul de debounce în milisecunde

int currentStep = 0; // Etapa curentă a procesului
bool restartFromStep = false; // Flag pentru reluarea dintr-un punct specific

// Variabilă pentru a urmări starea de eroare a senzorilor
//bool sensorErrorDisplayed = false;

// Variabilă globală pentru a controla afișarea mesajului
bool isRowWeldingDisplayed = false; // Inițial, mesajul nu este afișat

// Definire pinuri
const int PistonPodem = 2;             // Ieșire pentru podem
const int PistonProteag = 3;           // Ieșire pentru proteag
const int PistonBlokator = 4;        // Ieșire pentru blokerator
const int PistonBunker = 5;            // Ieșire pentru bunker
const int PEDALA_RCS_PIN = 18;     // Ieșire pentru pedala RCS RELE
const int SENSOR_DREAPTA =  22;      // Intrare pentru senzor dreapta (verifică contactul pe partea dreaptă)
const int SENSOR_STANGA   = 23;    // Intrare pentru senzor stânga (verifică contactul pe partea stângă)
const int SENSOR_PROTEAG  = 24;     // Intrare pentru senzorul proteagului (verifică dacă proteagul a ajuns la capăt)
const int CLAPAN_SIGNAL   = 19;     // Intrare pentru semnalul de la RCS (indică finalizarea operațiilor RCS)
const int START_BUTTON    = 25;      // Butonul de start - intrare
const int BUTTON_PAUSE = 26;          // BUTON PAUSE
      // Definirea pinilor pistoanelor
      
const int pistonPins[8] = {6, 7, 8, 9, 10, 11, 12, 13}; // Definirea pinilor pentru pistoane

// Variabile pentru navigare și gestionarea meniurilor
int currentMenu = 0;
const int totalMenus = 8; // Am adaugat un meniu pentru GRUPE
String menus[totalMenus] = {
  "TACT",
  "RINDURI",
  "TIMP PROTEAG",
  "TIMP BLOKATOR",
  "TIMP BUNKER",
  "CILINDRI",
  "DATE",
  "PISTOANE"
};

// Variabile pentru valorile din submeniuri
int values[5] = {1, 1, 1, 1, 1}; // TACT, RINDURI, TIMP PROTEAG, TIMP BLOKATOR
const int minValues[] = {1, 1, 1, 1, 1};
const int maxValues[] = {8, 99, 2500, 2000, 1000};
const int steps[] = {1, 1, 50, 10, 10};

// Variabile pentru gestionarea pistonilor și grupurilor 
int pistonState [] = {-1, -1, -1, -1, -1, -1, -1, -1};  // Starea pistonilor
int currentPiston = 0;

int rinduriCounter = 0;
int plasaCounter = 0;

// Variabila pentru timpul de start
unsigned long startTime = millis();
bool senzorActivat = false;

bool manual = false;
bool pistonEditing = false; // Mod de editare a pistonului
bool isEditing = false; // Mod de editare a valorilor (TACT, RINDURI, etc.)
bool inWorkState = false;

unsigned long okButtonPressTime = 0; // Timpul când butonul OK este apăsat
const unsigned long longPressThreshold = 500; // Prag pentru apăsare lungă (1 secundă)

void setup() {

    // Configurare pinuri
 pinMode(SENSOR_DREAPTA, INPUT);      // Senzor dreapta configurat ca intrare
 pinMode(SENSOR_STANGA, INPUT);       // Senzor stânga configurat ca intrare
 pinMode(SENSOR_PROTEAG, INPUT);      // Senzor proteag configurat ca intrare
 pinMode(CLAPAN_SIGNAL, INPUT);       // Semnal RCS configurat ca intrare
 pinMode(START_BUTTON, INPUT);        // Buton START configurat ca intrare cu rezistență internă pull-up
 pinMode(BUTTON_PAUSE, INPUT);        // Buton PAUSE
  // Configurarea pinilor pentru pistoane
  for (int i = 0; i < 8; i++) {
    pinMode(pistonPins[i], OUTPUT);  // Setează fiecare pin din array ca ieșire
  }

 pinMode(PistonPodem, OUTPUT);    // Podem configurat ca ieșire
 pinMode(PistonProteag, OUTPUT);  // Proteag configurat ca ieșire
 pinMode(PistonBlokator, OUTPUT); // Blokerator configurat ca ieșire
 pinMode(PistonBunker, OUTPUT);   // Bunker configurat ca ieșire

 pinMode(PEDALA_RCS_PIN, OUTPUT); // RELE Pedala RCS configurată ca ieșire
 
 
  // Configurarea pinilor butoanelor
  for (int i = 0; i < 4; i++) {
    pinMode(buttonPins[i], INPUT_PULLUP);
    buttons[i].attach(buttonPins[i]);
    buttons[i].interval(25);
  }

  // Inițializarea LCD-ului
  lcd.begin(LCD_COLUMNS, LCD_LINES);
  lcd.backlight();


// Citirea valorilor din EEPROM
  values[0] = EEPROM.read(0);  // TACT
  values[1] = EEPROM.read(1); //RINDURI
  values[2] = EEPROM.read(2) * 10; //TIMP PROTEAG
  values[3] = EEPROM.read(3) * 10; //TIMP BLOKATOR
  values[4] = EEPROM.read(4) * 10; //TIMP BUNKER
  Serial.begin(9600); // Setează viteza de transmisie a datelor pe serial
  
  for (int i = 0; i < 8; i++) {
    pistonState[i] = EEPROM.read(5 + i);
    if (pistonState[i] == 255) {
      pistonState[i] = -1;
    }
    Serial.print("PISTON ");
    Serial.print(i + 1);
    Serial.print(" in grupa: ");
    Serial.println(pistonState[i]);
  }

  // Mesaj de salut
  lcd.setCursor(0, 0);
  lcd.print("     ARMESH  ");
  lcd.setCursor(0, 1);
  lcd.print("     VER-2   ");
  delay(1000);

      showMenu();
}

bool readClapanSignal() {
  bool currentReading = digitalRead(CLAPAN_SIGNAL); // Citește semnalul de la pinul CLAPAN_SIGNAL
  

  // Verifică dacă starea s-a schimbat
  if (currentReading != lastClapanSignalState) {
    clapanLastDebounceTime = millis(); // Resetează timpul de debounce
    
  }

  // Dacă a trecut timpul de debounce
  if ((millis() - clapanLastDebounceTime) > clapanDebounceDelay) {
    if (currentReading != clapanSignalState) {
      clapanSignalState = currentReading; // Actualizează starea semnalului
      
    }
  }

  lastClapanSignalState = currentReading; // Actualizează ultima stare citită
  return clapanSignalState; // Returnează starea actuală a semnalului
}


void loop() {

  if (manual == true) {
    // isEditing = false;
    //  pistonEditing = false;
    menuPistoane();
  
  } else if (inWorkState == true) {
    working();
  } else {
    readButtons();
  }

}

void working() {
  if (plasaCounter <=0) { // PRIMA PORNIRE
    digitalWrite(PistonPodem, HIGH);
  }

  // Citirea stării butonului
  int buttonState = digitalRead(START_BUTTON);

  // Verificarea dacă butonul a fost apăsat (stare HIGH)
  if (buttonState == HIGH) {

    while(rinduriCounter < values[1]) {
      startRindPlasaCycle();
    }
    // Gestionarea PLASELOR
    
    plasaCounter++;
    rinduriCounter = 0;
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("PLASE FABRICATE ");
    lcd.setCursor(7, 1);
    lcd.print(plasaCounter);
    delay(100);
  }
}

// Citirea și gestionarea butoanelor
void readButtons() {
  for (int i = 0; i < 4; i++) {
    buttons[i].update();
  }
  // Buton OK
  if (buttons[2].fell()) {
    okButtonPressTime = millis(); // Înregistrăm momentul apăsării
  }
  if (buttons[2].rose()) {
    unsigned long pressDuration = millis() - okButtonPressTime; 
    if (pressDuration > longPressThreshold) {   // Apăsare lungă
        if (pistonEditing) {
            savePistonState(); // Salvează starea pistonului în EEPROM
        }
    } else if (pistonEditing) {
       togglePistonState(); // Apăsare scurtă - comută starea pistonului
    } 
    else if (isEditing) {
      saveSetting(); // Salvează setările (TACT, RINDURI, etc.)
    } 
    else if (currentMenu == 7) {
      manual = true;
      currentMenu = 0;
      return; // daca meniul selectat este 7 atunci setam flagul manual si iesim din meniul de configurari
    }
    else selectMenu();
  }

  // Butoane Up, Down și Back
  if (buttons[0].fell()) navigateMenu(-1);  // Butonul Up
  if (buttons[1].fell()) navigateMenu(1);  // Down
  if (buttons[3].fell()) {
    okButtonPressTime = millis(); // Înregistrăm momentul apăsării
  }
  if (buttons[3].rose()) {
    unsigned long pressDuration = millis() - okButtonPressTime;
    if (pressDuration > longPressThreshold) {   // Apăsare lungă
        if (pistonEditing) {
            showMenu1();// ne arata tabela
        }
    } else
    backMenu();       // Back
  }
}

// Navigare în meniu sau între valori
void navigateMenu(int direction) {
    if (pistonEditing) {
    currentPiston = (currentPiston + direction + 8) % 8; // Navigare între pistoane
  } else if (isEditing) {
    int &value = values[currentMenu];
    value += direction * steps[currentMenu];
    if (value > maxValues[currentMenu]) value = minValues[currentMenu];
    if (value < minValues[currentMenu]) value = maxValues[currentMenu];
  } else {
    currentMenu = (currentMenu + direction + totalMenus) % totalMenus;
  }
  showMenu();
}

// Comutare stare piston
void togglePistonState() {
  if (pistonState[currentPiston] >= 7) {
    pistonState[currentPiston] = -1;
  } else {
    pistonState[currentPiston] = ++ pistonState[currentPiston]; // Comută starea
  }
  showMenu();
}

// Salvare stare piston în EEPROM
void savePistonState() {
  EEPROM.write(5 + currentPiston, pistonState[currentPiston]);
  lcd.clear();
  lcd.print("PISTON ");
  lcd.print(currentPiston + 1);
  lcd.setCursor(9, 0);
  lcd.print("SALVAT");
  lcd.setCursor(0, 1);
  lcd.print("IN GRUPA  - ");
  lcd.print(pistonState[currentPiston] + 1);
  delay(500);
  showMenu();

    for (int i = 0; i < 8; i++) {
      pistonState[i] = EEPROM.read(5 + i);
      if (pistonState[i] == 255) {
        pistonState[i] = -1;
      }
      Serial.print("PISTON ");
      Serial.print(i + 1);
      Serial.print(" in grupa: ");
      Serial.println(pistonState[i]);
    }
}
// Salvare setări (TACT, RINDURI, etc.) în EEPROM
void saveSetting() {
  EEPROM.write(currentMenu, currentMenu < 2 ? values[currentMenu] : values[currentMenu] / 10);
  isEditing = false;
  lcd.clear();
  lcd.print("Setare Salvata!");
  delay(1000);
  showMenu();
  Serial.println(values[0]);
  Serial.println(values[1]);
  Serial.println(values[2]);
  Serial.println(values[3]);
  Serial.println(values[4]);
}

// Selectare meniu sau salvare valori
void selectMenu() {
  if (currentMenu == 5) {
    pistonEditing = true; // Intră în modul de editare a pistonilor
   showMenu();
  } else if (currentMenu < 5) {
    isEditing = true; // Intră în modul de editare a valorilor
    showMenu();
  } else if (currentMenu == 6){ 
    showMenu1();
  } else if (currentMenu == 7){ 
    manual = true;
  }
}

// Revenire la meniul anterior
void backMenu() {
  if (pistonEditing) {
    pistonEditing = false;
  } else if (isEditing) {
    isEditing = false;
  }
  showMenu();
}

// Afișarea meniului curent
void showMenu() {
  lcd.clear();
  if (isEditing) {
    lcd.print("EDIT-");
    lcd.print(menus[currentMenu]);
    lcd.setCursor(0, 1);
    lcd.print(values[currentMenu]);
  } else if (pistonEditing) {
    lcd.print("EDIT PISTON:- ");
    lcd.print(currentPiston + 1);
    lcd.setCursor(0, 1);
    lcd.print("ALEGE GRUPA:-");
    lcd.setCursor(14, 1);
    lcd.print(pistonState[currentPiston] + 1);
  } else {
    lcd.print(menus[currentMenu]);
    lcd.setCursor(0, 1);
    if (currentMenu < 5) lcd.print(values[currentMenu]);
  }
}

// Afișarea datelor despre apartenenta cilindrilor la grupe
void showMenu1() {
  lcd.clear();
    lcd.print("P1 2 3 4 5 6 7 8");
    lcd.setCursor(0, 1);
    lcd.print("G");
     lcd.setCursor(1, 1);
      for (int i = 0; i < 8; i++) {
    
    pistonState[i] = EEPROM.read(5 + i);
    if (pistonState[i] == 255) {pistonState[i]=-1;}
    lcd.print(pistonState[i] + 1); // Citirea apartenenței pistonilor la grupuri
    lcd.print(" ");  
  }  
} 

// Program de lucru 
// Start ciclului RINDPLASA
void startRindPlasaCycle() {

// Variabilă globală pentru grupa curentă
int activatedGroup = 0;
int activatedGroups = 0; // Numărul total de grupuri activate
  startTime = millis(); // Resetare CRUCIALĂ aici, în interiorul funcției rindplasa!
    senzorActivat = false;
  // Dezactivare piston PODEM
  digitalWrite(PistonPodem, LOW);

switch (currentStep) {
  case 0: // Inițializare ciclului

  if (!isRowWeldingDisplayed) { // Afișăm doar dacă nu a fost deja afișat
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("SE SUDEAZA");
      lcd.setCursor(0, 1);
      lcd.print("RINDUL - ");
      lcd.setCursor(10, 1);
      lcd.print(rinduriCounter + 1);

      isRowWeldingDisplayed = true; // Marcăm că mesajul a fost afișat
  }

  // Activare piston BLOKATOR
  digitalWrite(PistonBlokator, HIGH);
  
  // Delay TIMP BUNKER
  delay(values[4]);

  // Activare piston BUNKER
  digitalWrite(PistonBunker, HIGH);

while (!sensorsActive()) {
    lcd.clear(); // Afișăm mesajul de eroare
    lcd.setCursor(0, 0);
    lcd.print(" Eroare Sensor:");

    lcd.setCursor(0, 1);
    if (digitalRead(SENSOR_DREAPTA) == LOW && digitalRead(SENSOR_STANGA) == LOW) {
        lcd.print("Dreapta & Stanga");
    } 
    else if (digitalRead(SENSOR_DREAPTA) == LOW) {
        lcd.print("    Dreapta");
    } 
    else if (digitalRead(SENSOR_STANGA) == LOW) {
        lcd.print("     Stanga");
    }
    
    delay(100); // Pauză pentru a evita flicker-ul afișajului
}

// După ce senzorii sunt activi, ștergem mesajul de eroare
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("SE SUDEAZA");
lcd.setCursor(0, 1);
lcd.print("RINDUL - ");
lcd.setCursor(10, 1);
lcd.print(rinduriCounter + 1);

// Resetăm variabila pentru afișare
isRowWeldingDisplayed = true;

  // Dezctivare piston BLOKATOR
  digitalWrite(PistonBlokator, LOW);
  delay(values[3]);
  
  // Dezactivare piston BUNKER
  digitalWrite(PistonBunker, LOW);
  currentStep = 1;

case 1: // **Activare Pedala RCS
  digitalWrite(PEDALA_RCS_PIN, HIGH);
 currentStep = 2; // Trecem la etapa următoare
 handlePause();
 if (restartFromStep) {
restartFromStep = false;
 return;
 }

  currentStep = 2;

case 2: // Bucla grupelor

// Bucla pentru activarea și dezactivarea grupelor
while (activatedGroups < values[0]) {
 handlePause();
  if (restartFromStep) {
  restartFromStep = false;
  return;
  }

  while (!readClapanSignal()) {
   delay(5);
   handlePause();
   if (restartFromStep) {
   restartFromStep = false;
   return;
   }
}

activateGroup(activatedGroup);
delay(5);
  while (readClapanSignal()) {
  delay(5);
 handlePause();
 if (restartFromStep) {
  restartFromStep = false;
 return;
}
}

 // Dezactivare grupă curentă
  deactivateGroup(activatedGroup);
      
  // Incrementare și ciclicitate grupă
  activatedGroup = (activatedGroup + 1) % values[0];  // Ciclicitate prin %

  // Activare imediată a noii grupe, dar nu grupa 0 la sfârșit
  if (activatedGroups < values[0] - 1) {
    activateGroup(activatedGroup); // Activare următoarea grupă imediat
  }

  // Incrementare grupuri activate
  activatedGroups++; // Incrementare grupuri activate
 }
   currentStep = 3;

    case 3: // Finalizarea ciclului
  // Dezactivare Pedala RCS
  digitalWrite(PEDALA_RCS_PIN, LOW);

  // Delay TIMP PODEM (trebuie adaugat)
  delay(200);

  // Activare Piston PODEM
  digitalWrite(PistonPodem, HIGH);

  // Activare piston BLOKATOR
  digitalWrite(PistonBlokator, HIGH);

  // Delay TIMP PROTEAG
      delay(values[2]);

  // Activare Piston PROTEAG
  digitalWrite(PistonProteag, HIGH);

  // Delay TIMP BLOKATOR
  delay(values[3]);
  
  // Dezactivare piston BLOKATOR
  digitalWrite(PistonBlokator, LOW);

    // Finalizarea ciclului
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(" RIND-PLASA NR. ");
  lcd.print(rinduriCounter +1);
  lcd.setCursor(0, 1);
  lcd.print("       OK");
  delay(500);
        lcd.clear();
        lcd.setCursor(0, 1);
        lcd.print("Asteptam senzor...");
        delay(100);

startTime = millis();

// Așteaptă până la 10 secunde sau până când senzorul devine activ
while (millis() - startTime < 10000) {
    if (digitalRead(SENSOR_PROTEAG)) {
        senzorActivat = true; // Senzorul a devenit activ
        break; // Ieșim din buclă imediat
    }
    delay(5); // Mică pauză pentru a reduce încărcarea procesorului
}

// După expirarea timpului sau activarea senzorului
if (senzorActivat) {
    // Senzorul s-a activat în timpul alocat
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("   Senzor OK ");
    lcd.setCursor(0, 1);
    lcd.print("Incepem alt rind");
    delay(1000);
    senzorActivat = false; // Resetare pentru următorul ciclu
} else {
    // Timpul a expirat și senzorul nu s-a activat
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("EROARE: Proteag");
    startTime = millis(); // Resetare CRUCIALĂ aici, înainte de bucla de eroare
    
    // Dezactivare piston PROTEAG
    digitalWrite(PistonProteag, LOW);
    delay(100);

    // Buclă până când senzorul devine activ
    bool afisat = false; // Flag pentru a afișa mesajul doar o dată
    while (!digitalRead(SENSOR_PROTEAG)) {
        if (!afisat) {
            lcd.setCursor(0, 1);
            lcd.print("Asteptam senzor...");
            afisat = true; // Mesajul este afișat o singură dată
        }
        delay(100); // Pauză pentru procesor
    }

    // Senzorul s-a activat după eroare
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("   Senzor OK ");
    lcd.setCursor(0, 1);
    lcd.print("Incepem alt rind");
    delay(1000);
    
    senzorActivat = false; // Resetare pentru următorul ciclu
    startTime = millis();  // Resetare timp pentru următorul ciclu
}
//TIMP STABILIZARE trebuie adaugat cit se va stabiliza firul
//delay(100);

  // Dezactivare piston PROTEAG
  digitalWrite(PistonProteag, LOW);

  // Activare piston BLOKATOR
  digitalWrite(PistonBlokator, HIGH);

  // Incrementarea rinduriCounter
  rinduriCounter++;
  currentStep = 0; // Reset la început
    break;
}
}
void deactivateAllGroups() {

    for (int i = 0; i < 8; i++) {
        digitalWrite(pistonPins[i], LOW); // Dezactivează fiecare piston
    }
      delay(100);
}

// Funcție pentru verificarea activării ambilor senzori
bool sensorsActive() {
    unsigned long start = millis(); // Stochează timpul de început
    while (millis() - start < 120) { // Așteaptă până la 120 ms
        if (digitalRead(SENSOR_DREAPTA) == HIGH && digitalRead(SENSOR_STANGA) == HIGH) {
            return true; // Dacă ambii senzori sunt activi, returnează true imediat
            
        }
    }
    return false; // Dacă timpul a expirat și senzorii nu sunt activi, returnează false
}

// Funcție pentru activarea unei grupe de pistoane
void activateGroup(int group) {
 for (int i = 0; i < 8; i++) {
    if (pistonState[i] == group) {
      digitalWrite(pistonPins[i], HIGH);  
    }
  }
}

// Funcție pentru dezactivarea unei grupe de pistoane
void deactivateGroup(int group) {
  for (int i = 0; i < 8; i++) {
    if (pistonState[i] == group) {
      digitalWrite(pistonPins[i], LOW);  
    }
  }  
}

void handlePause() {
    if (digitalRead(BUTTON_PAUSE) == HIGH) { // Buton PAUSE apăsat
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("     PAUZA");
        lcd.setCursor(0, 1);
        lcd.print("    ACTIVATA");
    //Dezactivam RCS
        digitalWrite(PEDALA_RCS_PIN, LOW);
               // Dezactivăm toate grupele
        deactivateAllGroups();

        // Așteptăm eliberarea butonului PAUSE
        while (digitalRead(BUTTON_PAUSE) == HIGH) {
            delay(100);
        }
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("     PAUZA");
        lcd.setCursor(0, 1);
        lcd.print("  DEZACTIVATA");

        // Setează stadiul să reînceapă de la case 1
        currentStep = 1;
        restartFromStep = true; // Setați flag-ul pentru reluare
        delay(50);
    }
}

/*

// Funcție pentru meniul PISTOANE
void menuPistoane() {
  bool inPistonMenu = true; // Variabilă pentru a rămâne în meniul PISTOANE
  currentPiston = 0; // Resetăm selecția la primul piston

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Meniu PISTOANE");
  delay(500); // Pauză scurtă pentru afișaj

  while (inPistonMenu) {
    // Afișează pistonul selectat și starea lui
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(pistonStateLabel(currentPiston)); // Numele pistonului
    lcd.setCursor(0, 1);
    lcd.print("Stare: ");
    lcd.print(pistonState[currentPiston] == HIGH ? "HIGH" : "LOW");

    // Gestionare butoane
    for (int i = 0; i < 4; i++) {
      buttons[i].update();
    }

    // Navigare între pistoane
    if (buttons[0].fell()) { // UP
      currentPiston = (currentPiston + 1) % 12; // Trecem la următorul piston
      delay(200); // Debounce
    }

    if (buttons[1].fell()) { // DOWN
      currentPiston = (currentPiston - 1 + 12) % 12; // Trecem la pistonul anterior
      delay(200); // Debounce
    }

    // Schimbare stare piston
    if (buttons[2].fell()) { // OK
      pistonState[currentPiston] = !pistonState[currentPiston]; // Schimbă starea
      if (currentPiston < 8) {
        digitalWrite(pistonPins[currentPiston], pistonState[currentPiston]);
      } else {
        controlSpecialPiston(currentPiston, pistonState[currentPiston]);
      }
      delay(200); // Debounce
    }

    // Ieșire din meniu
    if (buttons[3].fell()) { // BACK
      lcd.clear();
      lcd.print("Iesire PISTOANE");
      delay(500);
      inPistonMenu = false; // Ieșim din buclă
    }
  }
}

// Funcție pentru afișarea numelui pistonului curent
String pistonStateLabel(int index) {
  switch (index) {
    case 0: return "Piston 1";
    case 1: return "Piston 2";
    case 2: return "Piston 3";
    case 3: return "Piston 4";
    case 4: return "Piston 5";
    case 5: return "Piston 6";
    case 6: return "Piston 7";
    case 7: return "Piston 8";
    case 8: return "PISTON-PODEM";
    case 9: return "PISTON-PROTEAG";
    case 10: return "PISTON-BLOKATOR";
    case 11: return "PISTON-BUNKER";
    default: return "Necunoscut";
  }
}

// Funcție pentru controlul pistoanelor speciale
void controlSpecialPiston(int index, bool state) {
  switch (index) {
    case 8: digitalWrite(PistonPodem, state); break;
    case 9: digitalWrite(PistonProteag, state); break;
    case 10: digitalWrite(PistonBlokator, state); break;
    case 11: digitalWrite(PistonBunker, state); break;
  }
}
*/



// Funcție pentru meniul PISTOANE
void menuPistoane() {
  
  bool inPistonMenu = true; // Variabilă pentru a rămâne în meniul PISTOANE
  int currentPiston = 0; // Resetăm selecția la primul piston
  bool shouldUpdateDisplay = true;

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Meniu PISTOANE");
  delay(500); // Pauză scurtă pentru afișaj
lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Meniu PISTOANE");
  delay(500); // Pauză scurtă pentru afișaj

  while (inPistonMenu) {
    // Actualizăm afișajul doar dacă este necesar
    if (shouldUpdateDisplay) {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(pistonStateLabel(currentPiston));
      lcd.setCursor(0, 1);
      lcd.print("Stare: ");
      lcd.print(pistonState[currentPiston] == HIGH ? "HIGH" : "LOW");
      shouldUpdateDisplay = false;
    }
    // Gestionare butoane DOAR dacă suntem în meniul PISTOANE
    if (manual) {
      for (int i = 0; i < 4; i++) {
        buttons[i].update();
      }

      // Navigare între pistoane
      if (buttons[0].fell()) { // UP
        currentPiston = (currentPiston + 1) % 12;
        shouldUpdateDisplay = true;
        delay(50); // Debounce
      }

      if (buttons[1].fell()) { // DOWN
        currentPiston = (currentPiston - 1 + 12) % 12;
        shouldUpdateDisplay = true;
        delay(50); // Debounce
      }

      // Schimbare stare piston
      if (buttons[2].fell()) { // OK
        pistonState[currentPiston] = !pistonState[currentPiston];
        if (currentPiston < 8) {
          digitalWrite(pistonPins[currentPiston], pistonState[currentPiston]);
        } else {
          controlSpecialPiston(currentPiston, pistonState[currentPiston]);
        }
        shouldUpdateDisplay = true;
        delay(50); // Debounce
      }

      // Ieșire din meniu
      if (buttons[3].fell()) { // BACK
        lcd.clear();
        lcd.print("Iesire PISTOANE");
        delay(500);
        inPistonMenu = false;
        manual = false;
      
      }
    }
  }
}

// Funcție pentru afișarea numelui pistonului curent
String pistonStateLabel(int index) {
  switch (index) {
    case 0: return "Piston 1";
    case 1: return "Piston 2";
    case 2: return "Piston 3";
    case 3: return "Piston 4";
    case 4: return "Piston 5";
    case 5: return "Piston 6";
    case 6: return "Piston 7";
    case 7: return "Piston 8";
    case 8: return "PISTON-BUNKER"; 
    case 9: return "PISTON-PODEM";
    case 10: return "PISTON-BLOKATOR";
    case 11: return "PISTON-PROTEAG";
    default: return "Necunoscut";
  }
}

// Funcție pentru controlul pistoanelor speciale
void controlSpecialPiston(int index, bool state) {
  switch (index) {
    case 8: digitalWrite(PistonBunker, state); break;
    case 9: digitalWrite(PistonPodem, state); break;
    case 10: digitalWrite(PistonBlokator, state); break;
    case 11: digitalWrite(PistonProteag, state); break;
  }
}