Détecteur de fuite de gaz connecté à l’Internet des objets piloté par Arduino

Arduino UNO 16-11-24

64 0

Plan de tutoriel

1- Présentation du détecteur de fuite de gaz connecté à l'Internet des objets

2- Comment la carte Arduino UNO commande le système ?

3- Composants matériels nécessaires

4- Schéma de câblage du système

5- Programmation de la carte Arduino UNO

Présentation du détecteur de fuite de gaz connecté à l'Internet des objets

Un détecteur de fuite de gaz connecté à l’Internet des Objets (IoT) est une solution intelligente qui détecte les fuites de gaz dans un environnement donné et envoie des alertes locales et à distance en temps réel. Il utilise des capteurs de gaz couplés à une connectivité réseau pour améliorer la sécurité des lieux résidentiels, commerciaux ou industriels.

Le détecteur IoT surveille en permanence la concentration des gaz dans l’air. Lorsqu’un seuil critique est atteint, il déclenche :

Une alerte locale via des moyens visuels (LED) ou sonores (buzzer).

Une alerte distante via Internet (notifications push, email, ou SMS).

(Optionnel) Active des actions automatisées, comme couper l’alimentation en gaz.

Fonctionnement détaillé

a) Surveillance continue

Le capteur de gaz mesure en temps réel la concentration du gaz dans l’air.

Si la concentration dépasse un seuil prédéfini (ex. 300 ppm pour le monoxyde de carbone), le capteur envoie une alerte au microcontrôleur.

b) Détection et alerte locale

Le microcontrôleur active immédiatement :

Un buzzer pour émettre une alarme sonore.

Une LED rouge pour signaler une fuite.

c) Notification distante

Grâce à sa connexion Internet, le système : Envoie un email via SMTP.

d) Actions automatisées

Le système peut être intégré à un relais pour couper automatiquement l’alimentation en gaz ou déclencher une ventilation.

Avantages du système connecté

Détection rapide : Capteurs sensibles pour détecter même de faibles concentrations de gaz.

Alertes en temps réel : Notifications instantanées même si l’utilisateur est absent.

Action proactive : Possibilité d’automatiser des réponses pour limiter les risques (ex. couper l’alimentation en gaz).

Surveillance à distance : Accès aux données via des applications IoT ou des tableaux de bord en ligne.

Enregistrement des données : Historique des niveaux de gaz pour une analyse ultérieure.

Ce détecteur connecté est une solution essentielle pour améliorer la sécurité et réduire les risques d’accidents liés aux fuites de gaz, tout en offrant un contrôle et une supervision en temps réel.

Comment la carte Arduino UNO commande le système ?

Phase de surveillance :

Le capteur MQ-4 mesure en continu la concentration de méthane dans l’air.

La sortie analogique (A0) est lue par l'Arduino pour obtenir une valeur proportionnelle à la concentration.

Détection d'une fuite :

Si la concentration de gaz dépasse un seuil critique (défini dans le code), l'Arduino : communique avec le module ESP8266 pour envoyer une alerte par email.

Notification par email :

Le module ESP8266, configuré pour se connecter au Wi-Fi, envoie un email via un service SMTP contenant les détails de l'alerte.

Retour à l’état normal :

Une fois la concentration de gaz revenue à un niveau sûr, le système désactive les alertes sonores et visuelles, et la LED verte s'allume.

Composants matériels nécessaires

Arduino UNO :

Arduino Uno

Microcontrôleur servant de base pour la gestion des capteurs et actionneurs.

Capteur MQ-4 :

Capteur capable de détecter les gaz inflammables tels que le méthane (CH4) et le gaz naturel.

Sortie analogique (A0) et numérique (D0).

Module Wi-Fi ESP8266 :

Assure la connectivité à Internet pour envoyer des alertes via email.

Module d'alimentation 3V/5V

Ce module est utilisé pour alimenter le module Wifi ESP8266.

Breadboard (Plaque d'essai) :

plaque d'essai

Une breadboard est utile pour créer un circuit temporaire et connecter facilement les composants entre eux.

Fils de connexion :

Fils de connexion

Il sont utilisés pour établir une connexion entre les composants du système.

Schéma de câblage du système

Capteur MQ-4 ↔ Arduino UNO :

VCC : 5V de l’Arduino.

GND : GND de l’Arduino.

D0 : Entrée analogique sur l’Arduino (ex. A0).

ESP8266 ↔ Arduino UNO :

RX : Broche numérique N° 4 de la carte Arduino

TX : Broche numérique N°3 de la carte Arduino

GND: GND de la carte Arduino

Les deux broches 3V3 et EN à la broche 5V du module de l’alimentation

RST : Broche numérique N° 8 de la carte Arduino

les deux broches 3V3 et EN à la broche 5V du module de l’alimentation

Programmation de la carte Arduino UNO

Voici le programme du détecteur de fuite de gaz connecté à l'Internet :

Vous devrez importer cette bibliothèque Adafruit_ESP8266 pour contrôler le module Wifi ESP8266.

#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)  // Si le capteur détecte un fuite de gaz
{
send_flag = true;  // envoi d’un email d’alerte
//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

#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) // Si le capteur détecte un fuite de gaz

{

send_flag = true; // envoi d’un email d’alerte

//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;

}

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

ESP32 Robot voiture à deux roues commandé via Bluetooth

ESP32 19-12-24

Création du jeu Snake avec la carte ESP8266

ESP8266 18-12-24

Piloter des moteurs par l’Arduino UNO et le module L293D

Arduino UNO 18-12-24

Agriculture intelligente connectée à IoT en utilisant l’Arduino

Arduino UNO 16-12-24

Création du jeu Snake avec la carte Arduino UNO

Arduino UNO 14-12-24

Atelier robotique

Tutoriels populaires

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino UNO 3181vues

Allumer une LED connectée à la carte ESP32 via WIFI

ESP32 Wifi 2963vues

Allumer une LED par la carte ESP32

ESP32 2931vues

Présentation de la carte ESP32

ESP32 2772vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 2711vues

Construction des robots

Tutoriels plus commentés

Commander trois LEDs par la télécommande en utilisant le capteur KY-032 et la carte Micro:bit

Micro:bit 3 commentaires

Allumer une LED connectée à l’Arduino UNO via WIFI

Arduino UNO Wifi 3 commentaires

Création des jeux avec Micro:bit et MakeCode

Micro:bit 2 commentaires

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur SSD1306

Arduino UNO 2 commentaires

Système de détection d’obstacles basé sur HC-SR04, afficheur SSD1306 et Arduino UNO

Arduino UNO 2 commentaires

Détecteur de fuite de gaz connecté à l’Internet des objets piloté par Arduino

Plan de tutoriel

1- Présentation du détecteur de fuite de gaz connecté à l'Internet des objets

2- Comment la carte Arduino UNO commande le système ?

3- Composants matériels nécessaires

4- Schéma de câblage du système

5- Programmation de la carte Arduino UNO

Présentation du détecteur de fuite de gaz connecté à l'Internet des objets

Fonctionnement détaillé

a) Surveillance continue

b) Détection et alerte locale

c) Notification distante

d) Actions automatisées

Avantages du système connecté

Comment la carte Arduino UNO commande le système ?

Composants matériels nécessaires

Schéma de câblage du système

Capteur MQ-4 ↔ Arduino UNO :

ESP8266 ↔ Arduino UNO :

Programmation de la carte Arduino UNO

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles