//------------------------------------------------------------------------------//
//---------------------------   QUETZAL ELECTRONICS   -----------------------------//
//---------------------------   CODE BY ROHIT R PARMAR   ---------------------//
//---------------------------   REVISION 2.0               ---------------------//
//------------------------------------------------------------------------------//
//
// AC LOAD[S]: WATER PUMP(M1),TWO SOLENOID SW(SV2,SV3),MIXER MOTOR(M3)[230V]
// DC LOAD[S]: FLOW INT SENSOR SUPPLY(12V),SV1(24V),FLUID PUMP(M2-24V),LOCK,LOCK_BREAK-12V[SOLENOID]
// WARNING[S]: HIGH MEANS DEVICES[LOAD] IS OFF AND LOW MEANS DEVICES[LOAD] ON
// LEVEL SENSOR[S] : FLUID LEVEL SWITCH[LS1],WATER LEVEL SWITCH[LS2]
// SWITCH SENSOR[S] : DOOR STATUS SWITCH[DLS],PUMP DIRECT SWITCH[PS],START SWITCH[START],MODE SWITCH,DOOR LOCK_UNLOCK SWITCH,FOOT SWITCH,EMERGENCY STOP
// LOCK ASSEMBLY CONTAINS STEPPER MOTOR AND BHOLANATH 4.5A MOTOR DRIVER
// http://bholanath.in/certificates-files/stepper-drives-TDS/BH-MSD-4.5A-DRIVE-MANUAL.pdf?130818
// TOTAL INPUTS  [9]  : LEVEL SENSOR[x(2)],SWITCH SENSOR[x(2)][IF ALL ADDED x(7)],
// TOTAL OUTPUTS [11] : SOLENOID VALVE[x(2)],WATER PUMP[x(1)],DOSING PUMP[x(1)],MIXER MOTOR[x(1)],STEPPER MOTOR[CONTAIN (3) PIN FOR CONTROL],LCD[(2) PIN I2C],BUZZER[x(1))]
// DEVICE CAPACITY    : MAX 20 INPUT_OUTPUT
// "GOOD THINGS TAKE A TIME" -ME
//------------------------------------------------------------------------------//

#include<EEPROM.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd (0x27,16,2); // SET DEFAULT I2C ADDRESS [0X27]
// ITS ADDRESS MAY BE DIFFER FROM COMPANY OF PCF8575
int show;

//------------------------------------------------------------------------------//
//---------------------------   STEPPER CONTROL PIN    -------------------------//
//------------------------------------------------------------------------------//

#define M_EN 5             // IN DESIGN j5 [pin2]
#define M_DIR 6            // IN DESIGN j6 [pin2]
#define M_PULSE A6         // IN DESIGN j7 [pin2] 

#define doorStatusPin A2   // IN DESIGN PS SWITCH[J1]     // WHITE PUSH SWITCH
#define doorLockPin A3     // IN DESIGN START SWITCH[J9]  // GREEN PUSH BUTTON
#define START_FLOW 11      // IN DESIGN DISCONNECT j25 & CONNECT SWICH[GPIO 11]

#define lockStsSaveLoc 50     // EEPROM LOCATION 
#define P_DIRECT 2            // PUMP DIRECT SWITCH 
bool    PD_STS = false;       // PUMP DIRECT flag

//------------------------------------------------------------------------------//
//---------------------------   LCD DISPLAY MESSAGE    -------------------------//
//------------------------------------------------------------------------------//

// "1234567812345678"
// "HEALTHCARE SOLUTION"
// "WELCOME"
// "POWER ON"
// "FILLING WATER"
// "WATER LEVEL OK"
// "LIQUID EMPTY"
// "CLEANNING DEVICE"

//------------------------------------------------------------------------------//
//---------------------------   INPUT SWITCHES     -----------------------------//
//------------------------------------------------------------------------------//

int dispDelay = 200;
int dispCnt = 0;

// DEFAULT CONNECTION : ONE TERMINAL CONNECT TO THE GROUND

#define LS1 3  //FLUID LEVEL SWITCH  //
#define LS2 4  //WATER LEVEL SWITCH   

// IN DESIGN DISCONNECT j26 & CONNECT SWICH[GPIO 12]
/*
  #define DLS 6  // DOOR LOCK SWITCH
  #define DCS 5  // DOOR  CLOSED LOCK SWITCH
  #define DFS 7  // DOOR  FOOT UNLOCK SWITCH
*/

