The IoT is the interconnection of physical objects or devices with sensors and software accessing capabilities to communicate data or information over the internet.
To build an IoT network, we need an interface medium that can fetch, control, and communicate data between sender and receiver electronics devices or servers.
Espressif Systems created the ESP32 Wi-Fi chip series. The ESP32 module is equipped with a 32-bit Tensilica microcontroller, 2.4GHz Wi-Fi connectivity, an antenna, memory, and power management modules, and much more. All of these built-in features of this ESP32 module make it ideal for IoT applications.
Hello readers, I hope you all are doing great. In this tutorial, we will learn another application of ESP32 in the field of IoT (Internet of Things). We are using a PIR sensor to detect motion and an Email alert will be generated automatically whenever a motion is being detected.
The HCSR-501 sensor module is used with ESP32 to detect the motion. So whenever a motion is detected, the PIR sensor will generate a HIGH output signal which will act as an input to the ESP32 module. In the absence of motion, the output of the PIR sensor will remain LOW. If a HIGH input signal is generated from the PIR sensor module, the LED (either peripheral or inbuilt) will be turned ON and along with that, an Email will be generated to the receiver’s email address as per the program instructions.
Software and Hardware requirements
- ESP32 development board
- HCSR-501 PIR sensor module
- Connecting Wires
- Sender’s email account details
- Receiver’s email address
- ESP-Mail-Client Library
What is HCSR-502 PIR sensor module and how does it work?
Fig. 2 PIR Motion Sensor
PIR stands for Passive Infrared sensors. It detects heat energy in the surrounding environment using a pair of pyroelectric sensors. Both sensors are placed next to each other, and when motion is detected or the signal differential between the two sensors changes, the PIR motion sensor returns a LOW result (logic zero volts). It means that in the code, you must wait for the pin to go low. The desired function can be called when the pin goes low.
There are two potentiometers available in the HCSR-501 PIR motion sensor module. One of the potentiometers is to control the sensitivity to the IR radiations. Lower sensitivity indicates the presence of a moving leaf or a small mouse. The sensitivity can be changed depending on the installation location and project specifications.
The second potentiometer is to specify the duration for which the detection output should be active. It can be programmed to turn on for as few as a few seconds or as long as a few minutes.
PIR sensors are used in thermal sensing applications such as security and motion detection. They’re commonly found in security alarms, motion detection alarms, and automatic lighting applications.
The simple mail transfer protocol (SMTP) is an internet standard for sending and receiving electronic mail (or email), with an SMTP server receiving emails from email clients.
SMTP is also used to establish server-to-server communication.
Gmail, Hotmail, Yahoo, and other email providers all have their own SMTP addresses and port numbers.
Fig. 3 SMTP
How does SMTP work?
To send emails, the SMTP protocol, also known as the push protocol, is used, and IMAP, or Internet Message Access Protocol (or post office protocol or POP), is used to receive emails at the receiver end.
The SMTP protocol operates at the application layer of the TCP/IP protocol suite.
When the client wants to send emails, a TCP connection to the SMTP server is established, and emails are sent over the connection.
- HELO – This command is sent only once per session and it is used to identify the qualified domain names and the client to the server.
- MAIL – used to initiate a message
- RCPT – Identifies the address
- DATA – This command is responsible for sharing data line by line
SMTP server parameters for email service
There are various email service providers available like, Gmail, Yahoo, Hotmail, Outlook etc. and each service provider have unique service parameters.
In this tutorial, we are using the Gmail or Google Mail service.
Gmail is the email service provided by Google and Gmail SMTP server is free to access and anyone can access this service, who has a Gmail account.
- SMTP server: smtp.gmail.com
- SMTP port: 465
- SMTP sender’s address: Gmail address
- SMTP sender’s password: Gmail Password
Create a new Gmail account (Sender)
It is recommended to create a new email account for sending emails using ESP32 or ESP8266 modules.
If you are using your main (personal) email account (for sending emails) with ESP and by mistake something goes wrong in the ESP code or programming part, your email service provider can ban or disable your main (personal) email account.
In this tutorial we are using a Gmail account.
Follow the link to create a new Gmail account : https://accounts.google.com
Fig. 4 create new gmail account
Access to Less Secure apps
To get access to this new Gmail account, you need to enable Allow less secure apps and this will make you able to send emails. The link is attached below:
Fig. 5 permission to less secure apps
Interfacing ESP32 and HCSR-501
Fig. 6 ESP32 and HCSR-501 connections
Arduino IDE Programming
We are using Arduino IDE to compile and upload code into ESP32 module. To know more about ESP32 basics, Arduino IDE and how to use it, follow our previous tutorial i.e., on ESP32 programming series. Link is given below:
To enable the email service in ESP32 it is required to download the ESP-Mail-Client Library. This library makes the ESP32 able to send email over SMTP server.
Follow the steps to install the ESP-Mail-Client library:
- Go to the link and download the ESP-Mail-Client library:
- Open your Arduino IDE.
- Then to add the ZIP file go to Sketch >> Include Library >> Add.ZIP Library and select the downloaded ZIP file.
Fig. 7 Adding ESP-Mail-Client Library
- Click on
Arduino IDE Code
//To use send Email for Gmail to port 465 (SSL), less secure app option should be enabled. https://myaccount.google.com/lesssecureapps?pli=1
//—-Add the header files
//—–define network credentials
#define WIFI_SSID “public”
#define WIFI_PASSWORD “ESP32@123”
//–add the Server address and port number with respect to a particular email service provider
#define SMTP_HOST “smtp.gmail.com”
#define SMTP_PORT esp_mail_smtp_port_587 //port 465 is not available for Outlook.com
//—-The log in credentials
#define AUTHOR_EMAIL “firstname.lastname@example.org”
#define AUTHOR_PASSWORD “Tech@ESP123”
//—-The SMTP Session object used for Email sending
//—Declare the message class
//—Callback function to get the Email sending status
void smtpCallback(SMTP_Status status);
const char rootCACert PROGMEM = “—–BEGIN CERTIFICATE—–\n”
int inputPin = 4; // connect with pir sensor pin
int pir_output = 0; // variable to store the output of PIR output
pir_output = digitalRead(inputPin);
Serial.print(“Connecting to AP”);
while (WiFi.status() != WL_CONNECTED)
Serial.println(“IP address: “);
/** Enable the debug via Serial port
* none debug or 0
* basic debug or 1
* Debug port can be changed via ESP_MAIL_DEFAULT_DEBUG_PORT in ESP_Mail_FS.h
/* Set the callback function to get the sending results */
/* Declare the session config data */
/* Set the session config */
session.server.host_name = SMTP_HOST;
session.server.port = SMTP_PORT;
session.login.email = AUTHOR_EMAIL;
session.login.password = AUTHOR_PASSWORD;
session.login.user_domain = “mydomain.net”;
/* Set the NTP config time */
session.time.ntp_server = “pool.ntp.org,time.nist.gov”;
session.time.gmt_offset = 3;
session.time.day_light_offset = 0;
/* Set the message headers */
message.sender.name = “ESP Mail”;
message.sender.email = AUTHOR_EMAIL;
message.subject = “Email Alert on Motion detection”;
“replace this with receiver email adderss”);
String textMsg = “Motion Detected!!!!!”;
message.text.content = textMsg;
message.text.charSet = “us-ascii”;
message.text.transfer_encoding = Content_Transfer_Encoding::enc_7bit;
message.priority = esp_mail_smtp_priority::esp_mail_smtp_priority_low;
/* Set the custom message header */
/* Connect to server with the session config */
if (pir_output == HIGH)
//—-Start sending Email and close the session
if (!MailClient.sendMail(&smtp, &message))
Serial.println(“Error sending Email, ” + smtp.errorReason());
Serial.println(“No Motion detected!”);
ESP_MAIL_PRINTF(“Free Heap: %d\n”, MailClient.getFreeHeap());
//to clear sending result log
/* Callback function to get the Email sending status */
void smtpCallback(SMTP_Status status)
/* Print the current status */
/* Print the sending result */
ESP_MAIL_PRINTF(“Message sent success: %d\n”, status.completedCount());
ESP_MAIL_PRINTF(“Message sent failled: %d\n”, status.failedCount());
struct tm dt;
for (size_t i = 0; i < smtp.sendingResult.size(); i++)
/* Get the result item */
SMTP_Result result = smtp.sendingResult.getItem(i);
time_t ts = (time_t)result.timestamp;
ESP_MAIL_PRINTF(“Message No: %d\n”, i + 1);
ESP_MAIL_PRINTF(“Status: %s\n”, result.completed ? “success” : “failed”);
ESP_MAIL_PRINTF(“Date/Time: %d/%d/%d %d:%d:%d\n”, dt.tm_year + 1900, dt.tm_mon + 1, dt.tm_mday, dt.tm_hour, dt.tm_min, dt.tm_sec);
ESP_MAIL_PRINTF(“Recipient: %s\n”, result.recipients);
ESP_MAIL_PRINTF(“Subject: %s\n”, result.subject);
//You need to clear sending result as the memory usage will grow up as it keeps the status, timstamp and
//pointer to const char of recipients and subject that user assigned to the SMTP_Message object.
//Because of pointer to const char that stores instead of dynamic string, the subject and recipients value can be
//a garbage string (pointer points to undefind location) as SMTP_Message was declared as local variable or the value changed.
Note: The exact code cannot be used. As a result, before uploading the code, you must make some changes such as replacing the SSID and password with your network credentials, email address of sender and receiver, SMTP setting parameters for respective email service providers, and so on. We’ll go over these details as well during the code description.
- The first step is adding the required header files or libraries.
- Here we are using two libraries:
- The first one is h, which is used to enable the Wi-Fi module and hence wireless network connectivity.
- Another library file required is the h to enable email service over SMTP (simple mail transfer protocol).
- Enter the network credentials in place of SSID and PASSWORD.
- Enter the SMTP parameter of the respective email service provider like, Gmail, Yahoo, Outlook, Hotmail etc. (In this tutorial we are using Gmail service).
- Parameters used below are for Gmail.
- Enter the sender’s email login details (email address and password ).
- Insert recipient’s email address.
- SMTPSession object is used for sending emails.
- Next step is declaring a message
- This smtpCallback() function is used to get the email sending status.
- This function also includes printing the results like success and failure of email sent.
- Next we are defining a variable to store the GPIO pin number to which the PIR sensor is to be connected.
- Next variable pir_output is used to store the current state of PIR output and initially it is fixed to zero.
Fig. 17 Variable for PIR sensor
- Initialize the serial monitor at 115200 baud rate for debugging purpose.
- Set the mode as INPUT for the GPIO pin to which PIR module is to be connected i.e., GPIO 4.
- We are using the built-in LED (LED turns ON when a motion is detected.
- The digitalRead() function is used to read the output of PIR sensor module, by passing the GPIO pin (to which PIR sensor is connected) as an argument and results will be stored inside pir_output
- begin() function is used to initialize the Wi-Fi module with Wi-Fi credentials used as arguments.
- The While loop will continuously run until the ESP32 is connected to Wi-Fi network.
- If the device is connected to local Wi-Fi network then print the details on serial monitor.
- localIP() function is used to fetch the IP address.
- Print the IP address on serial monitor using println() function.
- debug() is used to enable the debug via Serial port where ‘0’ and ‘1’ are used as arguments where;
- 0 – none debug
- 1 – basic debug
- Inside ESP_Mail_FS.h header file, ESP_MAIL_DEFAULT_DEBUG_PORT can be used to change the Debug port.
- Set the callback() function to get sending results.
- Setting session configuration includes, assigning the server address, port number of the server (here we are using Gmail services), email login details of the sender etc.
- Next step is setting the message header.
- Message header will be set inside the setup() function which includes, sender’s name, subject, sender’s email address, receiver’s email address and name.
- A string type variable textMsg is defined to to store the message to be transferred over email.
- connect() function.is used to connect to server with session configuration.
- ESP32 is continuously checking for the input from PIR sensor inside the loop function.
- If the input received from pir sensor is HIGH the ESP32 will generate an email to the client for that sendMail() function is used and if mail transmission is failed then that will be printed on the serial monitor along with the reason.
- The inbuilt LED on ESP32 will be turned ON and the respective results will be printed on the serial monitor.
Fig. 25 ‘If motion detected’
- If the input received from the PIR sensor is LOW then the LED will remain LOW/OFF and no email alert will be generated.
Fig. 25 No motion detected
- Finally, clear the email log to avoid excessive memory usage.
Fig. 26 Clear the email log
- Open the Arduino IDE.
- Paste the above code into your Arduino IDE.
- Make the required changes in the code like, network credentials, email service parameters of the respective email service provider, sender and receiver email address and define the message you want to share over SMTP server.
- Select the right development board and COM port for serial communication.
Fig. 27 select development board and COM port
- Compile and upload the program into the ESP32 development board.
- Connect the HCSR-501 module with the ESP32 as per the circuit/connect details given above.
Fig. 28 ESP32’s Inbuilt LED is turned ON when a motion is detected
- Open the serial monitor with 115200 baud rate.
Fig. 29 Serial monitor
- Check the receiver email account.
Fig.30 received email on motion detection
This concludes the tutorial. We hope you found this of some help and also hope to see you soon with a new tutorial on ESP32.