Voice Connection based Security system with ESP8266 and Arduino for IoT in Home Automation

Hardware setup and Circuit Design

The circuit is built using ESP8266 module, PIR sensor, ISD1820 voice module and a 12V adapter provides power to the whole circuit. There is also two voltage regulators and LM317 for 3.3V and an LM7805 for 5V. These are necessary to power ESP8266 and other consumables. Here’s a breakdown of the circuit design:

Power Regulation: The 200Ω, 330Ω resistor combination is connected to configure the LM317 regulator to output 3.3V and LM7805 regulator output 5V to ISD1820 and PIR sensors. The regulators are powered from a 12V adapter.

PIR and Voice Module Control:

The PIR sensor and ISD1820 module are powered ON and OFF via a BC547 transistor and a current limiting resistor at GPIO 2 of the ESP8266.

The input pin connected from the PIR sensor’s Dout pin using a BC547 transistor is the GPIO 0. Should motion be detected, it will read the GPIO 0 high and send an email alert via the ESP8266.

Transistor Switches: The ESP8266 pin outputs are limited, so we use transistors to drive the modules. Also, there are switches to disconnect the modules temporarily from power up to prevent entering a reset loop.

How to build an Email API with IFTTT

The project makes use of the IFTTT (If This Then That) service in order to send email notifications that can be automated through predefined triggers. Here’s how to create an API using IFTTT:

Log in to your IFTTT account.

Search the “Maker Webhooks” service to connect to Webhooks.

Start with Gmail and let’s connect and grant the permissions.

Make an Applet, set the action (This) to Webhooks. Pass in an appropriate event name (e.g., “intrusion_detected”).

That action is set to Gmail. Craft your custom email subject and body text that lets the user know that there was an intrusion.

Take the API url under Webhooks documentation and copy it. We will use this URL in the Arduino code to trigger an email.

The Arduino Code and System functionnality

Using the PIR sensor as the input, it is monitored by ESP8266 programmed with Arduino IDE. If motion is detected, it will trigger the ISD1820 module to say whatever it recorded and make an HTTP GET request to the IFTTT API URL to send an email notification. Here’s a high-level outline of the code functionality:

Sensor and modules initializations.

Using the ESP8266 connect to a Wi-Fi.

Run a PIR sensor’s output, and play a recorded message when motion is detected.

To get an email alert, can trigger a HTTP GET request to IFTTT URL.

Advantages and Use Cases

This IoT-based security system offers several benefits:

Remote monitoring: Using the ESP8266, the system can be remotely armed and disarmed over the internet.

Personalized alerts: The ISD1820 can record your custom warning messages.

Affordable and scalable: The system is cost effective and can be further rendered with additional sensors and notifications.

This paper presents an IoT based Security System using Arduino and ESP8266.

The ability to remotely control and monitor your home alarm system using a simple web interface using an IoT security system controlled with Arduino and the ESP8266 module. The ESP8266 microcontroller is leveraged to operate in Access Point (AP) and Station (STA) modes within the project. The driving interface is a web page that users can visit to ARM or DISARM the system using the ESP8266 which acts as the main controller and ‘makes the connection’.

In this article, we will follow through the project and talked about some of the major asses of how to configure Arduino and ESP8266, how to design the user interface in the form of HTML, and how we can handle actions from the user interface considering the alarm states as well. And we’ll discuss the code, and explain each part, so you can understand it, and modify it.

Step 1: On the ESP8266 side, I configure ESP8266 as AP and STA.

For the project, the ESP8266 works as Access Point and Station. This allows you to set up the module itself to form a local Wi-Fi network to communicate with connected devices while also being able to connect to external networks for cloud based integration.char* ssid = “BPAS home”; // Put your WiFi SSID here.e ESP8266 module, PIR sensor, and ISD1820 voice module, all powered by a 12V adapter. The setup also includes two voltage regulators—an LM317 for 3.3V and an LM7805 for 5V. These are essential for powering the ESP8266 and other components. Here’s a breakdown of the circuit design:

Power Regulation: The LM317 regulator is configured to output 3.3V using a combination of 200Ω and 330Ω resistors, and the LM7805 regulator provides 5V output for the ISD1820 and PIR sensor. A 12V adapter powers the regulators.

PIR and Voice Module Control:

