//________________________SMART HOME_______________________//
//MADE BY :
//EL KATOURI NOSSAIR
//EL KOUNE   MOHAMED
//DECEMBER 2023
//_________________________________________________________//
//-----------------------------------------------------------
//=================================================> BLYNK <=
//-----------------------------------------------------------



//-----------------------------------------------------------
//==================================================> WIFI <=
//-----------------------------------------------------------



//-----------------------------------------------------------
//=============================================> DOOR LOCK <=
//-----------------------------------------------------------

//=======================> KEYPAD :
//DEFINING___________________________________________________
#include <Keypad.h>        //Includ the library of the keypad
#define KEYPAD_ROWS    4              //We use all the 4 rows
#define KEYPAD_COLUMNS 3        //Just 3 clumns gonna be used
byte rowPins[KEYPAD_ROWS] = { 16, 4, 0, 2};  //R1, R2, R3, R4
byte columnPins[KEYPAD_COLUMNS] = { 15, 8, 7};   //C1, C2, C3
char KEYS[KEYPAD_ROWS][KEYPAD_COLUMNS] = {  
  { '1', '2', '3'},
  { '4', '5', '6'},
  { '7', '8', '9'},
  { '*', '0', '#'} };      //Defining each button's character
Keypad KEYPAD = Keypad(makeKeymap(KEYS), rowPins, columnPins,
KEYPAD_ROWS, KEYPAD_COLUMNS);          //Create KEYPAD object
//VARIABLES AND FUNCTIONS ___________________________________
byte CODE_PREVIOUS_STATE = 0;
byte CODE_STATE          = 1;
byte CODE_COUNTER        = 0;
char PASS_CODE[4]  = { '1', '1', '1', '1'};
char CHECK_CODE[4] = { '0', '0', '0', '0'};

//=======================>  SCREEN :
//DEFINING___________________________________________________
#include <LiquidCrystal_I2C.h>    //The library of the screen
#define I2C_ADDRESS 0x27                    //The i2c address
#define LCD_ROWS    4         //How many rows the screen have
#define LCD_COLUMNS 20     //How many columns the screen have
LiquidCrystal_I2C SCREEN(I2C_ADDRESS, LCD_COLUMNS, 
LCD_ROWS);                             //Create SCREEN object

//=======================>  SERVO :
//DEFINING___________________________________________________
#include <ESP32Servo.h>     //Includ the library of the servo
#define DOOR 13
Servo   DOOR_SERVO;                //Create DOOR_SERVO object
//VARIABLES AND FUNCTIONS____________________________________
byte lock_position = 0;
byte unlock_position = 90;



//-----------------------------------------------------------
//===============================================> KITCHEN <=
//-----------------------------------------------------------

//=======================> WINDOW :
//DEFINING___________________________________________________
#define KITCHEN_WINDOW 14
Servo   KITCHEN_SERVO;
//VARIABLES AND FUNCTIONS ___________________________________
bool KLS = 0;                           //Kitchen light state
int GAS_VALUE = 0;

//=======================> LIGHT AND SWITCH :
#define KITCHEN_LIGHT        9
#define KITCHEN_LIGHT_SWITCH 35

//=======================> GAZ SENSOR :
#define GAS_SENSOR 26


//-----------------------------------------------------------
//===========================================> LIVING_ROOM <=
//-----------------------------------------------------------

//=======================> WINDOW :
#define LIVING_ROOM_WINDOW 12
Servo   LIVING_ROOM_SERVO;

//=======================> LIGHT AND SWITCH :
#define LIVING_ROOM_LIGHT        10
#define LIVING_ROOM_LIGHT_SWITCH 32



//-----------------------------------------------------------
//==============================================> BATHROOM <=
//-----------------------------------------------------------

//=======================> LIGHT AND SWITCH :
#define BATHROOM_LIGHT        17
#define BATHROOM_LIGHT_SWITCH 33



//-----------------------------------------------------------
//===============================================> BERROOM <=
//-----------------------------------------------------------

//=======================> WINDOW AND SWITCHS :
#define BEDROOM_WINDOW 27
Servo   BEDROOM_SERVO;
#define BEDROOM_WINDOW_SWITCH_UP 34
#define BEDROOM_WINDOW_SWITCH_DOWN 5

