//V5  cu 4 transformatoare trebuie pusa in procesor
// trebuie de schimbat ecranul

#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 = HIGH;        // Starea anterioară a semnalului
bool clapanSignalState = HIGH;            // Starea curentă a semnalului
unsigned long clapanLastDebounceTime = 0; // Ultima actualizare a semnalului
unsigned long clapanDebounceDelay = 10;   // Timpul de debounce în milisecunde

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

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

// Definire pinuri
const int SensorOK = 27;          // Ieșire pentru bec sensorOK
const int Becdreapta = 28;        // Ieșire pentru bec dreapta
const int Becstinga = 29;         // Ieșire pentru bec stinga
const int PistonPodem = 2;        // Ieșire pentru podem
const int RCS_INVERTOR = 3;      // Ieșire pentru permisiune INVERTOR
const int PistonBunkerN1 = 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 INVERTOR_RCS  = 24;   // Intrare de la INVERTOR adica PERMISIUNE INVERTOR 
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
const int PistonBunkerN2 = 4;     // Ieșire pentru blokerator

      // Definirea pinilor PISTOANELOR
const int pistonPins[4] = {10, 11, 12, 30}; // Definirea pinilor pentru pistoane
      // Definirea pinilor TRANSFORMATOARELOR
const int T1 = 6;
const int T2 = 7;
const int T3 = 8;
const int T4 = 9;
//const uint8_t TRANS_PINS[4] = {32, 33, 34, 35};
const uint8_t TRANS_PINS[4] = {36, 37, 38, 39}; // sau 22–29

// Variabile pentru navigare și gestionarea meniurilor
int currentMenu = 0;
const int totalMenus = 13; // Am adaugat un meniu pentru GRUPE
String menus[totalMenus] = {
  "TACT",
  "RINDURI",
  "TIMP SENSOR",
  "TIMP PODEM",
  "TIMP PROTEAG",
  "TIMP BUNKER_N1",
  "TIMP EROARE",
  "TIMP BUNKER_N2",
  "PAUZA RCS",
  "CILINDRI",
  "DATE",
  "PISTOANE",
  "STATISTICA"
};

int clapanCloseCount = 0; // Contor pentru tranzițiile LOW → HIGH

// Variabile pentru valorile din submeniuri
int values[9] =  {2, 2, 120, 200, 100, 30, 500, 1000, 500}; // {1, 1, 1, 1, 1, 1, 1, 1, 1};// // TACT, RINDURI, TIMP PROTEAG, TIMP BLOKATOR
const int minValues[] = {1, 1, 1, 1, 1, 1, 1, 1, 1};
const int maxValues[] = {4, 99, 1000, 1000, 1000, 1000, 2500, 1000, 500};
const int steps[] = {1, 1, 10, 50, 50, 10, 50, 50, 10};

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

// Variabile pentru gestionarea rindurilor si plaselor
int rinduriCounter = 0;
int plasaCounter = 0;