GPIO 2 of the ESP8266 is used to control the power to the PIR sensor and ISD1820 module through a BC547 transistor and a current-limiting resistor.

GPIO 0 serves as the input pin connected to the PIR sensor’s Dout pin through a BC547 transistor. When motion is detected, GPIO 0 reads a high signal, triggering an email alert via the ESP8266.

Transistor Switches: The output current of the ESP8266 pins is limited, so transistors are used to drive the modules. Additionally, switches are added to disconnect the modules temporarily during power-up to avoid entering a reset loop.

Building an Email API with IFTTT

To send email notifications, the project leverages the IFTTT (If This Then That) service, which can automate tasks based on predefined triggers. Here’s how to create an API using IFTTT:

Log in to your IFTTT account.

Connect to Webhooks by searching for the “Maker Webhooks” service.

Connect to Gmail and provide the necessary permissions.

Create a new Applet and set the trigger (This) to Webhooks. Use a relevant event name (e.g., “intrusion_detected”).

Set the action (That) to Gmail. Create a custom email subject and body text indicating an intrusion.

Copy the API URL provided under Webhooks documentation. This URL will be used in the Arduino code to trigger an email.

Arduino Code and System Operation

The ESP8266, programmed using the Arduino IDE, monitors the output from the PIR sensor. When motion is detected, it triggers the ISD1820 module to play the recorded voice and sends an HTTP GET request to the IFTTT API URL to dispatch an email notification. Here’s a high-level outline of the code functionality:

Initialize sensors and modules.

Connect to Wi-Fi using the ESP8266.

Monitor PIR sensor output and play the recorded message when motion is detected.

Trigger an HTTP GET request to the IFTTT URL to send an email alert.

Advantages and Use Cases

This IoT-based security system offers several benefits:

Remote monitoring: The system can be armed and disarmed remotely over the internet using the ESP8266.

Personalized alerts: You can record custom warning messages using the ISD1820.

Affordable and scalable: The system is cost-effective and can be expanded to include additional sensors and notifications.

Implementing an IoT-Based Security System Using Arduino and ESP8266

Creating an IoT-based security system using Arduino and ESP8266 enables remote monitoring and control over your home’s alarm system through a simple web interface. The project leverages the ESP8266 microcontroller, which is configured to operate in both Access Point (AP) and Station (STA) modes. The ESP8266 acts as the main controller and establishes a Wi-Fi connection, allowing users to access a web page to ARM or DISARM the system.

In this article, we’ll explore the project, focusing on the key aspects of configuring Arduino and ESP8266, designing a user interface using HTML, and implementing actions based on alarm states. We will discuss the code and explain each segment to provide clarity and enable modifications.

Step 1: Configuring the ESP8266 as AP and STA

In the project, the ESP8266 acts as both an Access Point and Station. This enables the module to establish a local Wi-Fi network for communication with connected devices, while also being able to connect to external networks for cloud-based integration.

Setting Up Wi-Fi Credentials

The following lines of code are crucial for configuring the Wi-Fi connection:

const char* ssid = “BPAS home”;  // Enter your Wi-Fi SSID here

cout <<“Password is : “<< const char* password = “cracksen”; //Enter your password here ;

Change the ssd and password to a value of your choice (to match your router’s credentials). This allows for an ESP8266 to join your network.

To get the ESP8266’s IP Address.

The following code segment should be used to find the ESP8266’s IP address which has been assigned to it. This helps in determining the URL for accessing the webpage interface:

the Serial.print(“Connected to “);

Serial.println(ssid);

Serial.print(“IP address: “);

It’s all quite legal, although the Arduino specifically states the Serial.println(WiFi.localIP()); line above may be slow to respond, as it must wait for the WiFi module to answer.

The module will show the IP address that it got from the router through accessing the Arduino IDE’s Serial Monitor. To access alarm control page from browser, this IP address will be used.

Step 2: The Webpage using HTML

The sim solution is next, and consists of designing a simple webpage using HTML as the user interface to control the alarm system. You can make the webpage your own way. Below is an example of a basic HTML structure:

mainPage += “<h1 align=\”center\”>IoT-based Security System</h1>”;

mainPage += “<h2 align=\”center\”>-CircuitDigest</h2>”;

mainPage += “<h1 align=\”center\”><p>Alarm Status: “;

