Arduino ESP8266 Internet of things

Smart gas leak detection system with Arduino

11-05-21 3422

Presentation of gas leak detection system

A gas leak detection system is a system that is used to detect the presence of gas leaks in a specific area. These systems can be used in a variety of settings, such as homes, commercial buildings, and industrial facilities, to detect leaks in gas pipelines, tanks, and other equipment.

Gas leak detection systems typically consist of a combination of sensors and control equipment. The sensors are used to detect the presence of gas in the air, while the control equipment is used to process the sensor data and trigger an alarm or other response in the event of a gas leak.

There are several types of gas sensors used in gas leak detection systems. These include:

Infrared sensors, which detect gas based on the absorption of infrared radiation.
Catalytic bead sensors, which detect gas based on a chemical reaction between the gas and a catalytic bead.
Metal oxide semiconductor sensors, which detect gas based on a change in electrical resistance.

Once a gas leak is detected, the control equipment can trigger an alarm or other response, such as shutting off the gas supply to the affected area, activating ventilation systems, or alerting emergency responders.

Gas leak detection systems can also be integrated with building management systems, providing real-time monitoring and control of gas levels.

In summary, a gas leak detection system is a system that detects the presence of gas leaks in a specific area, and triggers an alarm or other response when a leak is detected. The system is composed of sensors and control equipment, and can be integrated with building management systems for real-time monitoring and control.

A gas leak detection system integrated with IoT (Internet of Things) technology is a type of system that uses sensors to detect the presence of gas in the air, and then transmits sensor data to a remote monitoring station over a network using IoT devices, such as gateways and cloud-based platforms. This allows for real-time monitoring and control of gas levels from a remote location.

In an IoT gas leak detection system, the sensors are placed at strategic locations to detect the presence of gas. These sensors typically detect the concentration of gas in the air and transmit this data to a central control system. This system can then process the sensor data and trigger an alarm or other response in the event of a gas leak. The control system can also send alerts to a remote monitoring station, allowing for real-time monitoring of gas levels from a remote location.

IoT gas leak detection systems can also provide additional features such as remote control, real-time notifications, and historical data analysis. By using IoT technology, the system can be monitored and controlled from a remote location, and data can be analyzed to identify patterns and trends over time.

IoT gas leak detection systems can be used in a variety of settings, such as homes, commercial buildings, and industrial facilities. They can be integrated with building management systems, providing real-time monitoring and control of gas levels, and can also be integrated with other IoT devices to create an interconnected smart environment.

In summary, a gas leak detection system integrated with IoT technology is a type of system that uses sensors to detect the presence of gas in the air and transmits sensor data to a remote monitoring station over a network using IoT devices, allowing for real-time monitoring and control of gas levels from a remote location. It also provides additional features such as remote control, real-time notifications, and historical data analysis, and can be integrated with other IoT devices to create an interconnected smart environment.

Presentation of Intelligent gas leak detection system with Arduino

An Arduino-based gas leak detection system integrated with IoT (Internet of Things) technology is a type of system that uses sensors to detect the presence of gas in the air, and then transmits sensor data to a remote monitoring station over a network using IoT devices, such as gateways and cloud-based platforms, while using an Arduino microcontroller to process the sensor data and trigger an alarm or other response in the event of a gas leak.

The Arduino board is a microcontroller board that can be easily integrated with sensors and other electronic components, making it a suitable option for gas leak detection system. The Arduino can be programmed to read data from the gas sensor and process the information, while the IoT device, such as ESP8266, can be used to connect the system to a WiFi network and transmit data to a remote server or other device.

Once a gas leak is detected, the Arduino can trigger an alarm or other response, such as activating ventilation systems, or alerting emergency responders via the IoT device. The system can also send data to a remote server for monitoring and analysis.

This type of system provides many benefits such as remote monitoring and control, real-time notifications and historical data analysis. The Arduino provides a powerful and flexible platform for advanced projects, and the integration with IoT technology allows for scalable and flexible solutions.

Purpose of this project :

In this project we will realize a gas leak detection system controlled by the Arduino board connected to the Internet.