// Variabile pentru temporizare pentru minos plasa
unsigned long startTimeR = 0; 
bool butoaneApasate = false;

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

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

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_PULLUP);      // Senzor dreapta configurat ca intrare
 pinMode(SENSOR_STANGA, INPUT_PULLUP);       // Senzor stânga configurat ca intrare
 pinMode(INVERTOR_RCS, INPUT_PULLUP);      // Senzor proteag configurat ca intrare
 pinMode(CLAPAN_SIGNAL, INPUT_PULLUP);       // Semnal RCS configurat ca intrare
 pinMode(START_BUTTON, INPUT_PULLUP);        // Buton START configurat ca intrare cu rezistență internă pull-up
 pinMode(BUTTON_PAUSE, INPUT_PULLUP);        // Buton PAUSE

  // Configurarea pinilor pentru pistoane
  for (int i = 0; i < 4; i++) {
 pinMode(pistonPins[i], OUTPUT);  // Setează fiecare pin din array ca ieșire
  }
 pinMode(SensorOK, OUTPUT);       //Bec SensorOK configurat ca ieșire
 pinMode(Becstinga, OUTPUT);      // Bec stinga configurat ca ieșire
 pinMode(Becdreapta, OUTPUT);     // Bec dreapta configurat ca ieșire
 pinMode(PistonPodem, OUTPUT);    // Podem configurat ca ieșire
 pinMode(RCS_INVERTOR, OUTPUT);  // Proteag configurat ca ieșire
 pinMode(PistonBunkerN2, OUTPUT); // Blokerator configurat ca ieșire
 pinMode(PistonBunkerN1, OUTPUT);   // Bunker configurat ca ieșire
 pinMode(PEDALA_RCS_PIN, OUTPUT); // RELE Pedala RCS configurată ca ieșire
  
    // Inițializare pinuri ca ieșiri
    pinMode(T1, OUTPUT);  //TRANSFORMATOR 1
    pinMode(T2, OUTPUT);  //TRANSFORMATOR 2
    pinMode(T3, OUTPUT);  //TRANSFORMATOR 3
    pinMode(T4, OUTPUT);  //TRANSFORMATOR 4

        for (uint8_t i = 0; i < 4; i++) {
        pinMode(TRANS_PINS[i], INPUT_PULLUP);
    }

    // Setare inițială a pinurilor pe LOW (opțional)
    digitalWrite(T1, LOW);
    digitalWrite(T2, LOW);
    digitalWrite(T3, LOW);
    digitalWrite(T4, LOW);

  // 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(1);      // TACT
  values[1] = EEPROM.read(2);      //RINDURI
  values[2] = EEPROM.read(3) * 10; //TIMP SENSOR
  values[3] = EEPROM.read(4) * 10; //TIMP PODEM
  values[4] = EEPROM.read(5) * 10; //TIMP PROTEAG
  values[5] = EEPROM.read(6) * 10; //TIMP BUNKERN1
  values[6] = EEPROM.read(7) * 10; //TIMP EROARE
  values[7] = EEPROM.read(8) * 10; //TIMP BUNKERN2
  values[8] = EEPROM.read(9) * 10; //TIMP PAUZA RCS
  
 Serial.begin(9600); // Setează viteza de transmisie a datelor pe serial
  
  for (int i = 0; i < 4; i++) {
    pistonState[i] = EEPROM.read(10 + i);
    if (pistonState[i] == 255) {
      pistonState[i] = -1;
    }
  }

  // Mesaj de salut
  lcd.setCursor(0, 0);
  lcd.print("     ARMESH  ");
  lcd.setCursor(0, 1);
  lcd.print(" VER-4-INVERTOR ");
  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 (manualState == true) {
    menuPistoane();
  } else if (automateState == true) {
    waitForInvertorRCS();
    working();
  } else {
    readButtons();
  }
  if (plasaCounter <= 0) { // PRIMA PORNIRE
    digitalWrite(PistonPodem, LOW);
  }

  // pentru minus plasa
  bool buton1Apasat = digitalRead(14) == LOW; // Citire buton 1
  bool buton2Apasat = digitalRead(17) == LOW; // Citire buton 2

  if (buton1Apasat && buton2Apasat) {
    if (!butoaneApasate) {
      butoaneApasate = true;
      startTimeR = millis(); // Salvăm timpul inițial când butoanele sunt apăsate
    }
    // Dacă butoanele sunt apăsate timp de 1 secunda
    if (butoaneApasate && (millis() - startTimeR >= 1000)) {
        if (plasaCounter > 0) { 
        plasaCounter--; // Scădem contorul cu 1
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("  PLASE minus 1 ");
        delay(1500);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("PLASE FABRICATE ");
        lcd.setCursor(7, 1);
        lcd.print(plasaCounter);
        delay(1500);
      } 
      butoaneApasate = false; // Resetăm starea butoanelor
      delay(1000); // Evităm dubla scădere accidentală
    }
  } else {
    butoaneApasate = false; // Resetăm starea dacă butoanele nu mai sunt apăsate
  }
}
/////////////////////////////////////
bool checkTransformersSafety() {
  int activeCount = 0;
  for (int i = 0; i < 4; i++) {
    if (digitalRead(TRANS_PINS[i]) == LOW) {
      activeCount++;
    }
  }
  return activeCount >= 2; // TRUE dacă cel puțin 2 TRANS_PINS sunt active
}
////////////////////////////////////
void waitForInvertorRCS() {
  while (digitalRead(INVERTOR_RCS) == HIGH) {

    // Totul oprit – SIGURANTA
    digitalWrite(PEDALA_RCS_PIN, LOW);
    digitalWrite(T1, LOW);
    digitalWrite(T2, LOW);
    digitalWrite(T3, LOW);
    digitalWrite(T4, LOW);
    deactivateAllGroups();
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("ASTEAPTA SEMNAL");
    lcd.setCursor(0, 1);
    lcd.print("DE LA INVERTOR");
    delay(10); // mic delay anti-flicker
  }
}


