Story
The security system in Pakistan
Next evolution target
Data exchange and processing
Government can play a role
MAIN STEPS
Step 1 (connections)
Step 2 (coding)
Step 3 (setup)
STEP-BY-STEP DEMO

Published September 6, 2022 © GPL3+

Automated Door Security System

This system informs us that whenever a door is opened on our website. This system utilizes IR sensors to detect the movement of the door.

IntermediateFull instructions provided10 hours1,044

Things used in this project

Hardware components

Espressif ESP8266 ESP-12E

Modulo IR Transceiver

Software apps and online services

Grandeur

Grandeur Canvas

Microsoft VS Code

Story

Story:

As IoT is a very emerging and interactive field, we were very curious about the devices and interconnected networks which can be built using IoT. Western culture as well as some companies are trying their effort to evolve this technology. So we guys took IOT Bootcamp organized by grandeur. Our main goal was to know more about the field and after that, we made a security system that helps us to secure the targeted area with infrared sensors. When someone will come or intrude, we will be notified so that we can secure the area as soon as possible.

The security system in Pakistan:

Everyone knows that the security system in Pakistan is very insecure. This project will help us secure the private areas. Projects can be expanded in a variety of ways, for example, we can secure unsecured doors in any company. We can control it with the app in real time. We can also integrate the windows so that no flaw can be detected or intruded upon.

Next evolution target:

Our next evolution will be in the field of IoT and we will be very happy to contribute to it. So the evolution will also include the security and surveillance system. All the doors will be interconnected with each other. Security cameras will also link for monitoring who is coming inside and who is going outside. People can allow their loved ones and their crew members to come inside it easily via the app. Will be really facing a definite change in our lifestyle as we will be influenced by smart devices around us. People will have their personal smart dogs who can interact with each other and it will feel like the robots are real. Flying cars will be the norm. I want to mention that flying cars would also be using the IoT principle. The data will be shared with each other in real-time. Smart flying cars will utilize this data to analyze their surroundings and it's a bit very far into the future. The question arises that when this feature will be implemented. And the answer is when we will continuously and rigorously try to develop the ecosystem of the internet of things.

Data exchange and processing:

Right now an estimate is that in 2020, each person is having more than 3 IP-based devices in his custody and he is continuously using them. This number will definitely increase and the rate of the data which is exchanged and processed is so high that we need processing power that will process data in real-time. And also we need to extract useful information through it. The data will be coming from everywhere from your smartphones, refrigerators, air conditioners, washing machines, televisions, fans, light bulbs, smart locking doors, temperature sensors around the environment, etc. This is a whole lot of work for managing and processing this bulk amount of data.

Government can play a role:

For implementing a proper solution of internet of things devices that are interconnected and share data in real-time, the government should help Pakistan for implementing it. The government should encourage the companies and the big Giants in Pakistan to develop the appliances in such a way that the cost of the appliance should reduce but the features and the quality of the product should increase.

MAIN STEPS:

Step 1 (connections):

We use an ESP-8266(12e) board along with an HW201 IR sensor module to make our project. The sensor is powered through the board's own power output, and the input stream is directed to the pin (D4).

Step 2 (coding):

For coding, we used the VSCode IDE and the grandeur library. Create a new grandeur project through the command prompt and open the newly created INO file. The background working of our code is as follows:

> The incoming stream of values from the IR sensor is digitally

stored in a variable right in the loop() function.

> A global boolean variable is created and preset to false - this

is our flag variable to check if there was a breach. A second global

variable is created and linked with a button in the grandeur canvas.

This will be our arm/disarm switch for the security system.

> The switch variable will retrieve value from grandeur on start

> Once armed, if the IR sensor value indicates that the door was opened,

it will change the flag to true (it is not reset to false if the door

is closed again).

> Every 5 seconds, the module will update the value of the flag to

grandeur servers. If the flag is true, the user will be alerted that

there has been a breach.

> This system can be expanded by adding more flag variables and grandeur

canvas listeners for each added door, window, or another form of opening.

Step 3 (setup):

