String data;




// Pinout of Inputs  + means Positive Required
// Item Name          Code Pins    Type          MCU Pins
// Bluetooth            0,1         I/O          2,3
// Relay                 +2         Out
// Buzzer                +3         Out
// Door Sensor         -/+4         In
// White LED             +5         Out
// KEY Led               +6         Out
// Motion                +7         In
// High Tone             +8         Out
// Red   LED             +9         Out
// Green LED            +10         Out
// Blue  LED            +11         Out
// Low Tone             +12         Out
// Hard Key Status       A0         In
// Light Sensor          A1         In


// All Input 
const int   DRI  =  4;   // Door Sensing  Input
const int   MSI  =  7;   // Motion Sensor Input
const int   LSI  = A1;   // Light  Sensor Input 
const int   KSI  = A0;   // Key   Status  Input
// All Output
const int   DSPR  = 9;    // Display Light RED
const int   DSPG  = 10;   // Display Light Green
const int   DSPB  = 11;   // Display Light Blue       
const int   DSPW  = 5;    // Display Light White
const int   KLED  = 6;    // key Led
const int   Bzr   = 3;    // Buzzer
const int   Rly   = 2;    // Relay.
const int   HTA   = 8;    // High Tone Alarm
const int   LTA   = 12;   // Low  Tone Alarm
const int   TL    = 13;   // Test Led Build in


// Door Sataus Defining
int EDRI;     // Enable Door Status input
int DRSS;     // Door Sense Status (HIgh or Low) means Normally Door Open or Close
int EDSA;     // Enable Door Status Alarm
int EDAS;     // Enable Door Alarm Sound
int CDS = 0;    // Current  Door Status
int PDS = 0;    // Previous Door Status
int LMS = 1;    // Lock Motion Sensor on Alarm
int DTS;        // Door Tone Sound
int DAUT = 250; // Door Alarm Up Tone
int DADT = 150; // Door Alarm Down Tone
int CDSS;       // Current Door Status Define HIGH or LOW
int DDSS = 0;   // Door Display State Status ( Open/Close/Alarm)
int PDDS = 0;   // Perivous Door Display State


// Motion Sensor Input
int EMS;        // Enable Motion Sensor
int MSS;        // Motion Sensor Sound
int MTS;        // Motion Tone Sound
int MST;        // Motion Sensor Trugger
int MTD;        // Motion Trugger Delay
int DMS;        // Disable Motion Sensor over Open Door
int CMS = 0;    // Current Motion State
int FMS = 0;    // Final Motion State
int MDSS =0;    // Motion Display Status State
int PMDS =0;    // Previous Motion Display Status

// Light can be redifined as per user requirment 
int MSL;   // Motion Sensor Light 
int DSL;   // Door Signal Light
int DAL;   // Door Alarm Light
int DSP;   // Display Light Normal
int EDSP;  // Enable Display Light
int LTS;   // Light Tone Sound



// Hard Key Reading Status
int EHKR  = 1;     // Enable Hardkey Reading
int EHKS;          // Enable HardKey Sound
int EHKT;          // Enable Hardkey Truggered
int HKTD;          // Kardkey Truggred Delay
int HKDL;          // Hardkey Display Light
int CHKR  = 0;     // Current Hardkey Reading
int PHKR  = 0;     // Previous Hardkey Reading
int HKRL  = 0;     // Hardkey Reading Limit
int HKCS;          // Hardkey Current Status
int PHKS;          // Perivous Hardkey Status


// Time Farm Counting
long unsigned int CRT;             // Current Running Time
long unsigned int DTT  = 0;        // Door  Trugger TIme
long unsigned int FTT  = 0;        // Final Trugger Time
long unsigned int HKCT = 0;        // Hardkey Current Time
long unsigned int HKTT = 5000;     // Hardkey Truggered Time
long unsigned int DSAW = 5000;     // Door Sensor Alarm Wait


// Light Sensor defining
int ELS;           // Enable Light Sensor
int LSL;           // Light Sensor Limit
int CLS;           // Current Light Sensor Status
int KGlow   = 0;   // Light Sensor LED Brightness
int DGlow   = 0;   // Display Led Brightness
int Dspeed  = 10;  // Display Led Brightness Speed
int Kspeed  = 10;  // Light Sensor Led Brightness Speed