//=======================> LIGHT AND SWITCH :
#define BEDROOM_LIGHT        19
#define BEDROOM_LIGHT_SWITCH 18

//=======================> DHT22 SENSOR :
#include "DHT.h"
#define DHT_TYPE DHT22
#define DHT_PIN 25
DHT dht(DHT_PIN, DHT_TYPE);



//-----------------------------------------------------------
//==================================================> TIME <=
//-----------------------------------------------------------
unsigned long CURRENT_TIME;
unsigned long CODE_PREVIOUS_TIME;















//><><><><><><><><><><><><> SET UP <><><><><><><><><><><><>//
void setup(){
//================================================> SERIAL <=
Serial.begin(115200);
Serial.println("SMART HOME PROJECT");
//=================================================> BLYNK <=
//Blynk.begin(auth, ssid, pass);
//==================================================> WIFI <=
//=============================================> DOOR LOCK <=
//SCREEN :
SCREEN.init();
//SERVO :
DOOR_SERVO.attach(DOOR, 500, 2400);
//===============================================> KITCHEN <=
//SERVO :
KITCHEN_SERVO.attach(KITCHEN_WINDOW, 500, 2400);
//LIGHT :
pinMode(KITCHEN_LIGHT, OUTPUT);
pinMode(KITCHEN_LIGHT_SWITCH, INPUT);
attachInterrupt(digitalPinToInterrupt(KITCHEN_LIGHT_SWITCH),
KITCHEN_INTERRUPT, RISING);
//GAS SENSOR :
pinMode(GAS_SENSOR, INPUT);
//===========================================> LIVING_ROOM <=
//SERVO :
LIVING_ROOM_SERVO.attach(LIVING_ROOM_WINDOW, 500, 2400);
//LIGHT :
pinMode(LIVING_ROOM_LIGHT, OUTPUT);
pinMode(LIVING_ROOM_LIGHT_SWITCH, INPUT);
//==============================================> BATHROOM <=
//LIGHT :
pinMode(BATHROOM_LIGHT, OUTPUT);
pinMode(BATHROOM_LIGHT_SWITCH, INPUT);
//===============================================> BERROOM <=
//SERVO :
BEDROOM_SERVO.attach(BEDROOM_WINDOW, 500, 2400);
pinMode(BEDROOM_WINDOW_SWITCH_UP,   INPUT);
pinMode(BEDROOM_WINDOW_SWITCH_DOWN, INPUT);
//LIGHT :
pinMode(BEDROOM_LIGHT, OUTPUT);
pinMode(BEDROOM_LIGHT_SWITCH, INPUT);
//DHT22 :
dht.begin();
}







//><><><><><><><><><><><><> FUNCTIONS <><><><><><><><><><><//
void KITCHEN_INTERRUPT() {
  KLS = !KLS;
}