//------------------------------------------------------------------------------//
//---------------------------   door lock              -------------------------//
//------------------------------------------------------------------------------//
#define RL 10     // door lock relay

//------------------------------------------------------------------------------//
//------------------- LOCK ASSEMBLY CONTROL SOURCE -----------------------------//
//------------------------------------------------------------------------------//
//
#define M_EN 5     // ENABLE PIN
#define M_DIR 6    // DIRECTION
#define M_PULSE A6  // PWM PULSE BASED ON SELECTED RPM
#define Relay 6    // Additional Relay Output Added by shrik

//------------------------------------------------------------------------------//
//------------------------------------------------------------------------------//

//#define PS A2     // PUMP DIRECT SWITCH
//#define START A3  // START BUTTON

//------------------------------------------------------------------------------//
//---------------------------   OUTPUT LOADS  ----------------------------------//
//------------------------------------------------------------------------------//

#define SV1 8    //VERY FIRST INLET VALVE   //DC LOAD //WATER INLET(24V)
#define SV2 7   //TANK CLEANER INLET VALVE //        //AC LOAD //13 // A1 //12

#define M1 12    //WATER PUMP  // AD LOAD //A1 //13
#define M2 9     //FLUID PUMP-DOSING PUMP  //DC LOAD(24V)
#define M3 A0    //MIXER MOTOR  //AC LOAD //NEW


boolean toggle2 = 0;
bool   DOS = false;     // DOOR OPEN STATUS
int  LOCK_S = 0;       // 0-UNLOCKED,1-LOCKED
bool BUSY = false;
unsigned int stepCount = 0;
const unsigned int maxStep = 150;//250

unsigned long countSec = 0;
int8_t MY_MODE = -1;
uint8_t process = 0;
//uint8_t stage = 0;
unsigned long puls = 0;    // HIGHER THE PULSE, HIGHER THE WATER PRESSURE
const int MAX_WATER_PRESSURE = 100;
long z = 0;

int doorStep = -1;
bool WLEVEL = false;
bool FLEVEL = false;