void working() {
  // Citirea stării butonului
  int buttonState = digitalRead(START_BUTTON);
  // Verificarea dacă butonul a fost apăsat (stare LOW)
  if (buttonState == LOW) {
    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(500);
    automateState = false; // permit accesul la meniul principal după terminarea plasei
  } else {
    buttons[3].update();
    if (buttons[3].rose()) { 
      automateState = false;
    }
  }
}

// Citirea și gestionarea butoanelor
void readButtons() {
  // Citirea stării butonului
  int buttonState = digitalRead(START_BUTTON);
  // Verificarea dacă butonul a fost apăsat (stare LOW) si daca e LOW atunci pornim a lucra automat
  if (buttonState == LOW) {
    automateState = true;
    currentMenu = 0;
    return;
  }
  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 == 11) {
      manualState = true;
      currentMenu = 0;
      return; // daca meniul selectat este 11 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 + 4) % 4; // 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] >= 3) {
    pistonState[currentPiston] = -1;
  } else {
    pistonState[currentPiston] = ++ pistonState[currentPiston]; // Comută starea
  }
  showMenu();
}

// Salvare stare piston în EEPROM
void savePistonState() {
  EEPROM.write(10 + 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 < 4; i++) {
      pistonState[i] = EEPROM.read(10 + i);
      if (pistonState[i] == 255) {
        pistonState[i] = -1;
      }
    }
}
// Salvare setări (TACT, RINDURI, etc.) în EEPROM
void saveSetting() {
  EEPROM.write(currentMenu + 1, currentMenu < 3 ? values[currentMenu] : values[currentMenu] / 10);
  isEditing = false;
  lcd.clear();
  lcd.print("Setare Salvata!");
  delay(1000);
  showMenu();
}

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

// 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 < 9) lcd.print(values[currentMenu]);
  }
}

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