mainPage += “<a href=\”switch2On\”><button>ARM</button></a>&nbsp;”;

mainPage += “<a href=\”switch2Off\”><button>DISARM</button></a></p>”;

feedback = “<h3 align=\”center\”>Click on ARM to enable the security system</h3>”;

This HTML code creates a webpage with buttons to ARM or DISARM the system. You can add more features or customize the appearance by editing this segment.

Step 3: Programming Actions for ARM and DISARM

When users click on the ARM or DISARM buttons, specific actions are executed based on the URL path. The following code snippets demonstrate the implementation:

server.on(“/switch2On”, [](){

    feedback = “<h3 align=\”center\”>Alarm is up and running</h3>”;

    currentPage = mainPage + feedback;

    server.send(200, “text/html”, currentPage);

    currentPage = “”;

    digitalWrite(GPIO_2, HIGH); // Turn on PIR and Voice module

    power_module = true;

    delay(1000);

});

server.on(“/switch2Off”, [](){

    feedback = “<h3 align=\”center\”>Alarm is down</h3>”;

    currentPage = mainPage + feedback;

    server.send(200, “text/html”, currentPage);

    currentPage = “”;

    digitalWrite(GPIO_2, LOW); // Turn off PIR and Voice Module

    power_module = false;

    delay(1000);

});

In this section, when the ARM button is clicked, it triggers the /switch2On URL, which executes the following actions:

• Updates the webpage feedback message to indicate that the alarm is active.
• Sets GPIO 2 to HIGH, which turns on connected modules such as the PIR sensor and Voice Module.
• Waits for a second to ensure the changes are applied.

Conversely, the /switch2Off URL turns off the GPIO pin and updates the webpage to indicate that the alarm is now disabled.

Integrating with IFTTT

A crucial part of the project is integrating the security system with IFTTT (If This Then That). This allows sending notifications or performing specific actions based on alarm triggers. You’ll need an IFTTT webhook URL, which you can obtain from the IFTTT website.

String url = “/trigger/123/with/key/mDsoOV_EERS3xRfrh3_UQBhbcx0qlRHns-z2qXXXXX”; // Use your own IFTTT URL

This line sends a request to the IFTTT webhook when the alarm is triggered, enabling email notifications or SMS alerts based on your settings.

Step 4: Uploading the Code to ESP8266

It is quite easy, as we can use many ways such as using the Arduino IDE, or using the Python in MicroPython.

After all the hardware ready and the code done uploading to the ESP8266 via the Arduino IDE and FTDI board. If you find the upload is problematic then reset the module and try again. Once the file is uploaded open the Serial Monitor to confirm that the ESP8266 is connected to Wi-Fi and displaying its IP address.

Testing and working of the security system

Once you’ve successfully uploaded the program, you can plug the ESP8266 onto a perf board and power it up. Check the connection status and obtain you ip address using serial monitor. Once you’ve done that, go to the webpage using the IP address and you will see the ARM and DISARM buttons.

Enabling the system lets the PIR sensor learn in around 50-60 seconds. After those it is ready to detect motion. Once the intruder enters the sensor’s range an audio alert is triggered and an email is sent to your registered ID through IFTTT with the time and date stamp of the event.

Conclusion and Summary of Project

This Arduino and ESP8266 project allows us to remotely control a security system via the most efficient, simple and affordable manner i.e without requiring an expensive, extra, small machine. With the flexibility of Arduino and ESP8266 connectivity features, combining these two can give you a smart home solution that’s cost effective but easily customizable. By using basic HTML-based webpage interface, it is easy to remote control the robot and integration with services like IFTTT allows its functionality to be improved with alerts and notifications.

If you have any questions or feedback about this project do share it in the comments below, I’ll be glad to help! Also, make sure to check out the video below to see how this project actually works completed. Happy building!

/*Program for : IOT based Security system system with Voice warning

BY ElectroGlobal  */

 

#include <ESP8266WiFi.h>

#include <WiFiClient.h>

#include <WiFiClientSecure.h>

#include <ESP8266WebServer.h>

#include <ESP8266mDNS.h>


MDNSResponder mdns;


boolean trigger_sms = false;

boolean power_module = false;



const char* ssid = "BPAS home";  //Enter you Wifi SSID here