void setup()
{

  Serial.begin(9600);
  Serial.println();
  Serial.println("ALL OK");

  pinMode(LS1, INPUT_PULLUP);            //FLUID LEVEL SWITCH
  pinMode(LS2, INPUT_PULLUP);            //WATER LEVEL SWITCH
  pinMode(P_DIRECT, INPUT_PULLUP);       //PUMP DIRECT SWITCH
  pinMode(START_FLOW, INPUT_PULLUP);
  pinMode(Relay,OUTPUT);  // Additional Relay Output
  

  pinMode(SV1, OUTPUT);                  //VERY FIRST INLET VALVE  //DC LOAD    //WATER INLET(24V)
  pinMode(SV2, OUTPUT);                  //ABOVE MIXER TANK VALVE  //AC LOAD
  pinMode(M1,  OUTPUT);                  //WATER PUMP              //AC LOAD
  pinMode(M2,  OUTPUT);                  //FLUID PUMP-DOSING PUMP  //DC LOAD(24V)
  pinMode(M3,  OUTPUT);                  //MIXER MOTOR             //AC LOAD

  pinMode(RL, OUTPUT);             //DOOR RELAY
//  pinMode(M_EN,   OUTPUT);
//  pinMode(M_PULSE,OUTPUT);
//  pinMode(M_DIR,  OUTPUT);

  /*
    pinMode(LS2, INPUT_PULLUP);   //WATER LEVEL SWITCH
    pinMode(DCS, INPUT_PULLUP);   //DOOR CLOSED SWITCH
    pinMode(DLS, INPUT_PULLUP);   //DOOR LOCK SWITCH

    pinMode(LOCK, OUTPUT);
    pinMode(LOCK_BRK, OUTPUT);
    digitalWrite(LOCK, LOW);
    digitalWrite(LOCK_BRK, LOW);
  */

  timerSetup();
  digitalWrite(SV1,LOW);  // VERY FIRST INLET VALVE  //DC LOAD //WATER INLET(24V)
  digitalWrite(SV2,LOW);  // ABOVE MIXER TANK VALVE  //AC LOAD

  digitalWrite(M1, LOW);   // WATER PUMP  // AD LOAD
  digitalWrite(M2, LOW);   // FLUID PUMP-DOSING PUMP  //DC LOAD(24V)
  digitalWrite(M3, LOW);   // MIXER MOTOR
  digitalWrite(RL, LOW);
  defaultLock();           // STEPPER HANDLE

  loadoff();
  if (isWaterEmpty())
  {
    //WATER LEVEL NOT OK
    //MAKE SV1 ON
    digitalWrite(SV1, HIGH);
  }
  else
  {
    //WATER LEVEL OK
    //MAKE SV1 OFF
    digitalWrite(SV1, LOW);
  }

  loadoff();
  if (isfluidEmpty())
  {
    //WATER LEVEL NOT OK 
    //MAKE SV2 ON
  //  digitalWrite(SV2, HIGH);
  }
  else
  {
    //WATER LEVEL OK
    //MAKE SV2 OFF
   // digitalWrite(SV2, LOW);
  }
  //Wire.setClock(10000);
  lcd.setBacklight(255);
  displaySetup();
  lcd.clear();
  lcd.print("POWER ON");
  lcd.setCursor(0, 1);
  delay(2000);
  lcd.clear();
  lcd.print("Macin Healthcare System");
  //lcd.setCursor(0, 1);
  //lcd.print("----------------");
  delay(3000);
  for (int h = 2; h >= 0; h--)
  {
    lcd.clear();
    lcd.setCursor(0, 1);
    lcd.print("WELCOME");
    delay(700);
    lcd.clear();
    delay(300);
  }
  lcd.clear();
  lcd.setCursor(0, 1);
  lcd.print("WEL COME");
  delay(700);
  LOCK_S = EEPROM.read(lockStsSaveLoc);
  if (isDoorOpen())
  {
    Serial.println("DOOR OPEN");
    Serial.println(LOCK_S);
    if (LOCK_S == 1)
    {
      stepCount = 0;
      doorLocked();
      timer2Setup();
      LOCK_S = 0;
      Serial.println("DOOR UNLOCK");
      Serial.println("DOOR OPEN");
    }

  }
  else
  {
    if (LOCK_S == 0)
    {
      Serial.println("DOOR unlocked");
      stepCount = 0;
      doorUnlocked();
      timer2Setup();
      LOCK_S = 1;
      Serial.println("DOOR LOCK");
      Serial.println("DOOR CLOSE");
    }
    EEPROM.write(lockStsSaveLoc, LOCK_S);
    MY_MODE = -1;

  }
}

void loop()
{
  deviceFlow();
  lcdDebug();
  delay(10);
  //pumpDirect();
}

void testSV2() //FUNCTION TO TURN ON SV2
{
  timeron();
  digitalWrite(M1, HIGH);
  digitalWrite(RL, HIGH);
  Serial.println(z);
}

void timerSetup()
{
  cli();//stop interrupts
  //set timer1 interrupt at 1Hz
  TCCR1A = 0;// set entire TCCR1A register to 0
  TCCR1B = 0;// same for TCCR1B
  TCNT1  = 0;//initialize counter value to 0
  // set compare match register for 1hz increments
  OCR1A = 7811;// = (16*10^6) / (1*1024) - 1 (must be <65536)
  /*
    // turn on CTC mode
    TCCR1B |= (1 << WGM12);
    // Set CS10 and CS12 bits for 1024 prescaler
    TCCR1B |= (1 << CS12) | (1 << CS10);
  */
  // enable timer compare interrupt
  TIMSK1 |= (1 << OCIE1A);
  sei();//allow interrupts
  countSec = 0;
}



ISR(TIMER1_COMPA_vect)
{
  flow1();
}