//><><><><><><><><><><><><><> LOOP <><><><><><><><><><><><>//
void loop(){
//SPEED UP THE SIMULATION____________________________________
delay(10);
//UPDATE TIME________________________________________________
CURRENT_TIME = millis();



//-----------------------------------------------------------
//=============================================> DOOR LOCK <=
//-----------------------------------------------------------

//===================> MAKE DECISIONS <====================//
if(CODE_STATE != CODE_PREVIOUS_STATE){
  switch (CODE_STATE) {
  case 0://______________________________________Sleep mode
    DOOR_SERVO.write(lock_position);
    SCREEN.clear();
    SCREEN.noBacklight();
    CODE_PREVIOUS_STATE = CODE_STATE;
    break;
  case 1://__________________________________Enter the code
    DOOR_SERVO.write(lock_position);
    SCREEN.clear();
    SCREEN.backlight();
    SCREEN.setCursor(2, 0);
    SCREEN.print("ENTER THE CODE :");
    SCREEN.setCursor(7, 1);
    SCREEN.print("[----]");
    SCREEN.setCursor(0, 2);
    SCREEN.print("* : reset");
    SCREEN.setCursor(0, 3);
    SCREEN.print("# : enter");
    CODE_PREVIOUS_TIME  = CURRENT_TIME;
    CODE_PREVIOUS_STATE = CODE_STATE;
    break;
  case 2://____________________________________Welcome home
    DOOR_SERVO.write(unlock_position);
    SCREEN.clear();
    SCREEN.setCursor(6, 1);
    SCREEN.print("WELCOME");
    SCREEN.setCursor(8, 2);
    SCREEN.print("HOME");
    CODE_PREVIOUS_TIME = CURRENT_TIME;
    CODE_PREVIOUS_STATE = CODE_STATE;
    break;
  case 3://______________________________________Wrong code
    SCREEN.clear();
    SCREEN.setCursor(7, 1);
    SCREEN.print("WRONG");
    SCREEN.setCursor(6, 2);
    SCREEN.print("PASSCODE");
    CODE_PREVIOUS_TIME = CURRENT_TIME;
    CODE_PREVIOUS_STATE = CODE_STATE;
    break;
  }}
//==========> UPDATE THE STATE : check the time <===========//
if(CODE_STATE != 0){
  //_____________________From state 1 to state 0 (sleep mode)
  if( CODE_STATE == 1 && 
      CURRENT_TIME - CODE_PREVIOUS_TIME >= 10000UL)
  {
    CODE_STATE = 0;
  }
  //__________________________________From state 2 to state 1
  if( CODE_STATE == 2 &&
      CURRENT_TIME - CODE_PREVIOUS_TIME >= 3000UL)
  {
    CODE_STATE = 1;
  }
  //__________________________________From state 3 to state 1
  if( CODE_STATE == 3 && 
      CURRENT_TIME - CODE_PREVIOUS_TIME >= 1000UL)
  {
    CODE_STATE = 1;
  }
}
//==========> UPDATE THE STATE : check the key <===========//
char key = KEYPAD.getKey();
if( key != NO_KEY ){
  //__________________________________From state 0 to state 1
  if( CODE_STATE == 0 && key == '#' ){
    CODE_STATE = 1;
  }
  //_____________________________________Enter x Reset x Code
  else if( CODE_STATE == 1 ){
    switch ( key ) {
    case '#'://________________________________Case 1 : enter
      if( CODE_COUNTER == 4 ){
        if( CHECK_CODE[0] == PASS_CODE[0]&&
            CHECK_CODE[1] == PASS_CODE[1]&&
            CHECK_CODE[2] == PASS_CODE[2]&&
            CHECK_CODE[3] == PASS_CODE[3])
        {
          CODE_STATE   = 2;
          CODE_COUNTER = 0;
        }else{
          CODE_STATE   = 3;
          CODE_COUNTER = 0;
        }
      }
      CODE_PREVIOUS_TIME = CURRENT_TIME;
      break;
    case '*'://________________________________Case 2 : reset
      CODE_COUNTER = 0;
      SCREEN.setCursor(8, 1);
      SCREEN.print("----");
      CODE_PREVIOUS_TIME = CURRENT_TIME;
      break;
    default://___________________Default Case : enter a number
      if(CODE_COUNTER < 4){
        CHECK_CODE[CODE_COUNTER] = key;
        SCREEN.setCursor(8 + CODE_COUNTER, 1);
        SCREEN.print("*");
        CODE_COUNTER++;
        CODE_PREVIOUS_TIME = CURRENT_TIME;
      }
      break;
    }
  }
}
//___________________________________________________________





//-----------------------------------------------------------
//===============================================> KITCHEN <=
//-----------------------------------------------------------

//========================> LIGHT <========================//
//MAKE DECISION______________________________________________
digitalWrite(KITCHEN_LIGHT, KLS);
//UPDATE THE STATE : check blynk_____________________________

//========================> WINDOW <=======================//

//=========================> GAS <=========================//
GAS_VALUE = analogRead(GAS_SENSOR);
GAS_VALUE = map(GAS_VALUE,0,4096,0,100);
if(GAS_VALUE >= 30){
  digitalWrite(KITCHEN_LIGHT, HIGH);
}
//___________________________________________________________





//-----------------------------------------------------------
//===========================================> LIVING_ROOM <=
//-----------------------------------------------------------
//___________________________________________________________



//-----------------------------------------------------------
//==============================================> BATHROOM <=
//-----------------------------------------------------------
//___________________________________________________________



//-----------------------------------------------------------
//===============================================> BERROOM <=
//-----------------------------------------------------------
//___________________________________________________________
}