Mount the ESP-8266 board on top of the door frame (we did it with double-sided tape). Fix the position of the IR sensor at the top of the door in such a way that it's pointing downwards towards the door. Directly in front of the sensor's receptor, paste a small opaque plane element to reflect the IR beam (any color that isn't pitch black). We used paper for this although a sturdier material like a small metal plate or even cardboard can be used instead. Power the board with a power cord and wait for it to connect to the wifi. Arm the system using the grandeur canvas app and test your new DIY anti-breach home security alarm system yourself!!

STEP-BY-STEP DEMO:

PICTURE 1

PICTURE 2

Pic 1-2

The door is opened, and the system is unarmed. At this point, the system can not be armed even by pressing the button on the grandeur canvas (it will automatically revert to off until the door is closed once).

PICTURE 3

PICTURE 4

pic 3-4

The door is now closed. Now the system can be armed through the arm button. If the system is disarmed before the door is opened, the status will revert to "System Disarmed"

PICTURE 5

PICTURE 6

Pic 5-6

The door is opened without disarming the system first. The status display will show that there has been a breach. Now simply closing the door will not revert the status (to prevent a quick breaking and door closure before the breach notification is seen). The user will be expected to check out the source of the breach, disarm the system, and will only be allowed to rearm it again after the door is properly closed again.

Code

Source code for Door automation system

/* Import WIFI library */
#include <ESP8266WiFi.h>

/* Import Grandeur library */
#include <Grandeur.h>

/* Import DHT library */

#define Door1 D4
#define DHTTYPE DHT11

// DHT dht(temp, DHTTYPE);

int timestamp;

/* SSID and Password */
#define ssid "HUAWEI-geHt"
#define password "myJSNmmk"

/* Define Credentials Here */
#define deviceID "devicel7kbyp9b00d70lj1cg6igsm0" 
#define apiKey "grandeurl7kbyoe700d40lj1fm2f20oj"
#define accessToken "f0072e383e963b3d156442c2f18c2aa8ee9477ce5ec2a5b735d42fd1ae2ba043"

/* Define Grandeur Variables */
Grandeur::Project project; 
Grandeur::Project::Device device;


bool door1flag = false;
int armed = 0; 

void statusChange(bool status) {
    switch(status) {
        case CONNECTED:
          /* Device connected to the cloud */
          Serial.println("Device is connected to the cloud.");
          return;

        case DISCONNECTED:
          /* Device disconnected from cloud */
          Serial.println("Device is disconnected from the cloud.");
          return;
    }
}


char* readDoors(){


    int door1 = digitalRead(D4);
    if(armed == 1){
        if (door1 == 1){
            door1flag = true;
        }
        if(door1flag == true){
            return "There has been a breach!";
        }
        else{
            return "Secure";
        }
    }
    else{
        return "System Disarmed";
    }


    if (door1 == 1){
        return "Door Opened!!!";
    }
    else {
        return "Closed";
    }
}

/* Function to display temperature */
void displayTemp(const char* code, int temperature) {
    Serial.println(temperature);
}


void connectWifi() {
    /* Configure in WIFI client mode */
    WiFi.mode(WIFI_STA);

    /* Connect to a router */
    WiFi.begin(ssid, password);

    /* Wait for wifi to connect */
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }

    /* Print message */
    Serial.println("");
    Serial.println("WiFi connected");
}

/* Update Temperature */
void update_curr_handler(const char* code, const char* val) {
    Serial.printf("Updated value is: %s\n", val);

}

void update_armed_handler(const char* code, const char* Armed){
    armed = atoi(Armed);
    if(armed == 1){
        int doorval = digitalRead(Door1);
        if(doorval == 1){
            armed = 0;
            device.data().set("Armed", setArmed());            
        }
        else{
            door1flag = false;
        }
    }
}

/* The setup function runs once when you press reset or power the board */

void setup() {
    /* Serial for debug */
    Serial.begin(9600);

    /* Configure led pin */
    // pinMode(temp, INPUT);

    /* Connect to wifi */
    connectWifi();

    /* Connect to Grandeur server */
    project = grandeur.init(apiKey, accessToken);

    /* Detect connection status */
    project.onConnection(statusChange);

    /* Get reference to device */
    device = project.device(deviceID);

    device.data().on("door1val", update_curr_handler);
    device.data().on("Armed", update_armed_handler);
    device.data().get("Armed", updateHandler);
    /* Start timer */
    /* Number of milliseconds passed since the program started */
    timestamp = millis();
}

void updateHandler(const char* path, const char* Armed) {
    /* Converting from string to int */
    armed = atoi(Armed);

    /* Print state */
    Serial.printf("Updated state is %d\n", armed);

    /* Update pin level */
    digitalWrite(LED_BUILTIN, !armed);
}


/* The loop function runs over and over again forever */
void loop() {
    if (millis() - timestamp > 3000) {  
        
         /* Sending data to grandeur cloud */
        device.data().set("door1val", readDoors());  
        timestamp = millis();
    }
int door1val = digitalRead(Door1);
Serial.println(door1val);

    delay(10);
    project.loop();
}

int setArmed(){
    return armed;
}

Credits

Haseeb Haider

1 project • 1 follower

Grandeur Technologies

9 projects • 54 followers

Simplifying IoT dev; abridging that huge gap between our softwares and hardwares.

Automated Door Security System