void flow()
{
  countSec++;
  Serial.print("T:");
  Serial.println(countSec);
  if (countSec == 1)//10
  {
    digitalWrite(RL, HIGH);//OFF

  }
  if (countSec == 5)//10
  {
    digitalWrite(SV2, LOW);//OFF
    //digitalWrite(M3, LOW);
    digitalWrite(M3, HIGH); //ON
  }
  else if (countSec == 13)  //4000
  {
    digitalWrite(SV2, HIGH );
  }
  else if (countSec == 20)  //4000
  {
    //digitalWrite(SV2, LOW ); //OFF
    digitalWrite(M1, LOW ); //OFF
  }
  else if (countSec == 33)
  {
    //digitalWrite(SV2, HIGH );
    digitalWrite(M1, HIGH );
  }
  else if (countSec == 45)  //4000
  {
    //  digitalWrite(SV2, LOW);
    digitalWrite(M3, LOW);
    digitalWrite(M1, LOW);
    if (digitalRead(LS1) == LOW)
      digitalWrite(M2, HIGH);
    else
      digitalWrite(M2, LOW);
  }
  else if (countSec == 60)
  {
    digitalWrite(M2, LOW);
    digitalWrite(SV2, HIGH );
    digitalWrite(M3, HIGH);
    digitalWrite(M1, HIGH);
  }
  else if (countSec == 75)
  {
    digitalWrite(SV2, LOW );
    digitalWrite(M3, LOW);
    digitalWrite(M1, LOW);
    digitalWrite(RL, LOW);
    timeroff();
  }

}
void flow1()
{
  
  countSec++;
  switch (countSec)
  {
    case 1:
      digitalWrite(RL, HIGH);
      break;
    case 5:
      digitalWrite(M3, HIGH);
      break;
    case 13:
      digitalWrite(SV2, HIGH );
      break;
    case 20:
      digitalWrite(M1, LOW );
      break;
    case 33:
      digitalWrite(M1, HIGH );
      break;
    case 39:
      //digitalWrite(SV2, LOW);
      break;
    case 40:
      digitalWrite(M1, LOW);
      break;
    case 45:
      digitalWrite(M3, LOW);
      if (digitalRead(LS1) == LOW)
        digitalWrite(M2, HIGH);
      else
        digitalWrite(M2, LOW);
      break;

    case 60:
      digitalWrite(M2, LOW);
      digitalWrite(M3, HIGH);
      digitalWrite(M1, HIGH);
      break;
    case 75:
      digitalWrite(M3,  LOW);
      digitalWrite(M1,  LOW);
      digitalWrite(RL,  LOW);
      digitalWrite(SV1, LOW);
      digitalWrite(SV2, LOW);
      digitalWrite(M2,  LOW);
      
      timeroff();
      break;
  }
}


void flow2()
{
  countSec++;
  //Serial.print("T:");
  //Serial.println(countSec);
  switch (countSec)
  {
    case 1:
      digitalWrite(RL, HIGH);
      break;
    case 5:
      //digitalWrite(SV2, LOW);
      digitalWrite(M3, HIGH);
      break;
    case 13:
      digitalWrite(SV2, HIGH );
      break;
    case 20:
      //digitalWrite(SV2, LOW );
      // digitalWrite(M1, LOW );
      break;
    case 33:
      //digitalWrite(SV2, HIGH );
      // digitalWrite(M1, HIGH );
      break;
    case 39:
      //digitalWrite(SV2, LOW);
      break;
    case 40:
      // digitalWrite(M1, LOW);
      break;
    case 45:
      digitalWrite(M3, LOW);
      if (digitalRead(LS1) == LOW)
        digitalWrite(M2, HIGH);
      else
        digitalWrite(M2, LOW);
      break;

    case 55:
      digitalWrite(M2, LOW);
      //digitalWrite(SV2, HIGH );
      digitalWrite(M3, HIGH);
      // digitalWrite(M1, HIGH);
      break;
    case 70:
      // digitalWrite(SV2, LOW );
      digitalWrite(M3, LOW);
      digitalWrite(M1, LOW);
      digitalWrite(RL, LOW);
      timeroff();
      break;
  }
}

void flow3()
{
  countSec++;
  //Serial.print("T:");
  //Serial.println(countSec);
  switch (countSec)
  {
      case 1:
      digitalWrite(RL, HIGH);
      break;
    case 5:
      digitalWrite(M3, HIGH);
      break;
    case 10:
      digitalWrite(SV2, HIGH);
      break;
    case 20:
      digitalWrite(SV2, LOW );
      break;
    case 30:
      digitalWrite(M1, LOW);
      break;
    case 35:
      if (digitalRead(LS1) == LOW)
        digitalWrite(M2, HIGH);
      else
        digitalWrite(M2, LOW);
      break;
    case 40:
      digitalWrite(M3, LOW);
      break;
    case 45:
      digitalWrite(M2, LOW);
      digitalWrite(M1, HIGH);
      digitalWrite(M3, HIGH);
      break;

    case 50:
      digitalWrite(SV2, HIGH);
      break;
    case 60:
      digitalWrite(M3, LOW);
      digitalWrite(M1, LOW);
      digitalWrite(SV2,LOW);
      digitalWrite(RL, LOW);
      timeroff();
      break;
  }
}
void timeron() {
  // turn on CTC mode
  TCCR1B |= (1 << WGM12);
  // Set CS10 and CS12 bits for 1024 prescaler
  TCCR1B |= (1 << CS12) | (1 << CS10);
  process = 1;
  countSec = 0;
}