// Afișarea datelor despre plasele fabricate
void showMenu2() {
  lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("PLASE FABRICATE ");
    lcd.setCursor(7, 1);
    lcd.print(plasaCounter);
    delay(1000);
} 

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

    // 🔹 PRIMUL RÂND: START + invertor
    if (rinduriCounter == 0) {
        if (digitalRead(START_BUTTON) == HIGH || digitalRead(INVERTOR_RCS) == HIGH) {
            return; // Nu porni rândul 1
        }
    } else {
        // 🔹 Rândurile următoare: doar invertor activ
        if (digitalRead(INVERTOR_RCS) == HIGH) {
            return; // Nu porni rândul următor până invertorul nu e activ
        }
    }

 // 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, HIGH);
  
  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(11, 0);
      lcd.print("R-");
      lcd.setCursor(13, 0);
      lcd.print(rinduriCounter + 1);
      lcd.setCursor(0, 1);
      lcd.print("PLASA NR. - ");
      lcd.setCursor(12, 1);
      lcd.print(plasaCounter + 1);  

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

   // Delay TIMP BUNKER
   delay(values[7]);
   // Activare piston BUNKER
   digitalWrite(PistonBunkerN1, HIGH);

     while (!sensorsActive()) {
     lcd.clear(); // Afișăm mesajul de eroare
     lcd.setCursor(0, 0);
     lcd.print("Asteptam Sensor:");
     delay(50);
     lcd.setCursor(0, 1);
     if (digitalRead(SENSOR_DREAPTA) == HIGH && digitalRead(SENSOR_STANGA) == HIGH) {
        lcd.print("Dreapta & Stanga");
        digitalWrite(Becdreapta, HIGH);
        digitalWrite(Becstinga, HIGH);  
      } else if (digitalRead(SENSOR_DREAPTA) == HIGH) {
        lcd.print("    Dreapta");
        digitalWrite(Becdreapta, HIGH);
          digitalWrite(Becstinga, LOW);
      } else if (digitalRead(SENSOR_STANGA) == HIGH) {
        lcd.print("     Stanga");
        digitalWrite(Becstinga, HIGH);
        digitalWrite(Becdreapta, LOW);
      }
          delay(500); // 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(11, 0);
      lcd.print("R-");
      lcd.setCursor(13, 0);
      lcd.print(rinduriCounter + 1);
      lcd.setCursor(0, 1);
      lcd.print("PLASA NR. - ");
      lcd.setCursor(12, 1);
      lcd.print(plasaCounter + 1); 
      digitalWrite(Becstinga, LOW);
      digitalWrite(Becdreapta, LOW);
   // Resetăm variabila pentru afișare
   isRowWeldingDisplayed = true;
   // Dezactivare piston BUNKER
   digitalWrite(PistonBunkerN1, 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; // Duplicat - eliminat
case 2: // Bucla grupelor
    while (activatedGroups < values[0]) {
            handlePause();
        if (restartFromStep) {
            restartFromStep = false;
            return;
        }

        // 1. Activare grup curent + PIN6 + Pedala RCS
        activateGroup(activatedGroup);
        digitalWrite(T1, HIGH);
        digitalWrite(T2, LOW);
        digitalWrite(T3, LOW);
        digitalWrite(T4, LOW);
        digitalWrite(PEDALA_RCS_PIN, HIGH);

        // 2. Așteptăm HIGH→LOW (activare clapan)
        while (readClapanSignal() == HIGH) {
            delay(10);
            handlePause();
            if (restartFromStep) return;
        }

        // 3. Așteptăm LOW→HIGH (deconectare clapan)
        while (readClapanSignal() == LOW) {
            delay(10);
            handlePause();
            if (restartFromStep) return;
        }
        // Acum facem prima schimbare (la PIN7)
        digitalWrite(T1, LOW);
        digitalWrite(T2, HIGH);

        // 4. Repetăm pentru următoarele PIN-uri
        // Așteptăm HIGH→LOW
        while (readClapanSignal() == HIGH) {
            delay(10);
            handlePause();
            if (restartFromStep) return;
        }

        // Așteptăm LOW→HIGH
        while (readClapanSignal() == LOW) {
            delay(10);
            handlePause();
            if (restartFromStep) return;
        }
        // Schimbare la PIN8
        digitalWrite(T2, LOW);
        digitalWrite(T3, HIGH);
           // Dezactivare piston BUNKER
  
        // 5. Repetăm pentru PIN9
        // Așteptăm HIGH→LOW
        while (readClapanSignal() == HIGH) {
            delay(10);
            handlePause();
            if (restartFromStep) return;
        }

        // Așteptăm LOW→HIGH
        while (readClapanSignal() == LOW) {
            delay(10);
            handlePause();
            if (restartFromStep) return;
        }
        // Schimbare la PIN9
        digitalWrite(T3, LOW);
        digitalWrite(T4, HIGH);

        // 6. Ultimul ciclu pentru a închide toate PIN-urile
        // Așteptăm HIGH→LOW
        while (readClapanSignal() == HIGH) {
            delay(10);
            handlePause();
            if (restartFromStep) return;
        }

        // Așteptăm LOW→HIGH
        while (readClapanSignal() == LOW) {
            delay(10);
            handlePause();
            if (restartFromStep) return;
        }
        // Închidem toate PIN-urile
        digitalWrite(T4, LOW);
        digitalWrite(PEDALA_RCS_PIN, LOW);
        digitalWrite(PistonBunkerN2, LOW);

        // 7. Dezactivare grup curent
        deactivateGroup(activatedGroup);
         digitalWrite(PEDALA_RCS_PIN, LOW);
             
        // 8. Trecem la următorul grup
        activatedGroup = (activatedGroup + 1) % values[0];
        activatedGroups++;
                delay(values[8]);
    }
    currentStep = 3;

    case 3: {
     // Dezactivare Pedala RCS
     digitalWrite(PEDALA_RCS_PIN, LOW);
     digitalWrite(T1, LOW);
     digitalWrite(T2, LOW);
     digitalWrite(T3, LOW);
     digitalWrite(T4, LOW);

     // Delay TIMP PODEM
     delay(values[3]);

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

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

     // Activare Piston PROTEAG
     digitalWrite(RCS_INVERTOR, HIGH);
     lcd.clear();
     lcd.setCursor(0, 1);
     lcd.print("    PROTEAG");
     digitalWrite(PistonBunkerN2, HIGH);

     unsigned long startTime = millis();
     bool senzorActivat = false;

     // Prima încercare de activare senzor
     while (millis() - startTime < values[6]) {
        if (digitalRead(INVERTOR_RCS) == LOW) {
            senzorActivat = true;
            break;
        }
        delay(10);
     }
      if (senzorActivat) {
        // Senzorul s-a activat din prima încercare
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("   PROTEAG ");
        lcd.setCursor(0, 1);
        lcd.print("  EFECTUAT");
        delay(values[8]);
      } 
                   digitalWrite(Becdreapta, LOW);
                   digitalWrite(Becstinga, LOW);
                   digitalWrite(SensorOK, LOW);
     // Dezactivare piston PROTEAG
     digitalWrite(RCS_INVERTOR, LOW);

      // Incrementarea rinduriCounter
     rinduriCounter++;
     currentStep = 0; // Reset la început
     break;
    }
  }
}
void deactivateAllGroups() {
    for (int i = 0; i < 4; i++) {
        digitalWrite(pistonPins[i], LOW); // Dezactivează fiecare piston
    }
      delay(20);
}