It mainly uses MQ-4 gas sensor, when the sensor detects gas leak, the Arduino board will send alert email by WIFI.

Necessary components

Arduino UNO

The Arduino UNO is a microcontroller board based on the ATmega328P. It has 14 digital input/output pins, 6 analog inputs, a 16 MHz quartz crystal, a USB connection, a power jack, an ICSP header, and a reset button. The Arduino UNO is programmed using the Arduino software (IDE), which is available for Windows, Mac, and Linux. The board can be powered by an external power supply or by USB. It is compatible with a wide range of sensors, actuators, and other devices, which can be connected to it using a variety of communication protocols, such as I2C, SPI, and UART. The Arduino UNO is a popular choice for beginners and hobbyists, as it is easy to use and has a large community of users and developers

MQ-4 gaz sensor

The MQ-4 gas sensor is a type of gas sensor that is used to detect the presence of methane (CH4) gas. It is a highly sensitive sensor that can detect methane gas concentrations as low as 200ppm (parts per million). It is often used in applications such as natural gas leakage detection, home gas leak alarms, and industrial process control.

The MQ-4 sensor consists of a sensing element, typically made of tin dioxide (SnO2), that is sensitive to methane gas. When methane gas is present, it is adsorbed by the sensing element, which causes a change in the electrical resistance of the element. This change in resistance is then converted into a corresponding output signal that can be read by a microcontroller or other electronic device.

The MQ-4 sensor has a fast response time and a long service life, making it a suitable option for gas leak detection. The sensor also has a wide operating temperature range and it can be used in both indoor and outdoor applications.

The sensor typically interfaces with a microcontroller, such as an Arduino or Micro:bit, and can be programmed to trigger an alarm or other response when a gas leak is detected. It also can be integrated with IoT devices to provide remote monitoring and control of gas levels and real-time notifications.

ESP8266 wifi

ESP8266 is a low-cost Wi-Fi microcontroller chip with full TCP/IP stack and microcontroller capability. It is produced by Espressif Systems, a Chinese manufacturer. It can be used to add Wi-Fi connectivity to devices such as microcontrollers, and it is often used in Internet of Things (IoT) projects.

The ESP8266 chip includes a 32-bit processor, flash memory, and a built-in Wi-Fi module, making it a complete solution for adding Wi-Fi connectivity to a device. It can be easily integrated with a microcontroller, such as an Arduino or a Micro:bit, and can be programmed using a variety of programming languages, such as C, C++, and Python.

The ESP8266 can be used in a variety of projects, such as wireless sensor networks, home automation systems, and web-connected devices. It can be programmed to connect to a Wi-Fi network, send and receive data, and interact with other devices over the Internet. The chip has a very small form factor and low power consumption, making it ideal for battery-powered devices.

In summary, the ESP8266 is a popular, low-cost, and versatile Wi-Fi module that can be used to add wireless connectivity to a variety of devices and projects. It offers a complete solution for IoT projects, and its small form factor and low power consumption make it ideal for battery-powered applications.

Connecting wires

Connecting wires refer to the process of connecting two or more electrical wires together in order to transmit electrical signals or power from one device to another. This can be done using a variety of methods and techniques, depending on the type of wire and the application.

Test plate

A test plate is used to include the flame sensor module, as well as connectors and other components to interface the sensor with the Micro:bit. It may also include LEDs, buttons or other input/output devices to test the functionality of the sensor and the microcontroller. The test plate allows for easy testing and validation of the sensor and the Makecode that is used to interact with it.

Mounting

To perform the assembly, you can connect:

for the MQ-4 sensor:

pin DO to pin A0 of the Arduino board
the VCC pin to the 5V pin of the Arduino board
the GND pin to the GND pin of the Arduino board

For ESP8266 module :

The RX pin to pin 4 of the Arduino board
The TX pin to pin 3 of the Arduino board
The GND pin to the GND of the Arduino board
The two pins 3V3 and EN to the 5V pin of the power supply module
The RST pin to pin 8 of the Arduino board the two pins 3V3 and EN to the 5V pin of the power supply module

Program:

Here is the program of the intelligent gas leak detection system connected to the Internet:

#include <Adafruit_ESP8266.h>

#include <SoftwareSerial.h>

#define ESP_RX 3
#define ESP_TX 4
#define ESP_RST 8
SoftwareSerial softser(ESP_RX, ESP_TX);

// Must declare output stream before Adafruit_ESP8266 constructor; can be
// a SoftwareSerial stream, or Serial/Serial1/etc. for UART.
Adafruit_ESP8266 wifi(&softser, &Serial, ESP_RST);
// Must call begin() on the stream(s) before using Adafruit_ESP8266 object.

#define ESP_SSID “*************” // Your network name here
#define ESP_PASS “*************” // Your network password here

char EMAIL_FROM[] = “adresse email de l’émetteur”;
char EMAIL_PASSWORD[] = “************”;
char EMAIL_TO[] = “adresse email du récepteur”;
char SUBJECT[] = “My ESP8266”;
char EMAIL_CONTENT[] = “Attention!!! ,\r\n il y a un feu .”;

// We’ll need your EMAIL_FROM and its EMAIL_PASSWORD base64 encoded, you can use https://www.base64encode.org/
#define EMAIL_FROM_BASE64 “bm9yZXBseUBtZXNhcnRpc2Fucy5mcg==”
#define EMAIL_PASSWORD_BASE64 “WVlMdVhKelphVg==”

#define HOST “Nom du serveur SMTP” // Find/Google your email provider’s SMTP outgoing server name for unencrypted email

#define PORT 587 // Find/Google your email provider’s SMTP outgoing port for unencrypted email

int count = 0; // we’ll use this int to keep track of which command we need to send next
bool send_flag = false; // we’ll use this flag to know when to send the email commands
int analogPin = A0; // Capteur de gaz MQ-4 analog interface
int analogVal; //analog readings

void setup() {
pinMode(btnPin,INPUT_PULLUP);
char buffer[50];

// This might work with other firmware versions (no guarantees)
// by providing a string to ID the tail end of the boot message:

// comment/replace this if you are using something other than v 0.9.2.4!
wifi.setBootMarker(F(“Version:0.9.2.4]\r\n\r\nready”));

softser.begin(9600); // Soft serial connection to ESP8266
Serial.begin(57600); while(!Serial); // UART serial debug

Serial.println(F(“Adafruit ESP8266 Email”));

// Test if module is ready
Serial.print(F(“Hard reset…”));
if(!wifi.hardReset()) {
Serial.println(F(“no response from module.”));
for(;;);
}
Serial.println(F(“OK.”));

Serial.print(F(“Soft reset…”));
if(!wifi.softReset()) {
Serial.println(F(“no response from module.”));
for(;;);
}
Serial.println(F(“OK.”));

Serial.print(F(“Checking firmware version…”));
wifi.println(F(“AT+GMR”));
if(wifi.readLine(buffer, sizeof(buffer))) {
Serial.println(buffer);
wifi.find(); // Discard the ‘OK’ that follows
} else {
Serial.println(F(“error”));
}

Serial.print(F(“Connecting to WiFi…”));
if(wifi.connectToAP(F(ESP_SSID), F(ESP_PASS))) {

// IP addr check isn’t part of library yet, but
// we can manually request and place in a string.
Serial.print(F(“OK\nChecking IP addr…”));
wifi.println(F(“AT+CIFSR”));
if(wifi.readLine(buffer, sizeof(buffer))) {
Serial.println(buffer);
wifi.find(); // Discard the ‘OK’ that follows

Serial.print(F(“Connecting to host…”));

Serial.print(“Connected..”);
wifi.println(“AT+CIPMUX=0”); // configure for single connection,
//we should only be connected to one SMTP server
wifi.find();
wifi.closeTCP(); // close any open TCP connections
wifi.find();
Serial.println(“Type \”send it\” to send an email”);

} else { // IP addr check failed
Serial.println(F(“error”));
}
} else { // WiFi connection failed
Serial.println(F(“FAIL”));
}
}