void Alarm()
{
 if (EDAS == true && CRT - DTT >= DSAW && CDS == CDSS) // EDoor Alarm Sound/CurrentDor status = CurntDoorStatus State
{
digitalWrite(Bzr, HIGH);
digitalWrite(DAL, HIGH);
digitalWrite(DTS, HIGH);
digitalWrite(KLED, LOW);
delay(DAUT);
digitalWrite(Bzr, LOW);
digitalWrite(DAL, LOW);
digitalWrite(DTS, LOW);
digitalWrite(KLED, HIGH);
delay(DADT);
}
if (EDAS == false && CRT - DTT >= DSAW && CDS == CDSS)
{
digitalWrite(DAL, HIGH);
delay(DAUT);
digitalWrite(DAL, LOW);
delay(DADT);
}
}

// Key Led Advance Functions FIXED to conditions 
void Fade()
{
if (ELS == true && CLS <=LSL)
{ analogWrite(KLED, KGlow);
  KGlow = KGlow + Kspeed;
  if (KGlow <= 0 || KGlow >= 250) 
  { Kspeed = -Kspeed; }
  analogWrite(DSP, DGlow);
  DGlow = DGlow + Dspeed;
  if (DGlow >= 250 || DGlow <= 0) 
  { Dspeed = -Dspeed; }
  
  delay(20); }
}



void setup() 
{
  pinMode(DRI,   INPUT_PULLUP);     // Door       Sensor
  pinMode(MSI,   INPUT);            // Motion     Sensor
  pinMode(LSI,   INPUT_PULLUP);     // Light      Sensor
  pinMode(KSI,   INPUT_PULLUP);     // key        Sensor
  pinMode(DSPR,  OUTPUT);
  pinMode(DSPB,  OUTPUT);
  pinMode(DSPW,  OUTPUT);
  pinMode(Bzr,   OUTPUT);
  pinMode(DSPG,  OUTPUT);
  pinMode(Rly,   OUTPUT);
  pinMode(KLED,  OUTPUT);
  pinMode(HTA,   OUTPUT);
  pinMode(LTA,   OUTPUT);
  pinMode(TL,    OUTPUT);
  Serial.begin(9600);

// Default Blink LED Display
// All connections will go high to low for define duration to test Display
digitalWrite(DSPR, HIGH);
digitalWrite(DSPB, HIGH);
digitalWrite(DSPW, HIGH);
digitalWrite(DSPG, HIGH);
digitalWrite(Bzr, HIGH);
digitalWrite(KLED, HIGH);
digitalWrite(HTA, HIGH);
digitalWrite(LTA, HIGH);
digitalWrite(Rly, HIGH);
digitalWrite(TL, HIGH);
delay(100);
digitalWrite(DSPR, LOW);
digitalWrite(DSPB, LOW);
digitalWrite(DSPW, LOW);
digitalWrite(DSPG, LOW);
digitalWrite(Bzr, LOW);
digitalWrite(KLED, LOW);
digitalWrite(HTA, LOW);
digitalWrite(LTA, LOW);
digitalWrite(Rly, LOW);
digitalWrite(TL, LOW);



// Default Settings
EDRI = 1;   // Enable Door Input
EDSA = 1;   // Enable Door Status Alarm
EDAS = 1;   // Enable Door Alarm Sound
EDSP = 1;   // Enable Display Light Normal

EMS  = 1;       // Enable Motion Sensor
MSS  = 1;       // Motion Sensor Sound
MTD =  250;     // Motion Trugger Delay
MSL  = DSPG;    // Motion Sensor Light
DSL  = DSPB;    // Door Signal Light
DAL  = DSPR;    // Door Alarm  Light 
DSP  = DSPW;    // Display Light
MST  = Rly;     // Motion Sensor Trugger
MTS  = HTA;     // Define Motion Sensor Tone 
DTS  = HTA;     // Define Door Alarm Tone
CDSS = LOW;    // Current Door State Status

// Hard Key Reading Status
EHKR  = 1;         // Enable Hardkey Reading
EHKS  = 3;         // Enable HardKey Sound
EHKT  = 2;         // Enable Hardkey Truggered
HKTD  = 250;       // Kardkey Truggred Delay
HKDL  = DSPG;      // Hardkey Display Light
CHKR  = 0;         // Current Hardkey Reading
PHKR  = 0;         // Previous Hardkey Reading
HKRL  = 500;       // Hardkey Reading Limit
LSL = 700;         // Light Sensor Limit
ELS = 1;           // Enable Light Sensor

}


void loop()
{

// Define Combination of Dual Funcation to Toggle 13 Pin led as switch functions for Bluetooth power source.
if ( CMS == true && HKCS == "KP" && HKCT >=HKTT )
{
  if ( digitalRead(TL == HIGH))
  { digitalWrite(TL, LOW);}
  else 
  {
    digitalWrite(TL, HIGH);
  }
}






// Defing HardKey Reading Function
if ( EHKR == true)
{ CHKR = analogRead(KSI);
  if ( CHKR != PHKR)
{ HKCS = "KR";
 if ( CHKR <= HKRL )
{ 
digitalWrite(EHKS, HIGH);
digitalWrite(EHKT, HIGH);
digitalWrite(HKDL, HIGH);
digitalWrite(DSP, LOW);
delay(HKTD);
digitalWrite(EHKS, LOW);
digitalWrite(EHKT, LOW);
digitalWrite(HKDL, LOW);
HKCS = "KP";
}
}
delay(15);
PHKR = CHKR;
}

// HardKey Action Display
if ( HKCS != PHKS )
{ if ( HKCS == "KP")
{ Serial.println("Key Pres");}
else if ( HKCS == "KR")
{ Serial.println("Key Rld");}
delay(15);
PHKS = HKCS;
}


// Door Action Display Section 
if( DDSS != PDDS )
{ if( DDSS == "DRO")
{Serial.println("Door Open");}
else if( DDSS == "DRC")
{Serial.println("Door Close");}
else if( DDSS == "DRA")
{Serial.println("Door Alarm");}
delay(15);
PDDS = DDSS;
}
// Motion Sensor Display Section
if ( MDSS != PMDS)
{ if (MDSS == "MT")
{ Serial.println("Mtn Trgd");}
else if(MDSS == "MR")
{ Serial.println("Mtn Relsd");}
else if (MDSS == "M")
{Serial.println("Mtn Detd");}
delay(15);
PMDS = MDSS;
}



 // Motion Sensor Conditon and configuration
if (EMS == true)    // Enable Motion Senor Input
{  CMS = digitalRead(MSI);
if ( CMS == HIGH)
{ MDSS = "MT";}
if (CMS == LOW)
{ MDSS = "MR";}
if ( CMS != FMS)
{
  if(CMS == HIGH && DMS != true && MSS != true)
{
  digitalWrite(DSP, LOW);
  digitalWrite(MSL, HIGH);
  digitalWrite(MST, HIGH);
  digitalWrite(KLED, LOW);
   delay(MTD);
  digitalWrite(MSL, LOW);
  digitalWrite(MST, LOW);
}
 if(CMS == HIGH && DMS != true && MSS == true)
{
  digitalWrite(DSP, LOW);
  digitalWrite(MSL, HIGH);
  digitalWrite(MST, HIGH);
  digitalWrite(MTS, HIGH);
  digitalWrite(Bzr, HIGH);
  digitalWrite(KLED, LOW);
  {MDSS = "M";}
   delay(MTD);
  digitalWrite(MSL, LOW);
  digitalWrite(MST, LOW);
  digitalWrite(MTS, LOW);
  digitalWrite(Bzr, LOW);
}
}
delay(10);
FMS = CMS;
}


// Door Sensor Configuration & Conditions
  CRT = millis();
  if ( EDRI == true)
  { CDS = digitalRead(DRI); }

   if (CDS != PDS) 
  { 
    if (CDS == CDSS) 
    {
      DTT = millis();
      digitalWrite(DSL, HIGH);
        DDSS = "DRO";
    } 
    else 
    {
      digitalWrite(DSL, LOW);
      DDSS = "DRC";
    }
    delay(50);
  }
 FTT = CRT - DTT;

if(EDSA == true)
{
if( FTT >= DSAW && CDS == CDSS)
  {
    digitalWrite(DAL, HIGH);
    digitalWrite(DSL, LOW);
    digitalWrite(DSP, LOW); 
  }
  else if( CDS != CDSS)
  {
    digitalWrite(DAL, LOW);
    DTT = 0;
    FTT = 0;
  }
if (EDAS == true && CRT - DTT >= DSAW && CDS == CDSS)
{
digitalWrite(DSP, LOW);
DDSS = "DRA";
Alarm();
}
else if ( EDAS == false && CRT - DTT >= DSAW && CDS == CDSS)
{ DDSS = "DRA";                 // Updating Display Status of Door Conition to Door Alarm
  Alarm();}                     // Alarm Truggered Porcess
else
{ digitalWrite(Bzr, LOW); }     // Sounder Off
}
if (CDS == CDSS && LMS == true) // Over Locking Motion Sensor on Alarm
{ DMS = 1;}
else
{ DMS = 0;}                     // Releasing Motion Sensor 
PDS = CDS;                      // Last Motion Sensor Condition Updating


// Define Conditions when Light Sensor match its limit
// K led is PWM based/ can fade in out if dark detect
if ( ELS == true)         // Enable Light Sensor
{ CLS = analogRead(LSI);} // Current Light Sensor status/Light Sensor Input
if ( CLS <= LSL)          // if Current Light Sensor is Greater/smaller then Light Sensor Limit
{ Fade();}
else
{  digitalWrite(KLED, LOW);}



if(CDS == CDSS && EDSP == true) // Display light shifting during Door light/ CrntDoorState & EnbleDisplight
{ digitalWrite(DSP, LOW);}      // Downing Display light to Light up Door Status light
else if( EDSP == true)          // Defing Display light to up if enable else keep low in normal
{  digitalWrite(DSP, HIGH); }
else
{ digitalWrite(DSP, LOW); }






while(Serial.available()) {
    delay(10);
    char c=Serial.read();
    if(c=='#')
    {break; }
    data += c;
}

if (data.length() > 0) 
{
  // Light Sensor Feedback & Configuration details
if (data =="Lstatus" )
{
  Serial.print(F("Enable Light Sensor=  "));   Serial.println(ELS);   // Enable Light Sensor
  Serial.print(F(" Light Sensor Limit=  "));   Serial.println(LSL);   // Light Sensor Limit
  Serial.print(F("Current Light Sensor = "));  Serial.println(CLS);   // Current Light Sensor Reading
  }
if( data =="ELS0")       // Disable Light Sensor 
{ELS =false;}
if (data == "ELS1")      // Enable Light Sensor
{ELS =true;}
if( data =="LSL0")       // Light Sensor Limit defult
{LSL =100;}
if( data =="CLS")        // Display Current Light sensor Reading 
{Serial.println(CLS);}
if( data =="LSL1")
{Serial.println(F("L Sensor Limit"));
while (Serial.available()==0){}
LSL = Serial.parseInt();
if (LSL != 0)
Serial.print(F("LSL Ok")); } // Defining Light Sensor Reading 


// Door Sensing Configuration
if (data =="Dstatus" )
{
  Serial.print(F("Enable Door Sensor =  "));          Serial.println(EDRI);   // Enable Light Sensor
  Serial.print(F("Enable Door Status Alarm =  "));    Serial.println(EDSA);   // Light Sensor Limit
  Serial.print(F("Enable Door Alarm Sound = "));      Serial.println(EDAS);   // Current Light Sensor Reading
  Serial.print(F("Lock Motion Sensor = "));           Serial.println(LMS);    // Light Sensor Task 1
  Serial.print(F("Current Door Status = "));          Serial.println(CDS);    // Light Sensor Task 2  
}
if(data == "CDDSS") // will display Door current state weather its Open/Close or Alarm state
{Serial.println(DDSS);}
if(data== "EDRI")
{ Serial.println(EDRI);}
if(data == "EDRI0")       // Disable Door Sensor 
{EDRI = false;}
if (data == "EDRI1")      // Enable Door Sensor
{EDRI = true;}
if(data == "EDSA0")       // Disable Door Status Alarm
{EDSA = false;}
if(data == "EDSA1")       // Enable  Door Status Alarm 
{EDSA = true;}
if(data =="EDAS0")        // Disable Door Alarm Sound
{EDAS = false;}
if(data =="EDAS1")        // Enable  Door Alarm Sound
{EDAS = true;}
if(data =="LMS0")         // UnLock Motion Sensor on Alarm
{LMS = false;}
if(data =="LMS1")         // Lock Motion Sensor on Alarm
{LMS = true;}
if(data == "DSAW")        // Get Delay Alarm on Open Door
{Serial.println(F(" Door Alarm wait Time is "));
 Serial.println(DSAW);}
if(data == "DSAW1")
{Serial.println(F("Door Alarm wait Time = "));
while (Serial.available()==0){}
DSAW = Serial.parseInt();
if (DSAW != 0)
Serial.print(F("DSAW Ok")); } // Defining Door Sense Alarm Wait 


// Motion Sensor Configuration
if (data =="Dstatus" )
{
  Serial.print(F("Enable Motion Sensor =  "));        Serial.println(EMS);   // Enable Motion Sensor
  Serial.print(F("Enable Motion Sound =  "));         Serial.println(MSS);   // Enable Motion Sensor Sound
  Serial.print(F("Enable Motion Truggered = "));      Serial.println(MST);   // Enable Motion Sensor Trugger
  Serial.print(F("Motion Truggered Delay = "));       Serial.println(MTD);   // Define Motion Sensor Truggered Delay
  Serial.print(F("Disable Motion Sensor Lock = "));   Serial.println(DMS);   // Disable Motion Sensor Lock  
}
if(data == "EMS0")       // Disable Door Sensor 
{EMS = false;}
if (data == "EMS1")      // Enable Door Sensor
{EMS = true;}
if(data == "MSS0")       // Disable Door Status Alarm
{MSS = false;}
if(data == "MSS1")       // Enable  Door Status Alarm 
{MSS = true;}
if(data =="MST0")        // Disable Door Alarm Sound
{MST = false;}
if(data =="MST1")        // Enable  Door Alarm Sound
{MST = true;}
if(data =="DMS0")         // UnLock Motion Sensor on Alarm
{DMS = false;}
if(data =="DMS1")         // Lock Motion Sensor on Alarm
{DMS = true;}
if(data == "MTD")        // Get Delay Alarm on Open Door
{Serial.println(F(" Motion Truggered Delay is "));
 Serial.println(MTD);}
if(data == "MTD1")
{Serial.println(F("Motion Truggered Delay = "));
while (Serial.available()==0){}
MTD = Serial.parseInt();
if (MTD != 0)
Serial.print(F("MTD Ok")); } // Defining Door Sense Alarm Wait 


// Light Configuration 
if ( data == "LIGHT")
{
  Serial.print(F("Motion Sensor Light = "));          Serial.println(MSL);     // Motion Sensor light
  Serial.print(F("Door Signal Light =  "));           Serial.println(DSL);     // Door Signal Light
  Serial.print(F("Door Alarm Light = "));             Serial.println(DAL);     // Door Alarm Light
  Serial.print(F("Normal Display Light = "));         Serial.println(DSP);     // Light Sensor Task 1
  Serial.print(F("Enable Display Light = "));         Serial.println(EDSP);    // Light Sensor Task 2  
  Serial.print(F("Door Tone Sound = "));              Serial.println(DTS);     // Door   Tone Sound 
  Serial.print(F("Motion Tone Sound = "));            Serial.println(MTS);     // Motion Tone Sound 
  Serial.print(F("Light Tone SOund = "));             Serial.println(LTS);     // Light  Tone Sound 
}
if(data == "DSP0")       // Disable Display Light 
{EDSP = false;}
if(data == "DSP1")       // Enable Dispaly Light 
{EDSP = true;}
if(data == "DTS0")       // Set Door Tone Sound to LOW
{DTS = false;}
if(data == "DTS1")       // Set Door Tone Sound to HIGH
{DTS = true; }
if(data == "MTS0")       // Motion Tone Sound to LOW
{MTS = false; }
if(data == "MTS1")       // Motion Tone Sound to HIGH
{MTS =  true; }
if(data == "LTS0")       // Light Tone Sound to LOW
{LTS = false; }
if(data == "LTS1")       // Light Tone Sound to HIGH
{LTS = true;}
if(data == "MSL")
{Serial.println(F("Motion Sensor Light = "));
while (Serial.available()==0){}
MSL = Serial.parseInt();
if (MSL != 0)
Serial.print(F("MSL Ok")); } // Defining Motion Sense Light
if(data == "DSL")
{Serial.println(F("Door Signal Light = "));
while (Serial.available()==0){}
DSL = Serial.parseInt();
if (DSL != 0)
Serial.print(F("DSL Ok")); } // Defining Door Sense Light
if(data == "DAL")
{Serial.println(F("Door Alarm Light = "));
while (Serial.available()==0){}
DAL = Serial.parseInt();
if (DAL != 0)
Serial.print(F("DAL Ok")); } // Defining Door Alarm Light
if(data == "DSP")
{Serial.println(F("Display Light = "));
while (Serial.available()==0){}
DSP = Serial.parseInt();
if (DSP != 0)
Serial.print(F("DSP Ok")); } // Display Light Normal

}
data = "";
}