// Funcție pentru verificarea activării ambilor senzori
bool sensorsActive() {
    unsigned long start = millis(); // Stochează timpul de început
    while (millis() - start < values[2]) { // Așteaptă până la timp sensor
        if (digitalRead(SENSOR_DREAPTA) == LOW && digitalRead(SENSOR_STANGA) == LOW) {
            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 < 4; i++) {
    if (pistonState[i] == group) {
      digitalWrite(pistonPins[i], HIGH);  
           // Activare Pedala RCS
     digitalWrite(PEDALA_RCS_PIN, HIGH);
    }
  }
      if (rinduriCounter == values[1]-1) {
        digitalWrite(SensorOK, HIGH);  // Aprinde LED-ul la ultimul rând
   } else { 
        digitalWrite(SensorOK, LOW);   // Stinge LED-ul în orice alt caz
    }
}

// Funcție pentru dezactivarea unei grupe de pistoane
void deactivateGroup(int group) {
  for (int i = 0; i < 4; i++) {
    if (pistonState[i] == group) {
      digitalWrite(pistonPins[i], LOW);  
           // Dezactivare Pedala RCS
     digitalWrite(PEDALA_RCS_PIN, LOW);
        
    }
  }  
      if (rinduriCounter == values[1]-1) {
        digitalWrite(SensorOK, LOW);  // Aprinde LED-ul la ultimul rând
   } 
    delay(50);
}

void handlePause() {
    bool pauseByButton = (digitalRead(BUTTON_PAUSE) == LOW);
    bool pauseByTransformer = checkTransformersSafety();

    // Dacă este activată pauza
    if (pauseByButton || pauseByTransformer) {
        lcd.clear();
        if (pauseByButton) {
            lcd.setCursor(0, 0);
            lcd.print("     PAUZA");
            lcd.setCursor(0, 1);
            lcd.print("    ACTIVATA");
        } else if (pauseByTransformer) {
            lcd.setCursor(0, 0);
            lcd.print("TRANS PINS ACTIVATE:");
            lcd.setCursor(0, 1);
            // Afișăm pinii TRANS activi
            String activePins = "";
            for (int i = 0; i < 4; i++) {
                if (digitalRead(TRANS_PINS[i]) == LOW) {
                    activePins += String(i + 1) + " "; // afișăm indexul pinului (1-4)
                }
            }
            lcd.print(activePins);
        }

        // Dezactivăm RCS și toate grupele
        digitalWrite(PEDALA_RCS_PIN, LOW);
        digitalWrite(T1, LOW);
        digitalWrite(T2, LOW);
        digitalWrite(T3, LOW);
        digitalWrite(T4, LOW);
        deactivateAllGroups();

        // Așteptăm revenirea la normal
        while (digitalRead(BUTTON_PAUSE) == LOW || checkTransformersSafety()) {
            delay(100); // mic delay pentru stabilitate
        }

        // Pauza dezactivată
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("     PAUZA");
        lcd.setCursor(0, 1);
        lcd.print("  DEZACTIVATA");
        delay(500);
        lcd.clear();

        lastClapanSignalState = HIGH; // Starea anterioară a semnalului  

        // Afișăm statusul sudură după pauză
        isRowWeldingDisplayed = false;
        if (!isRowWeldingDisplayed) {
            lcd.setCursor(0, 0);
            lcd.print("SE SUDEAZA");
            lcd.setCursor(11, 0);
            lcd.print("R-");
            lcd.setCursor(13, 0);
            lcd.print(rinduriCounter + 1);
            lcd.setCursor(0, 1);
            lcd.print("PLASA NR. - ");
            lcd.setCursor(12, 1);
            lcd.print(plasaCounter + 1);
            isRowWeldingDisplayed = true;
        }

        // Setăm reluarea de la pasul 1
        currentStep = 1;
        restartFromStep = true;
        delay(50);
    }
}

// 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
  int pistonState [] = {LOW, LOW, LOW, LOW, LOW, LOW, LOW};
  bool shouldUpdateDisplay = true;

  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
      for (int i = 0; i < 4; i++) {
      buttons[i].update();
    }

    // Navigare între pistoane
    if (buttons[0].fell()) { // UP
      currentPiston = (currentPiston + 1) % 7;
      shouldUpdateDisplay = true;
      delay(50); // Debounce
    }
    if (buttons[1].fell()) { // DOWN
      currentPiston = (currentPiston - 1 + 7) % 7;
      shouldUpdateDisplay = true;
      delay(50); // Debounce
    }
    // Schimbare stare piston
    if (buttons[2].fell()) { // OK
      pistonState[currentPiston] = !pistonState[currentPiston];
      if (currentPiston < 4) {
        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);
      lcd.clear();
      lcd.print(menus[currentMenu = 11]);      // Back
      inPistonMenu = false;
      manualState = 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 "PistonBunkerN1"; 
    case 5: return "PISTON-PODEM";
    case 6: return "PistonBunkerN2";
    default: return "Necunoscut";
  }
}

// Funcție pentru controlul pistoanelor speciale
void controlSpecialPiston(int index, bool state) {
  switch (index) {
    case 4: digitalWrite(PistonBunkerN1, state); break;
    case 5: digitalWrite(PistonPodem, state); break;
    case 6: digitalWrite(PistonBunkerN2, state); break;
  }
}
////////////////////////////////////////////////////////////////////