void timeroff()
{
  TCCR1B = 0; //disable timer stopd unintended triggers
  process = 0;
  countSec = 0;
  BUSY = false;
  loadoff();
  MY_MODE = 3;
}


void loadoff()
{
  //z = 0;
  countSec = 0;
  digitalWrite(M1, LOW);
  digitalWrite(RL,LOW);
  digitalWrite(M3, LOW);

  if (PD_STS == false)
    digitalWrite(M2, LOW);

  BUSY = false;
  WLEVEL = false;
  FLEVEL =false;
  //digitalWrite(SV2, LOW);
}

void displaySetup()
{
  int error;
  Wire.begin();
  Wire.beginTransmission(0x27);
  error = Wire.endTransmission();
  Serial.print("Error: ");
  Serial.print(error);

  if (error == 0) {
    Serial.println(": LCD found.");

  } else {
    Serial.println(": LCD not found.");
  } // if

  lcd.begin(16, 2); // initialize the lcd
  show = 0;
}

ISR(TIMER2_COMPA_vect)
{ //timer1 interrupt 8kHz toggles pin 9
  //generates pulse wave of frequency 8kHz/2 = 4kHz (takes two cycles for full wave- toggle high then toggle low)
  if (toggle2)
  {
    digitalWrite(M_PULSE, HIGH);
    toggle2 = 0;
  }
  else
  {
    digitalWrite(M_PULSE, LOW);
    toggle2 = 1;
    stepCount++;
    //Serial.println(stepCount);
    if (stepCount == maxStep)
    {
      timer2off();
      defaultLock();
    }
  }
}

void doorLocked()
{
  digitalWrite(M_PULSE, LOW);
  digitalWrite(M_DIR, HIGH);
  digitalWrite(M_EN, HIGH);

}

void doorUnlocked()
{
  digitalWrite(M_PULSE, LOW);
  digitalWrite(M_DIR, LOW);
  digitalWrite(M_EN, HIGH);
 
}

void defaultLock()
{
  digitalWrite(M_PULSE, HIGH);
  digitalWrite(M_DIR, LOW);
  digitalWrite(M_EN, LOW);
}

void timer2Setup()
{
  cli();//stop interrupts
  //set timer2 interrupt at 8kHz
  TCCR2A = 0;// set entire TCCR2A register to 0
  TCCR2B = 0;// same for TCCR2B
  TCNT2  = 0;//initialize counter value to 0
  // set compare match register for 8khz increments
  OCR2A = 124;// = (16*10^6) / (8000*8) - 1 (must be <256)
  // turn on CTC mode
  TCCR2A |= (1 << WGM21);
  // Set CS21 bit for 128 prescaler
  TCCR2B |= (1 << CS22) | (1 << CS20);
  // enable timer compare interrupt
  TIMSK2 |= (1 << OCIE2A);
  sei();//allow interrupts
}


void timer2off()
{
  TCCR2A = 0;// set entire TCCR2A register to 0
  TCCR2B = 0;// same for TCCR2B
  TCNT2  = 0;//initialize counter value to 0
}


bool isDoorOpen()
{
  int l = analogRead(doorStatusPin);
  //Serial.println(l);
  if (l > 500)
  {
//  //Serial.println("OPEN");
  DOS = true;
  return true;
//    
   //Serial.println("CLOSED");
//   DOS = false;
//   return false;
  }
  else
  {
//    //Serial.println("CLOSED");
    DOS = false;
    return false;
    
   //Serial.println("OPEN");
//    DOS = true;
//   return true;
  }
}


bool isWaterEmpty()
{
  bool l = digitalRead(LS2);
  if (l == HIGH)
  {
    return true;//YES,WATER EMPTY
  }
  else
  {
    return false;//NO
  }
}

bool isfluidEmpty()
{
  bool FLD = digitalRead(LS1);
  if (FLD == HIGH)
  {
    return true;//YES,WATER EMPTY
  }
  else
  {
    return false;//NO
  }
}

