Bien le bonsoir.
J'ai écrit un code pour faire la communication série entre un arduino MEGA 2560 et un ESP32.
je souhaite envoyer des variables ( 2 variables dans un premier temps) de l'ESP32 vers arduino MEGA.
Les variables envoyées sont : WIFI.localIP et state_Alarme.
Lorsque je relis les 2 cartes ensemble, sur le moniteur serie de l'Arduino Mega, je peux voir que les données ( 2 variables ) n'arrivent pas correctement sur la carte Arduino MEGA.
Pour le câblage j'ai fait :
RX2 arduino ===> TX2 ESP32
TX2 arduino ===> RX2 ESP32
SVP quelqu'un peut-il m'aider à comprendre pourquoi les données envoyées ne sont pas reçu correctement ?
Voici le code de l'ESP32 :
#include <Arduino.h>
#include <ESPAsyncWebServer.h>
#include <SPIFFS.h>
#include <Key.h>
#include <Keypad.h>
const char *ssid = "galaxynoutsa";
const char *password = "hqwd2630";
/*-----------------------------déclaration des variables de gestion du clavier-------------------------------*/
const int ROW_NUM = 4; //four rows
const int COLUMN_NUM = 4; //four columns
char keys[ROW_NUM][COLUMN_NUM] = {
{'1','2','3', 'A'},
{'4','5','6', 'B'},
{'7','8','9', 'C'},
{'*','0','#', 'D'}
};
byte pin_rows[ROW_NUM] = {33, 25, 26, 27}; //broche a configure uniquement en entree
byte pin_column[COLUMN_NUM] = {19, 5, 14, 22}; //connect to the column pinouts of the keypad{34, 36, 38, 40}{48, 46, 44, 42}
Keypad clavier = Keypad( makeKeymap(keys), pin_rows, pin_column, ROW_NUM, COLUMN_NUM );
/*-----------------------------déclaration des variables de gestion du clavier-------------------------------*/
/*--------------------------------------------------declaration des des variables pour la gestion de l'éclairage-------------------------*/
//------------variables pour emissiom/reception des données
String Donnee_envoi ="";
String Donnee_recu ="";
String Adresse_IP = "";
bool Fin_reception = false;
int state_Mode = 0 ;
/*--------------------------------------declaration des Pins des lampes----------------*/
int lampeSalon = 13;
int lampeChambre = 32;
int lampeCuisine = 2;
int lampeGarage = 4;
int lampeDouche = 21;
int priseSalon = 23; // à rectifier
int priseCuisine = 18; // à rectifier
/*--------------------------------------declaration des Pins des lampes------------------*/
/*-------------------variables pour gérer le les capteurs sur la pge web-----------------*/
String temp_valeur;
String hum_valeur;
String gaz_status = "0";
String intru_status = "0" ;
String flamme_status = "0" ;
/*-------------------variables pour gérer le les capteurs sur la pge web-----------------*/
//------------variables des switch/case de la fonction éclairage
int sal = 0 ;
int cha = 0 ;
int cui = 0 ;
int gar = 0 ;
int dou = 0 ;
//------------variables du switch/case de la fonction éclairage
//------------variables de gestion des états des lampes
int state_Salon = 0 ;
int state_Chambre = 0 ;
int state_Cuisine = 0 ;
int state_Garage = 0 ;
int state_Douche = 0 ;
//------------variables de gestion des états des lampes
//------------------------variables de gestion de l'alarme
unsigned long temps_A ;
unsigned long temps_B ;
int alarme = 0 ; // activer/désactiver l'alarme
int state_Alarme = 0 ;
//------------------------variables de gestion de l'alarme
//---------------variables de gestion des prises de courant
int prise_sal = 0;
int prise_cui = 0;
int state_Prise_Salon = 0;
int state_Prise_Cuisine = 0;
//---------------variables de gestion des prises de courant
//------------variables de gestion du clavier
bool touche_0 = false;
bool touche_1 = false;
bool touche_2 = false;
bool touche_3 = false;
bool touche_4 = false;
bool touche_5 = false;
bool touche_6 = false;
bool touche_7 = false;
bool touche_8 = false;
bool touche_9 = false;
bool touche_A = false;
bool touche_B = false;
bool touche_C = false;
bool touche_D = false;
bool touche_x = false;
bool touche_dieze = false;
//------------variables de gestion du clavier
/*--------------------------------------------------declaration des des variables pour la gestion de l'éclairage-------------------------*/
/*----------------------------------------Déclaration des fonctions---------------------------------------------*/
void eclairage_et_prise (); // fontion de gestion de l'éclairage
void gestion_clavier(); // fonction de gestion du clavier
void desactivation_touche(); // fonction de désactivation des touches
void Emission();
//String Traitement(String donnee, int index);
void Reception();
/*----------------------------------------Déclaration des fonctions---------------------------------------------*/
AsyncWebServer server(80);
void setup()
{
//----------------------------------------------------Serial
Serial.begin(115200);
Serial2.begin(115200);
//Serial.println("\n");
/*--------------------------------------configuration des Pins en entrée/sortie--------------------------------------*/
pinMode(lampeSalon, OUTPUT);
pinMode(lampeChambre, OUTPUT);
pinMode(lampeCuisine, OUTPUT);
pinMode(lampeGarage, OUTPUT);
pinMode(lampeDouche, OUTPUT);
pinMode(priseSalon, OUTPUT);
pinMode(priseCuisine, OUTPUT);
/*--------------------------------------configuration des Pins en entrée/sortie--------------------------------------*/
//----------------------------------------------------SPIFFS
if(!SPIFFS.begin())
{
Serial.println("Erreur SPIFFS...");
return;
}
File root = SPIFFS.open("/");
File file = root.openNextFile();
while(file)
{
Serial.print("File: ");
Serial.println(file.name());
file.close();
file = root.openNextFile();
}
//----------------------------------------------------WIFI
WiFi.begin(ssid, password);
Serial.print("Tentative de connexion...");
while(WiFi.status() != WL_CONNECTED)
{
Serial.print(".");
delay(100);
}
Serial.println("\n");
Serial.println("Connexion etablie!");
Serial.print("Adresse IP: ");
Serial.println(WiFi.localIP());
//----------------------------------------------------SERVER
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request)
{
request->send(SPIFFS, "/index.html", "text/html");
});
server.on("/w3.css", HTTP_GET, [](AsyncWebServerRequest *request)
{
request->send(SPIFFS, "/w3.css", "text/css");
});
server.on("/script.js", HTTP_GET, [](AsyncWebServerRequest *request)
{
request->send(SPIFFS, "/script.js", "text/javascript");
});
/*-----------------------------gestion du Mode de fonctionnement---------------------------------------------*/
server.on("/manuel", HTTP_GET, [](AsyncWebServerRequest *request)
{
// je dois coder l'action à executer dans cette fonction
state_Mode = 1 ;
request->send(200);
});
server.on("/voyage", HTTP_GET, [](AsyncWebServerRequest *request)
{
// je dois coder l'action à executer dans cette fonction
state_Mode = 2 ;
request->send(200);
});
server.on("/etatMode", HTTP_GET, [](AsyncWebServerRequest *request)
{
if (state_Mode == 1){
String text = "Manuel";
request->send(200, "text/plain", text);
}
else{
String text = "Voyage";
request->send(200, "text/plain", text);
}
});
/*-----------------------------gestion du Mode de fonctionnement---------------------------------------------*/
/*-----------------------------récupération des requettes et gestion de l'éclairage intérieur---------------------------------------------*/
//-----------------------------------------------------------------globale
server.on("/onTout", HTTP_GET, [](AsyncWebServerRequest *request)
{
sal = 1 ;
cha = 1 ;
cui = 1 ;
gar = 1 ;
dou = 1 ;
request->send(200);
});
server.on("/offTout", HTTP_GET, [](AsyncWebServerRequest *request)
{
sal = 2 ;
cha = 2 ;
cui = 2 ;
gar = 2 ;
dou = 2 ;
request->send(200);
});
//-----------------------------------------------------------------Salon
server.on("/on1", HTTP_GET, [](AsyncWebServerRequest *request)
{
sal = 1 ;
request->send(200);
});
server.on("/off1", HTTP_GET, [](AsyncWebServerRequest *request)
{
sal = 2 ;
request->send(200);
});
//-----------------------------------------------------------------chambre
server.on("/on2", HTTP_GET, [](AsyncWebServerRequest *request)
{
cha = 1 ;
request->send(200);
});
server.on("/off2", HTTP_GET, [](AsyncWebServerRequest *request)
{
cha = 2 ;
request->send(200);
});
//-----------------------------------------------------------------Scuisine
server.on("/on3", HTTP_GET, [](AsyncWebServerRequest *request)
{
cui = 1 ;
request->send(200);
});
server.on("/off3", HTTP_GET, [](AsyncWebServerRequest *request)
{
cui = 2 ;
request->send(200);
});
//-----------------------------------------------------------------garage
server.on("/on4", HTTP_GET, [](AsyncWebServerRequest *request)
{
gar = 1 ;
request->send(200);
});
server.on("/off4", HTTP_GET, [](AsyncWebServerRequest *request)
{
gar = 2 ;
request->send(200);
});
//-----------------------------------------------------------------douche
server.on("/on5", HTTP_GET, [](AsyncWebServerRequest *request)
{
dou = 1 ;
request->send(200);
});
server.on("/off5", HTTP_GET, [](AsyncWebServerRequest *request)
{
dou = 2 ;
request->send(200);
});
/*-----------------------------récupération des requettes et gestion de l'éclairage intérieur---------------------------------------------*/
/*-------------------------------------------------Gestion des états des lampes-----------------------------------------------*/
server.on("/etatSalon", HTTP_GET, [](AsyncWebServerRequest *request)
{
if (state_Salon == 1){
String text = "Allumée";
request->send(200, "text/plain", text);
}
else{
String text = "Eteinte";
request->send(200, "text/plain", text);
}
});
server.on("/etatChambre", HTTP_GET, [](AsyncWebServerRequest *request)
{
if (state_Chambre == 1){
String text = "Allumée";
request->send(200, "text/plain", text);
}
else{
String text = "Eteinte";
request->send(200, "text/plain", text);
}
});
server.on("/etatCuisine", HTTP_GET, [](AsyncWebServerRequest *request)
{
if (state_Cuisine == 1){
String text = "Allumée";
request->send(200, "text/plain", text);
}
else{
String text = "Eteinte";
request->send(200, "text/plain", text);
}
});
server.on("/etatGarage", HTTP_GET, [](AsyncWebServerRequest *request)
{
if (state_Garage == 1){
String text = "Allumée";
request->send(200, "text/plain", text);
}
else{
String text = "Eteinte";
request->send(200, "text/plain", text);
}
});
server.on("/etatDouche", HTTP_GET, [](AsyncWebServerRequest *request)
{
if (state_Douche == 1){
String text = "Allumée";
request->send(200, "text/plain", text);
}
else{
String text = "Eteinte";
request->send(200, "text/plain", text);
}
});
/*-------------------------------------------------Gestion des états des lampes-----------------------------------------------*/
/*-----------------------------récupération et affichage des valeurs de température, humidité, gaz et flamme---------------*/
//----------------------------------------------------------------------------temperature
server.on("/valeurTemperature", HTTP_GET, [](AsyncWebServerRequest *request)
{
String tempe = temp_valeur;
request->send(200, "text/plain", tempe);
});
//-------------------------------------------------------------------------------humidite
server.on("/valeurHumidite", HTTP_GET, [](AsyncWebServerRequest *request)
{
String humidite = hum_valeur;
request->send(200, "text/plain", humidite);
});
//------------------------------------------------------------------------------------gaz
server.on("/valeurGaz", HTTP_GET, [](AsyncWebServerRequest *request)
{
if ( gaz_status == "1" ){
String text = "<i class='w3-red'>Fuite de gaz !</i>";
request->send(200, "text/plain", text);
}
else {
String text = "<i class='w3-teal'>Normale</i>";
request->send(200, "text/plain", text);
}
});
//--------------------------------------------------------------------------------flamme
server.on("/flamme", HTTP_GET, [](AsyncWebServerRequest *request)
{
if ( flamme_status == "1"){
String text = "<i class='w3-red'>Attention Incendie !</i>";
request->send(200, "text/plain", text);
}
else {
String text = "<i class='w3-teal'>Normale</i>";
request->send(200, "text/plain", text);
}
});
/*-----------------------------récupération et affichage des valeurs de température, humidité, gaz et flamme---------------*/
/*-----------------------------gestion de l'alarme, Activation/désactivation -----------------------------------*/
//-----------------------------------------------------------------activer/désactiver
server.on("/onAlarme", HTTP_GET, [](AsyncWebServerRequest *request)
{
state_Alarme = 1 ;
request->send(200);
});
server.on("/offAlarme", HTTP_GET, [](AsyncWebServerRequest *request)
{
state_Alarme = 0 ;
request->send(200);
});
server.on("/etatAlarme", HTTP_GET, [](AsyncWebServerRequest *request)
{
if (state_Alarme == 1){
String text = "Activée";
request->send(200, "text/plain", text);
}
else{
String text = "Désactivée";
request->send(200, "text/plain", text);
}
});
//-----------------------------------------------------------------------------intrusion
server.on("/intrusion1", HTTP_GET, [](AsyncWebServerRequest *request)
{
if ( intru_status == "1" ){
String text = "<i class='w3-red'>Intrusion !</i>";
request->send(200, "text/plain", text);
}
else {
String text = "<i class='w3-teal'>Normale !</i>";
request->send(200, "text/plain", text);
}
});
/*-----------------------------Activation/désactivation de l'alarme-----------------------------------*/
/*-----------------------------gestion des prises de courant-----------------------------------*/
//--------------------------------------------------------------------prise du salon
server.on("/onSalon", HTTP_GET, [](AsyncWebServerRequest *request)
{
prise_sal = 1 ;
request->send(200);
});
server.on("/offSalon", HTTP_GET, [](AsyncWebServerRequest *request)
{
prise_sal = 2 ;
request->send(200);
});
server.on("/etatPriseSalon", HTTP_GET, [](AsyncWebServerRequest *request)
{
if (state_Prise_Salon == 1){
String text = "Allumée";
request->send(200, "text/plain", text);
}
else{
String text = "Eteinte";
request->send(200, "text/plain", text);
}
});
//-----------------------------------------------------------------prise de la cuisine
server.on("/onCuisine", HTTP_GET, [](AsyncWebServerRequest *request)
{
prise_cui = 1 ;
request->send(200);
});
server.on("/offCuisine", HTTP_GET, [](AsyncWebServerRequest *request)
{
prise_cui = 2 ;
request->send(200);
});
server.on("/etatPriseCuisine", HTTP_GET, [](AsyncWebServerRequest *request)
{
if (state_Prise_Cuisine == 1){
String text = "Allumée";
request->send(200, "text/plain", text);
}
else{
String text = "Eteinte";
request->send(200, "text/plain", text);
}
});
/*-----------------------------gestion des prises de courant-----------------------------------*/
server.begin();
Serial.println("Serveur actif!");
}
void loop()
{
//Reception();
gestion_clavier();
Emission();
eclairage_et_prise() ;
}
/*----------------------------------fonction de reccupération des touches enfoncées du clavier-------------------------------------*/
void gestion_clavier(){
char code = clavier.getKey();
/*if(code)
{
Serial.println(code);
Serial.print("etoile : ");
Serial.println(touche_x);
Serial.print("dieze : ");
Serial.println(touche_dieze);
}*/
if (code != NO_KEY){
switch (code){
case '*' :
desactivation_touche();
touche_x = true;
break;
case '#' :
desactivation_touche();
touche_dieze = true;
break;
case '1' :
if(touche_x == true){sal = 1 ; }
else if(touche_dieze == true){sal = 2; }
desactivation_touche();
break;
case '2' :
if(touche_x == true){cha = 1 ; }
else if(touche_dieze == true){cha = 2; }
desactivation_touche();
break;
case '3' :
if(touche_x == true){cui = 1 ; }
else if(touche_dieze == true){cui = 2; }
desactivation_touche();
break;
case '4' :
if(touche_x == true){gar = 1 ; }
else if(touche_dieze == true){gar = 2; }
desactivation_touche();
break;
case '5' :
if(touche_x == true){dou = 1 ; }
else if(touche_dieze == true){dou = 2; }
desactivation_touche();
break;
case '6' :
if(touche_x == true){prise_sal = 1 ; }
else if(touche_dieze == true){prise_sal = 2; }
desactivation_touche();
break;
case '7' :
if(touche_x == true){prise_cui = 1 ; }
else if(touche_dieze == true){prise_cui = 2; }
desactivation_touche();
break;
case 'A' :
desactivation_touche();
touche_A = true;
temps_A = millis();
break;
case 'B' :
if(touche_A == true && millis() - temps_A <= 2000 ){ state_Alarme = 1; }
desactivation_touche();
break;
case 'C' :
desactivation_touche();
touche_C = true;
temps_B = millis();
break;
case 'D' :
if(touche_C == true && millis() - temps_B <= 2000 ){ state_Alarme = 0; }
desactivation_touche();
break;
}
}
}
/*----------------------------------fonction de reccupération des touches enfoncées du clavier-------------------------------------*/
/*-----------------------------fonction gestion de l'éclairage à partir des requetes obtenues précédemment--------------------*/
void eclairage_et_prise (){
switch (sal){
case 1 :
digitalWrite(lampeSalon, HIGH);
state_Salon = 1 ;
sal = 0 ;
break;
case 2 :
digitalWrite(lampeSalon, LOW);
state_Salon = 0 ;
sal = 0 ;
break;
}
switch (cha){
case 1 :
digitalWrite(lampeChambre, HIGH);
state_Chambre = 1 ;
cha = 0 ;
break;
case 2 :
digitalWrite(lampeChambre, LOW);
state_Chambre = 0 ;
cha = 0 ;
break;
}
switch (cui){
case 1 :
digitalWrite(lampeCuisine, HIGH);
state_Cuisine = 1 ;
cui = 0 ;
break;
case 2 :
digitalWrite(lampeCuisine, LOW);
state_Cuisine = 0 ;
cui = 0 ;
break;
}
switch (gar){
case 1 :
digitalWrite(lampeGarage, HIGH);
state_Garage = 1 ;
gar = 0 ;
break;
case 2 :
digitalWrite(lampeGarage, LOW);
state_Garage = 0 ;
gar = 0 ;
break;
}
switch (dou){
case 1 :
digitalWrite(lampeDouche, HIGH);
state_Douche = 1 ;
dou = 0 ;
break;
case 2 :
digitalWrite(lampeDouche, LOW);
state_Douche = 0 ;
dou = 0 ;
break;
}
switch (prise_sal){
case 1 :
digitalWrite(priseSalon, HIGH);
state_Prise_Salon = 1 ;
prise_sal = 0 ;
break;
case 2 :
digitalWrite(priseSalon, LOW);
state_Prise_Salon = 0 ;
prise_sal = 0 ;
break;
}
switch (prise_cui){
case 1 :
digitalWrite(priseCuisine, HIGH);
state_Prise_Cuisine = 1 ;
prise_cui = 0 ;
break;
case 2 :
digitalWrite(priseCuisine, LOW);
state_Prise_Cuisine = 0 ;
prise_cui = 0 ;
break;
}
}
/*-----------------fonction gestion de l'éclairage à partir des requetes obtenues précédemment--------------------*/
/*---------------------------------fonction d'émission et de reception des données---------------------------------*/
//------------------------------------fonction pour l'émission des données
void Emission(){
//Donnee_envoi += char(WiFi.localIP());
//Donnee_envoi += (String)state_Alarme + "," ;
//Serial.print("envoi: ");
Serial.print(WiFi.localIP());
Serial2.print(WiFi.localIP());
Serial.print(",");
Serial2.print(",");
Serial.print(state_Alarme);
Serial2.print(state_Alarme);
Serial.println(",");
Serial2.println(",");
//delay(100);
//Donnee_envoi ="";
}
//------------------------------------fonction pour la reception des données
void Reception(){
while (Serial2.available()) {
// get the new byte:
char inChar = (char)Serial2.read();
// add it to the inputString:
Donnee_recu += inChar;
if (inChar == '\n') {
Fin_reception = true;
delay(10);
}
}
if (Fin_reception == true)
{
temp_valeur = Traitement(Donnee_recu, 1);
hum_valeur = Traitement(Donnee_recu, 2);
gaz_status = Traitement(Donnee_recu, 3);
intru_status = Traitement(Donnee_recu, 4);
flamme_status = Traitement(Donnee_recu, 5);
Fin_reception = false ;
}
/*Serial.print("temp_valeur");
Serial.println(temp_valeur);
Serial.print("hum_valeur");
Serial.println(hum_valeur);*/
}
//------------------------------------fonction pour le traitement des données
String Traitement(String donnee, int index)
{
int stringData = 0;
String dataPart = "";
for(int i = 0; i<donnee.length()-1; i++){
if(donnee[i]==','){
stringData++;}
else if(stringData==index){
dataPart.concat(donnee[i]);}
else if(stringData>index){
return dataPart;
break;
}
} return dataPart;
}
/*---------------------------------fonction d'émission et de reception des données---------------------------------*/
void desactivation_touche(){
touche_0 = false;
touche_1 = false;
touche_2 = false;
touche_3 = false;
touche_4 = false;
touche_5 = false;
touche_6 = false;
touche_7 = false;
touche_8 = false;
touche_9 = false;
touche_A = false;
touche_B = false;
touche_C = false;
touche_D = false;
touche_x = false;
touche_dieze = false;
}
Voici le code de l'Arduino MEGA :
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
#include "DHT.h"
#define DHTPIN 2
#define DHTTYPE DHT11 // DHT 11
DHT dht(DHTPIN, DHTTYPE);
LiquidCrystal_I2C lcd(0x27,20,4); // set the LCD address to 0x27
/*----------------------------------------declaration des PIN----------------------------------------*/
const int capteur_GAZ = A3; //capteur de GAZ
const int capteur_intru = 4; //capteur de presence
const int capteur_flamme = A7; //capteur de flamme
const int buzzer = 10 ; // module sonore
const int venti_clim = 22 ; //climatiseur
const int venti_evacuation = 9 ; // ventillateur évacuation des fuites de GAZ
const int ledR=12;
const int ledV=13;
/*----------------------------------------declaration des PIN----------------------------------------*/
/*----------------------------------------variables de gestion du systeme----------------------------*/
//------------variables de gestion DHT11
int temp_valeur;
int hum_valeur;
int temp_status = 0 ;
//------------variables de gestion capteur de GAZ
float gaz_valeur = 0.00;
int gaz_status = 0;
unsigned long temps_gaz = millis();
//------------variables de gestion capteur d'intrusion
int intru_status = 0 ;
int intru_valeur= 0 ;
unsigned long temps_intru = millis();
//------------variables de gestion capteur de flamme
int flamme_valeur = 0 ;
int flamme_status = 0 ;
unsigned long temps_flamme = millis();
//------------variables pour emissiom/reception des données
String Donnee_envoi ="";
String Donnee_recu ="";
String Adresse_IP = "2.2.2.2";
String state_Alarme ="1";
bool Fin_reception = false ;
//------------variables de gestion de l'affichage
bool aff_aucun = true;
bool aff_gaz = true;
bool aff_intru = true;
bool aff_flamme = true;
bool aff_gaz_intru = true;
bool aff_gaz_flamme = true;
bool aff_intru_flamme = true;
bool aff_gaz_intru_flamme = true;
/*----------------------------------------variables de gestion du systeme----------------------------*/
/*----------------------------------------Déclaration des fonctions----------------------------------*/
void lire_DHT11();
void lire_gaz();
void lire_intru();
void lire_flamme();
void capteur_actif();
void capteur_inactif();
void affichage_lcd();
void activation_affichage();
void Emission();
//String Traitement(String donnee, int index);
void Reception();
/*----------------------------------------Déclaration des fonctions----------------------------------*/
void setup() {
//---------configuration des PINS en E/S
pinMode(capteur_GAZ,INPUT);
pinMode(capteur_intru,INPUT);
pinMode(capteur_flamme,INPUT);
pinMode(venti_evacuation,OUTPUT);
pinMode(venti_clim,OUTPUT);
pinMode(buzzer,OUTPUT);
pinMode(ledR,OUTPUT);
pinMode(ledV,OUTPUT);
//---------Initialisation de la communication serie
Serial.begin(115200);
Serial2.begin(115200);
dht.begin();
//---------Initialisation de l'afficheur LCD
lcd.init();
lcd.backlight();
lcd.clear();
lcd.setCursor(0,0);
//--------- reception et traitement de l'adresse IP
}
void loop() {
Reception();
Donnee_recu = "";
lire_DHT11();
lire_gaz();
lire_intru();
lire_flamme();
//Emission();
affichage_lcd();
}
/*--------------------------fonction pour lire le capteur de temperature--------------------------*/
void lire_DHT11(){
hum_valeur = dht.readHumidity();
temp_valeur = dht.readTemperature();
if ( temp_valeur > 27 ){
//temp_status = 1;
digitalWrite(venti_clim, HIGH);
//Serial.println("venti_clim HIGH");
}
else{
// temp_status = 0;
digitalWrite(venti_clim, LOW);
//Serial.println("venti_clim LOW");
}
}
/*--------------------------fonction pour lire le capteur de temperature--------------------------*/
/*--------------------------fonction pour lire le capteur de gaz----------------------------------*/
void lire_gaz(){
gaz_valeur = ((analogRead(capteur_GAZ)*5.00)/1023.00);
if ( gaz_valeur > 1.00 ){ // on doit effectuer une conversion sur la variable
gaz_status = 1; //'a' pour avoir la bonne valeur du taux de gaz en ppm
temps_gaz = millis();
digitalWrite(venti_evacuation,HIGH);
capteur_actif();
}
else{
gaz_status = 0;
digitalWrite(venti_evacuation,LOW);
}
}
/*--------------------------fonction pour lire le capteur de gaz-----------------------------------*/
/*--------------------------fonction pour lire le capteur de d'intrusion---------------------------*/
void lire_intru(){
intru_valeur = digitalRead(capteur_intru);
if ( intru_valeur == LOW && state_Alarme == "1" ){
intru_status = 1;
capteur_actif();
}
else {
intru_status = 0;
}
}
/*--------------------------fonction pour lire le capteur de d'intrusion---------------------------*/
/*--------------------------fonction pour lire le capteur de flamme--------------------------------*/
void lire_flamme(){
flamme_valeur = analogRead(capteur_flamme);
if ( flamme_valeur < 100 ){
flamme_status = 1;
temps_flamme = millis();
capteur_actif();
}
else{
flamme_status = 0;
}
}
/*--------------------------fonction pour lire le capteur de flamme--------------------------------*/
/*--------------------------fonctions gerer l'etat du buzzer et des LED de signalisation-----------*/
void capteur_actif(){
digitalWrite(ledR,HIGH);
digitalWrite(ledV,LOW);
tone(buzzer, 200, 700); // on doit améliorer le code du buzzer pour produire un bon son (sirène de police)
}
void capteur_inactif(){
digitalWrite(ledR,LOW);
digitalWrite(ledV,HIGH);
noTone(buzzer);
}
/*--------------------------fonctions gerer l'etat du buzzer et des LED de signalisation-----------*/
/*---------------------------------fonction gerer l'afficheur LCD---------------------------------*/
void affichage_lcd(){
if(gaz_status == 0 && intru_status == 0 && flamme_status == 0){
capteur_inactif() ;
activation_affichage();
lcd.clear();
lcd.setCursor(3,0);
lcd.print("temperature : ");
lcd.setCursor(17,0);
lcd.print(temp_valeur);
lcd.setCursor(3,1);
lcd.print("humidite : ");
lcd.setCursor(14,1);
lcd.print(hum_valeur);
}
else if(gaz_status == 1 && intru_status == 0 && flamme_status == 0 && aff_gaz == true){
lcd.clear();
lcd.setCursor(3,0);
lcd.print("Atention !");
lcd.setCursor(2,1);
lcd.print("!! Fuite de Gaz !!");
activation_affichage();
aff_gaz = false ;
}
else if(gaz_status == 0 && intru_status == 1 && flamme_status == 0 && aff_intru == true){
lcd.clear();
lcd.setCursor(3,0);
lcd.print("Atention !");
lcd.setCursor(3,1);
lcd.print("!! Intrusion !!");
activation_affichage();
aff_intru = false ;
}
else if(gaz_status == 0 && intru_status == 0 && flamme_status == 1 && aff_flamme == true){
lcd.clear();
lcd.setCursor(3,0);
lcd.print("Atention !");
lcd.setCursor(3,1);
lcd.print("!! Incendie !!");
activation_affichage();
aff_flamme = false ;
}
else if(gaz_status == 1 && intru_status == 1 && flamme_status == 0 && aff_gaz_intru == true){
lcd.clear();
lcd.setCursor(3,0);
lcd.print("Atention !");
lcd.setCursor(3,1);
lcd.print("!! Fuite de Gaz !!");
lcd.setCursor(3,2);
lcd.print("!! Intrusion !!");
activation_affichage();
aff_gaz_intru = false ;
}
else if(gaz_status == 1 && intru_status == 0 && flamme_status == 1 && aff_gaz_flamme == true){
lcd.clear();
lcd.setCursor(3,0);
lcd.print("Atention !");
lcd.setCursor(3,1);
lcd.print("!! Fuite de Gaz !!");
activation_affichage();
aff_gaz_flamme = false ;
}
else if(gaz_status == 0 && intru_status == 1 && flamme_status == 1 && aff_intru_flamme == true){
lcd.clear();
lcd.setCursor(3,0);
lcd.print("Atention !");
lcd.setCursor(3,1);
lcd.print("!! Fuite de Gaz !!");
activation_affichage();
aff_intru_flamme = false ;
}
else if(gaz_status == 1 && intru_status == 1 && flamme_status == 1 && aff_gaz_intru_flamme == true){
lcd.clear();
lcd.setCursor(3,0);
lcd.print("Atention !");
lcd.setCursor(3,1);
lcd.print("!! Fuite de Gaz !!");
activation_affichage();
aff_gaz_intru_flamme = false ;
}
}
/*---------------------------------fonction gerer l'afficheur LCD---------------------------------*/
/*---------------------------------fonction d'émission et de reception des données---------------------------------*/
//------------------------------------fonction pour l'émission des données
void Emission(){
Donnee_envoi +=','+(String)temp_valeur +',' ;
Donnee_envoi += (String)hum_valeur +',' ;
Donnee_envoi += (String)gaz_status +',' ;
Donnee_envoi += (String)intru_status +',';
Donnee_envoi += (String)flamme_status +',' ;
//Serial.print("envoi: ");
//Serial.println(Donnee_envoi);
//Serial1.println(Donnee_envoi);
//delay(100);
Donnee_envoi ="";
}
//------------------------------------fonction pour la reception des données
void Reception(){
while (Serial2.available()) {
// get the new byte:
char inChar = (char)Serial2.read();
// add it to the inputString:
Donnee_recu += inChar;
if (inChar == '\n') {
Fin_reception = true;
//delay(10);
}
}
if (Fin_reception == true)
{
Adresse_IP = Traitement(Donnee_recu, 0);
state_Alarme = Traitement(Donnee_recu, 1);
Serial.print("Donnee_recu: ");
Serial.println(Donnee_recu);
Serial.print("IP: ");
Serial.println(Adresse_IP);
Serial.print("Alarme: ");
Serial.println(state_Alarme);
Fin_reception = false ;
}
}
//------------------------------------fonction pour le traitement des données
String Traitement(String donnee, int index)
{
int stringData = 0;
String dataPart = "";
for(int i = 0; i<donnee.length()-1; i++){
if(donnee[i]==','){
stringData++;}
else if(stringData==index){
dataPart.concat(donnee[i]);}
else if(stringData>index){
return dataPart;
break;
}
} return dataPart;
}
/*---------------------------------fonction d'émission et de reception des données---------------------------------*/
void activation_affichage(){
aff_aucun = true;
aff_gaz = true;
aff_intru = true;
aff_flamme = true;
aff_gaz_intru = true;
aff_gaz_flamme = true;
aff_intru_flamme = true;
aff_gaz_intru_flamme = true;
}
Voici une capture du moniteur série de l'Arduino MEGA :