void loop() {

if(!send_flag){ // check if we expect to send an email
// Read the analog interface
analogVal = analogRead(analogPin);
if (analogVal<=60)  // If the sensor detects a gas leak

{
send_flag = true;  // sending an alert email

//Serial.println(btnVal);
delay(1000);
}
}

if(send_flag){ // the send_flat is set, this means we are or need to start sending SMTP commands
if(do_next()){ // execute the next command
count++; // increment the count so that the next command will be executed next time.
}
}
}

// do_next executes the SMTP command in the order required.
boolean do_next()
{

switch(count){
case 0:
Serial.println(“Connecting…”);
return wifi.connectTCP(F(HOST), PORT);
break;
case 1:
// send “HELO ip_address” command. Server will reply with “250” and welcome message
return wifi.cipSend(“HELO computer.com”,F(“250”)); // ideally an ipaddress should go in place
// of “computer.com” but I think the email providers
// check the IP anyways so I just put anything.
break;
case 2:
// send “AUTH LOGIN” command to the server will reply with “334 username” base 64 encoded
return wifi.cipSend(“AUTH LOGIN”,F(“334 VXNlcm5hbWU6”));
break;
case 3:
// send username/email base 64 encoded, the server will reply with “334 password” base 64 encoded
return wifi.cipSend(EMAIL_FROM_BASE64,F(“334 UGFzc3dvcmQ6”));
break;
case 4:
// send password base 64 encoded, upon successful login the server will reply with 235.
return wifi.cipSend(EMAIL_PASSWORD_BASE64,F(“235”));
break;
case 5:{
// send “MAIL FROM:<emali_from@domain.com>” command
char mailFrom[50] = “MAIL FROM:<“; // If 50 is not long enough change it, do the same for the array in the other cases
strcat(mailFrom,EMAIL_FROM);
strcat(mailFrom,”>”);

return wifi.cipSend(mailFrom,F(“250”));
break;
}
case 6:{
// send “RCPT TO:<email_to@domain.com>” command
char rcptTo[50] = “RCPT TO:<“;
strcat(rcptTo,EMAIL_TO);
strcat(rcptTo,”>”);
return wifi.cipSend(rcptTo,F(“250”));
break;
}
case 7:
// Send “DATA” command, the server will reply with something like “334 end message with \r\n.\r\n.”
return wifi.cipSend(“DATA”,F(“354”));
break;
case 8:{
// apply “FROM: from_name <from_email@domain.com>” header
char from[100] = “FROM: “;
strcat(from,EMAIL_FROM);
strcat(from,” “);
strcat(from,”<“);
strcat(from,EMAIL_FROM);
strcat(from,”>”);
return wifi.cipSend(from);
break;
}
case 9:{
// apply TO header
char to[100] = “TO: “;
strcat(to,EMAIL_TO);
strcat(to,”<“);
strcat(to,EMAIL_TO);
strcat(to,”>”);
return wifi.cipSend(to);
break;
}
case 10:{
// apply SUBJECT header
char subject[50] = “SUBJECT: “;
strcat(subject,SUBJECT);
return wifi.cipSend(subject);
break;
}
case 11:
return wifi.cipSend(“\r\n”); // marks end of header (SUBJECT, FROM, TO, etc);
break;
case 12:
return wifi.cipSend(EMAIL_CONTENT);
break;
case 13:
return wifi.cipSend(“\r\n.”); // marks end of data command
break;
case 14:
return wifi.cipSend(“QUIT”);
break;
case 15:
wifi.closeTCP();
return true;
break;
case 16:
Serial.println(“Done”);
send_flag = false;
count = 0;
return false; // we don’t want to increment the count
break;
default:
break;
}
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

#include <Adafruit_ESP8266.h>

#include <SoftwareSerial.h>

#define ESP_RX 3

#define ESP_TX 4

#define ESP_RST 8

SoftwareSerial softser(ESP_RX, ESP_TX);

// Must declare output stream before Adafruit_ESP8266 constructor; can be

// a SoftwareSerial stream, or Serial/Serial1/etc. for UART.

Adafruit_ESP8266 wifi(&softser, &Serial, ESP_RST);

// Must call begin() on the stream(s) before using Adafruit_ESP8266 object.

#define ESP_SSID “*************” // Your network name here

#define ESP_PASS “*************” // Your network password here

char EMAIL_FROM[] = “adresse email de l’émetteur”;

char EMAIL_PASSWORD[] = “************”;

char EMAIL_TO[] = “adresse email du récepteur”;

char SUBJECT[] = “My ESP8266”;

char EMAIL_CONTENT[] = “Attention!!! ,\r\n il y a un feu .”;

// We’ll need your EMAIL_FROM and its EMAIL_PASSWORD base64 encoded, you can use https://www.base64encode.org/

#define EMAIL_FROM_BASE64 “bm9yZXBseUBtZXNhcnRpc2Fucy5mcg==”

#define EMAIL_PASSWORD_BASE64 “WVlMdVhKelphVg==”

#define HOST “Nom du serveur SMTP” // Find/Google your email provider’s SMTP outgoing server name for unencrypted email

#define PORT 587 // Find/Google your email provider’s SMTP outgoing port for unencrypted email

int count = 0; // we’ll use this int to keep track of which command we need to send next

bool send_flag = false; // we’ll use this flag to know when to send the email commands

int analogPin = A0; // Capteur de gaz MQ-4 analog interface

int analogVal; //analog readings

void setup() {

pinMode(btnPin,INPUT_PULLUP);

char buffer[50];

// This might work with other firmware versions (no guarantees)

// by providing a string to ID the tail end of the boot message:

// comment/replace this if you are using something other than v 0.9.2.4!

wifi.setBootMarker(F(“Version:0.9.2.4]\r\n\r\nready”));

softser.begin(9600); // Soft serial connection to ESP8266

Serial.begin(57600); while(!Serial); // UART serial debug

Serial.println(F(“Adafruit ESP8266 Email”));

// Test if module is ready

Serial.print(F(“Hard reset…”));

if(!wifi.hardReset()) {

Serial.println(F(“no response from module.”));

for(;;);

}

Serial.println(F(“OK.”));

Serial.print(F(“Soft reset…”));

if(!wifi.softReset()) {

Serial.println(F(“no response from module.”));

for(;;);

}

Serial.println(F(“OK.”));

Serial.print(F(“Checking firmware version…”));

wifi.println(F(“AT+GMR”));

if(wifi.readLine(buffer, sizeof(buffer))) {

Serial.println(buffer);

wifi.find(); // Discard the ‘OK’ that follows

} else {

Serial.println(F(“error”));

}

Serial.print(F(“Connecting to WiFi…”));

if(wifi.connectToAP(F(ESP_SSID), F(ESP_PASS))) {

// IP addr check isn’t part of library yet, but

// we can manually request and place in a string.

Serial.print(F(“OK\nChecking IP addr…”));

wifi.println(F(“AT+CIFSR”));

if(wifi.readLine(buffer, sizeof(buffer))) {

Serial.println(buffer);

wifi.find(); // Discard the ‘OK’ that follows

Serial.print(F(“Connecting to host…”));

Serial.print(“Connected..”);

wifi.println(“AT+CIPMUX=0”); // configure for single connection,

//we should only be connected to one SMTP server

wifi.find();

wifi.closeTCP(); // close any open TCP connections

wifi.find();

Serial.println(“Type \”send it\” to send an email”);

} else { // IP addr check failed

Serial.println(F(“error”));

}

} else { // WiFi connection failed

Serial.println(F(“FAIL”));

}

void loop() {

if(!send_flag){ // check if we expect to send an email

// Read the analog interface

analogVal = analogRead(analogPin);

if (analogVal<=60) // If the sensor detects a gas leak

{

send_flag = true; // sending an alert email

//Serial.println(btnVal);

delay(1000);

}

if(send_flag){ // the send_flat is set, this means we are or need to start sending SMTP commands

if(do_next()){ // execute the next command

count++; // increment the count so that the next command will be executed next time.

}

// do_next executes the SMTP command in the order required.

boolean do_next()

{

switch(count){

case 0:

Serial.println(“Connecting…”);

return wifi.connectTCP(F(HOST), PORT);

break;

case 1:

// send “HELO ip_address” command. Server will reply with “250” and welcome message

return wifi.cipSend(“HELO computer.com”,F(“250”)); // ideally an ipaddress should go in place

// of “computer.com” but I think the email providers

// check the IP anyways so I just put anything.

break;

case 2:

// send “AUTH LOGIN” command to the server will reply with “334 username” base 64 encoded

return wifi.cipSend(“AUTH LOGIN”,F(“334 VXNlcm5hbWU6”));

break;

case 3:

// send username/email base 64 encoded, the server will reply with “334 password” base 64 encoded

return wifi.cipSend(EMAIL_FROM_BASE64,F(“334 UGFzc3dvcmQ6”));

break;

case 4:

// send password base 64 encoded, upon successful login the server will reply with 235.

return wifi.cipSend(EMAIL_PASSWORD_BASE64,F(“235”));

break;

case 5:{

// send “MAIL FROM:<emali_from@domain.com>” command

char mailFrom[50] = “MAIL FROM:<“; // If 50 is not long enough change it, do the same for the array in the other cases

strcat(mailFrom,EMAIL_FROM);

strcat(mailFrom,”>”);

return wifi.cipSend(mailFrom,F(“250”));

break;

}

case 6:{

// send “RCPT TO:<email_to@domain.com>” command

char rcptTo[50] = “RCPT TO:<“;

strcat(rcptTo,EMAIL_TO);

strcat(rcptTo,”>”);

return wifi.cipSend(rcptTo,F(“250”));

break;

}

case 7:

// Send “DATA” command, the server will reply with something like “334 end message with \r\n.\r\n.”

return wifi.cipSend(“DATA”,F(“354”));

break;

case 8:{

// apply “FROM: from_name <from_email@domain.com>” header

char from[100] = “FROM: “;

strcat(from,EMAIL_FROM);

strcat(from,” “);

strcat(from,”<“);

strcat(from,EMAIL_FROM);

strcat(from,”>”);

return wifi.cipSend(from);

break;

}

case 9:{

// apply TO header

char to[100] = “TO: “;

strcat(to,EMAIL_TO);

strcat(to,”<“);

strcat(to,EMAIL_TO);

strcat(to,”>”);

return wifi.cipSend(to);

break;

}

case 10:{

// apply SUBJECT header

char subject[50] = “SUBJECT: “;

strcat(subject,SUBJECT);

return wifi.cipSend(subject);

break;

}

case 11:

return wifi.cipSend(“\r\n”); // marks end of header (SUBJECT, FROM, TO, etc);

break;

case 12:

return wifi.cipSend(EMAIL_CONTENT);

break;

case 13:

return wifi.cipSend(“\r\n.”); // marks end of data command

break;

case 14:

return wifi.cipSend(“QUIT”);

break;

case 15:

wifi.closeTCP();

return true;

break;

case 16:

Serial.println(“Done”);

send_flag = false;

count = 0;

return false; // we don’t want to increment the count

break;

default:

break;

}

You can also see

Using the OV7670 camera with the Arduino UNO board

12-03-23

Smart gas leak detection system with Arduino

Presentation of gas leak detection system

Presentation of Intelligent gas leak detection system with Arduino

Purpose of this project :

Necessary components

Mounting

Program:

You can also see

Using the OV7670 camera with the Arduino UNO board

Connect Arduino UNO to Wifi network using ESP8266 module

0 commentaire

Leave a comment

Annuler la réponse

Recent tutorials

Using the OV7670 camera with the Arduino UNO board

Video Streaming Web Server with ESP32-CAM

Connect Arduino UNO to Wifi network using ESP8266 module

View location data sent by NEO-M6 GPS using ESP32 board

Most viewed tutorials

Control a water pump by Arduino

Display text on the I2C LCD 1602A display with Arduino

Control a buzzer by the ESP32 card

Control a DC motor with Micro:bit

Most commented tutorials

Send data (temperature and humidity) to the Thingspeak site with Arduino

Order a car equipped with ESP32-CAM via a wifi connection

Display text on the I2C LCD 1602A display with Arduino

Control a thermal printer with Arduino