bool isLiquidEmpty()
{
  bool l = digitalRead(LS1);
  if (l == HIGH)
  {
    return true;
  }
  else
  {
    return false;
  }
}

void deviceFlow()
{
  bool j, k, l, m, o;
  j = digitalRead(LS1);  // FLUID LEVEL
  k = digitalRead(LS2);  // WATER LEVEL
  l = isDoorOpen();      // DOOR STS
  m = isGreenKeyPressed();  // true if pressed
  o = digitalRead(START_FLOW);
  /*Serial.print(j);
    Serial.print(k);
    Serial.print(l);
    Serial.print(m);
    Serial.print(o);
    Serial.println();*/
  /* if (isWaterEmpty())
    {
     //WATER LEVEL NOT OK
     //MAKE SV1 ON
     digitalWrite(SV1, HIGH);
    }
    else
    {
     //WATER LEVEL OK
     //MAKE SV1 OFF
     digitalWrite(SV1, LOW);
    }*/

  if (l == false) //DOOR CLOSED
  {
    // DOOR CLOSED
    // JUST LOCK DOOR ONCE
    //IGNORE IF DOOR ALREADY LOCKED
    if (LOCK_S == 0)
    {
      delay(200);
      stepCount = 0;
      doorUnlocked();
      timer2Setup();
      Serial.println("LOCK");
      LOCK_S = 1;
      EEPROM.write(lockStsSaveLoc, LOCK_S);
    }
  }
  else
  {
    //DOOR OPENED
    timeroff();
    MY_MODE = -1;
    if (LOCK_S == 1)
    {
      stepCount = 0;
      doorLocked();
      timer2Setup();
      Serial.println("UNLOCK");
      LOCK_S = 0;
      EEPROM.write(lockStsSaveLoc, LOCK_S);
    }
    //LOCK_S = 0;
    //EEPROM.write(lockStsSaveLoc, LOCK_S);
    if (BUSY == true)
    {
      timeroff();
      Serial.println("CYCLE TERFMINATED");
      Serial.println("DOOR OPEN");
    }
  }
  if (BUSY == false && WLEVEL == true && l == false && LOCK_S == 1 && FLEVEL == true) //o-Start Switch,k = waterlevel,l-door closed
  {
    if (PD_STS == false)
    {
      Serial.println("FLOW STARTED");
      BUSY = true;
      MY_MODE = 1;
      //TIMER ON
    }
  }
  else if (o == false && k == true)
  {
    /* lcd.clear();
      lcd.print("Please Wait..");
      lcd.setCursor(0, 1);
      lcd.print("FILLING WATER");
      delay(300);*/

  }
  else if (o == false && l == true)
  {
    /*lcd.clear();
      lcd.print("Please,");
      lcd.setCursor(0, 1);
      lcd.print("CLOSE DOOR");
      delay(300);*/
  }


  if (isLiquidEmpty())
  {
    //FLUID LEVEL NOT OK
  }
  else
  {
    //FLUID LEVEL OK
  }

  if (m == true && BUSY == false) // m=GREEN KEY PRESSED
  {
    if (LOCK_S == 1)
    {
      stepCount = 0;
      doorLocked();
      timer2Setup();
      Serial.println("UNLOCK");
      LOCK_S = 0;
      EEPROM.write(lockStsSaveLoc, LOCK_S);
      delay(2000);
    }
    else
    {
      stepCount = 0;
      doorUnlocked();
      timer2Setup();
      // BUSY = true;
      Serial.println("LOCK");
      LOCK_S = 1;
      EEPROM.write(lockStsSaveLoc, LOCK_S);
      delay(2000);
    }

  }
}

bool isGreenKeyPressed()
{
  //Intial state HIGH
  int h = analogRead(doorLockPin);
  if (h > 200)   // NOT PRESSED
    return false;
  else   //PRESSED
    return true;
}

/*void pumpDirect()
{
  if (BUSY == false && !isDoorOpen()) //DOOR CLOSED  //DEVICE FREE
  {
    bool m = digitalRead(P_DIRECT);
    if (m == false)
    {
      digitalWrite(M1, HIGH);
      PD_STS = true;
    }
    else
    {
      digitalWrite(M1, LOW);
      PD_STS = false;
    }
  }
}
*/