const char* password = "cracksen"; //Enter your password here


 


ESP8266WebServer server(80);


String mainPage = ""; //The default page

String feedback = ""; //Gives staus of the switch

String currentPage = ""; //Combines main and feedback page


int GPIO_0 = 0; //Pin defanition

int GPIO_2 = 2; //Pin defanition


void setup(void){

  //HTML code for webpage//

  mainPage += "<h1 align=\"center\">IOT based security System</h1><h2 align=\"center\">-CircuitDigest</h2><h1 align=\"center\"><p>Alarm Status: <a href=\"switch2On\"><button>ARM</button></a>&nbsp;<a href=\"switch2Off\"><button>DISARM</button>  </a></p>";

  feedback = "<h3 align=\"center\">Click on ARM to enable the security system</h3>";

  //End of HTML code//

  currentPage = mainPage+feedback;

  

  // preparing GPIOs

  pinMode(GPIO_0, INPUT); //feeded by PIR sensor

  pinMode(GPIO_2, OUTPUT); //used to turn on PIR and Voice module

  digitalWrite(GPIO_2, LOW);

  

  delay(1000);

  Serial.begin(115200);

  WiFi.begin(ssid, password);

  Serial.println("");


  // Wait for connection

  while (WiFi.status() != WL_CONNECTED) {

    delay(500);

    Serial.print(".");

  }

  // config static IP



  Serial.println("");

  Serial.print("Connected to ");

  Serial.println(ssid);

  Serial.print("IP address: ");

  Serial.println(WiFi.localIP()); //Serial monitor will give the IP addrss of your ESP module

  

  if (mdns.begin("esp8266", WiFi.localIP())) {

    Serial.println("MDNS responder started");

  }

  

  server.on("/", [](){

    currentPage = mainPage+feedback;

    server.send(200, "text/html", currentPage);

    currentPage = "";

  });



  

  server.on("/switch2On", [](){

    feedback = "<h3 align=\"center\">Alarm is up and running </h3>"; //HTML code modification

    currentPage=mainPage+feedback;

    server.send(200, "text/html", currentPage);

    currentPage="";

    digitalWrite(GPIO_2, HIGH); //Turn on PIR and Voice module

    power_module=true;

    delay(1000);

  });

  server.on("/switch2Off", [](){

    feedback = "<h3 align=\"center\">Alarm is down</h3>"; //HTML code modification 

    currentPage=mainPage+feedback;

    server.send(200, "text/html", currentPage);

    currentPage="";

    digitalWrite(GPIO_2, LOW); //Turn off PIT and Voice Module

    power_module=false;

    delay(1000); 

  });



  server.begin();

  Serial.println("IOT security system is up and running");

}


//Function to send an E-mail//

void send_Email()

{

const char* host = "maker.ifttt.com"; //The host of API URL will be the same for all

const int httpsPort = 443;


   WiFiClientSecure client;

  Serial.print("connecting to ");

  Serial.println(host);

  if (!client.connect(host, httpsPort)) {

    Serial.println("connection failed");

    return;

  }


 


  String url = "/trigger/123/with/key/mDsoOV_EERS3xRfrh3_UQBhbcx0qlRHns-z2qXXXXX"; //Must change it to your API URL

  Serial.print("requesting URL: ");

  Serial.println(url);


  client.print(String("GET ") + url + " HTTP/1.1\r\n" +

               "Host: " + host + "\r\n" +

               "User-Agent: BuildFailureDetectorESP8266\r\n" +

               "Connection: close\r\n\r\n");


  Serial.println("request sent");

  while (client.connected()) {

    String line = client.readStringUntil('\n');

    if (line == "\r") {

      Serial.println("headers received");

      break;

    }

  }

  String line = client.readStringUntil('\n');


  Serial.println("reply was:");

  Serial.println("==========");

  Serial.println(line);

  Serial.println("==========");

  Serial.println("closing connection");

}

//Function to send an E-mail


 

void loop(void){

  server.handleClient();


  if (digitalRead(GPIO_0==HIGH) && power_module==true)

  trigger_sms=true;

  else

  trigger_sms=false;

  

  if (trigger_sms==true)

  {

    send_Email(); //If the PIR module is powered and if a person is detected send a E-mail

    trigger_sms=false;

    delay(2000);

  }

  

}