void lcdDebug()
{
  if (dispCnt == dispDelay)
  {
    if (isWaterEmpty())
    {
      //WATER LEVEL NOT OK
      //MAKE SV1 ON
      digitalWrite(SV1, HIGH);
    }
    else
    {
      //WATER LEVEL OK
      //MAKE SV1 OFF
      digitalWrite(SV1, LOW);
      WLEVEL = true;
    }

    if (isfluidEmpty())
    {
      //fluid LEVEL NOT OK
      //MAKE SV2 ON
    //  digitalWrite(SV2, HIGH);
    }
    else
    {
      //WATER LEVEL OK
      //MAKE SV2 OFF
    //  digitalWrite(SV2, LOW);
      FLEVEL = true;
    }
    
    switch (MY_MODE)
    {
      case -1:
        if (WLEVEL == false && FLEVEL == false)
        {
          lcd.clear();
          lcd.print("FILLING H2o or Liq");
          if (!isDoorOpen())
          {
            lcd.setCursor(0, 1);
            lcd.print("DOOR : CLOSED");
          }
          else
          {
            lcd.setCursor(0, 1);
            lcd.print("DOOR : OPEN");
          }
        }
        
     else if (WLEVEL == true && FLEVEL == false)
        {
          lcd.clear();
          lcd.print("FILLING H2o or Liq");
          if (!isDoorOpen())
          {
            lcd.setCursor(0, 1);
            lcd.print("DOOR : CLOSED");
          }
          else
          {
            lcd.setCursor(0, 1);
            lcd.print("DOOR : OPEN");
          }
        }

   else if (WLEVEL == false && FLEVEL == true)
        {
          lcd.clear();
          lcd.print("FILLING W or F");
          if (!isDoorOpen())
          {
            lcd.setCursor(0, 1);
            lcd.print("DOOR : CLOSED");
          }
          else
          {
            lcd.setCursor(0, 1);
            lcd.print("DOOR : OPEN");
          }
        }

           else if (WLEVEL == true && FLEVEL == true)
        {
          lcd.clear();
          lcd.print("H2o and Liq OK");
          if (!isDoorOpen())
          {
            lcd.setCursor(0, 1);
            lcd.print("DOOR : CLOSED");
          }
          else
          {
            lcd.setCursor(0, 1);
            lcd.print("DOOR : OPEN");
          }
        }
        break;

      case 1:
        BUSY = true;
        for (int h = 5; h >= 0; h--)
        {
          lcd.clear();
          lcd.setCursor(0, 1);
          lcd.print("READY..   " + String(h));
          delay(700);
          lcd.clear();
          delay(300);
          countSec = 0;
        }
        testSV2();
        MY_MODE++;
        break;

      case 2:
        lcd.clear();
        lcd.print("IN PROCESS..");
        lcd.setCursor(0, 1);
        lcd.print("Time:");
        //lcd.print("S:" + String(stage) + "  TIME(S):");
        /*if (75 - countSec >= 10)
          lcd.print(75 - countSec);
          else
          {
          lcd.print("0");
          lcd.print(75 - countSec);
          }*/
        if (countSec >= 10)
          lcd.print(countSec);
        else
        {
          lcd.print("0");
          lcd.print(countSec);
        }
        break;

     

      case 3:
        for (int h = 5; h >= 0; h--)
        {
          lcd.clear();
          lcd.setCursor(0, 1);
          lcd.print(" END PROCESS");
          delay(700);
          lcd.clear();
          delay(300);
          lcd.clear();
        }
        lcd.print("END PROCESS.");
        lcd.setCursor(0, 1);
        lcd.print("OPEN DOOR");
        BUSY = false;
        digitalWrite(SV2, LOW);
        digitalWrite(SV1, LOW);

        // Activate relay on pin 6 after 75 seconds and run it for 5 seconds
        if (countSec == 75)
        {
          digitalWrite(Relay, HIGH); // Activate relay
          lcd.clear();
          lcd.print("Relay activated");
          lcd.setCursor(0, 1);
          lcd.print("Successfully");
        }
        else if (countSec == 80)
        {
          digitalWrite(Relay, LOW); // Deactivate relay after 5 seconds
        }

        while (LOCK_S == 1 || !isDoorOpen())
        {
          // Existing code...
        }

        delay(1000);

        WLEVEL = false;
        FLEVEL = false;
        MY_MODE = -1;
        process = 0;
        break;
    }
    dispCnt = 0;
  }
  else
  {
    dispCnt++;
  }
}
void resetArduino()
{
  asm volatile ("  jmp 0");
}