Objets connectes et communication sans fil embarquée
Département Génie Électrique
Licence professionnelle : Electronique des Systèmes Embarqués
COMPTE RENDU
Module :
OBJETS CONNECTES ET COMMUNICATION
SANS FIL EMBARQUEES
Réaliser par : Sous la demande :
TALHIOUI MOHAMMED Mr. AMRANNI
EL FAZAZI MOHAMMED
Année universitaire : 2023/2024
Objets connectes et communication sans fil embarquée
TP N°1 : Monitoring de principaux paramètres
électriques et physiques en utilisant un
microcontrôleur Arduino UNO
I- Principe
Le principe du système de "monitoring" de paramètres électriques et physiques à l’aide du
microcontrôleur ATmega328 (Arduino UNO) et de différents principaux capteurs (courant,
tension, température, lumière,)
Objectifs :
-Comprendre le principe de base d'un système de surveillance (monitoring) des paramètres
électriques et physiques.
-Mettre en œuvre un système de monitoring simple utilisant un microcontrôleur Arduino
UNO et divers capteurs.
-Acquérir et traiter les données des capteurs en temps réel.
-Afficher les données mesurées sur un écran LCD et/ou les transmettre à un ordinateur pour
une analyse ultérieure.
II- Etude sous ISIS
a) - Capteur de courant (ACS712) :
Le montage :
Objets connectes et communication sans fil embarquée
Le code :
#include <LiquidCrystal.h>
const int RS = 12, EN = 11, D4 = 5, D5 = 4, D6 = 3, D7 = 2;
LiquidCrystal lcd(RS, EN, D4, D5, D6, D7);
#define voltagePin A1
const float analogueFactor = 5000.0 / 1023.0;
const float sensitivity = 185.0;
const float ACoffset = 2500.0;
float analogueValue = 0.0;
float currentValue = 0.0;
float adcVoltage = 0.0;
byte degree[8] =
{
0b00011,
0b00011,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
};
unsigned long ctr = 1;
void setup() {
lcd.begin(16, 2);
lcd.createChar(1, degree);
Serial.begin(9600);
for (int positionCounter = 0; positionCounter < 16; positionCounter++) {
lcd.scrollDisplayLeft();
delay(150);
}
lcd.setCursor(0, 0);
lcd.print("monitoring");
lcd.setCursor(0, 1);
lcd.print("mesuramment");
delay(2000);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("ESTM");
delay(2000);
}
void loop()
{
analogueValue = analogRead(voltagePin); // Lire la valeur analogique du pin
Objets connectes et communication sans fil embarquée
adcVoltage = analogueValue * analogueFactor ;
currentValue = ((adcVoltage - ACoffset) / sensitivity);
delay(10);
lcd.setCursor(8,1);
lcd.print("I:");
lcd.print(currentValue, 2);
lcd.print("A");
Serial.print(" <--La mesure numéro : ");
Serial.print(ctr);
Serial.println("-->");
Serial.print(" Current = ");
Serial.print(currentValue, 2);
Serial.println(" A");
}
Ce code mesure le courant électrique à l'aide d'un capteur analogique et l'affiche sur un écran
LCD 16x2. L'écran LCD affiche que le courant est de 13.51A
b) - Capteur de tension
Le montage :
Le code :
#include <LiquidCrystal.h>
const int RS = 12, EN = 11, D4 = 5, D5 = 4, D6 = 3, D7 = 2;
LiquidCrystal lcd(RS, EN, D4, D5, D6, D7);
#define voltagePin A1
const float R1 = 30000.0;
Objets connectes et communication sans fil embarquée
const float R2 = 7500.0;
float Vout = 0.0;
float Vin = 0.0;
float value = 0.0;
byte degree[8] =
{
0b00011,
0b00011,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
};
unsigned long ctr = 1;
void setup() {
lcd.begin(16, 2);
lcd.createChar(1, degree);
Serial.begin(9600);
for (int positionCounter = 0; positionCounter < 16; positionCounter++) {
lcd.scrollDisplayLeft();
delay(150);
}
lcd.setCursor(0, 0);
lcd.print("monitoring");
lcd.setCursor(0, 1);
lcd.print("mesuramment");
delay(2000);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("ESTM");
delay(2000);
}
void loop()
{
value = analogRead(voltagePin);
Vout = (value * 5.0) / 1024.0;
Vin = Vout / (R2/(R1+R2));
delay(10);
lcd.setCursor(8,0);
lcd.print("-");
lcd.print(Vin, 1);
lcd.print("V");
Serial.print (" <--La mesure numéro : ");
Objets connectes et communication sans fil embarquée
Serial.print(ctr);
Serial.println("-->");
//=>pour l'affichage de la tension :
Serial.print(" Voltage = ");
Serial.print(Vin);
Serial.println(" V");
}
Le circuit fourni réalise la surveillance d'une tension à l'aide d'un diviseur de tension et
l'affiche sur un écran LCD, Il affiche -25V
c)-Capteur de température (DHT11 ou 22)
Le montage
Le code :
#include <LiquidCrystal.h>
#include <DHT.h>
const int RS = 12, EN = 11, D4 = 5, D5 = 4, D6 = 3, D7 = 2;
LiquidCrystal lcd(RS, EN, D4, D5, D6, D7);
#define DHTPIN 7
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
byte degree[8] =
{
0b00011,
0b00011,
Objets connectes et communication sans fil embarquée
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
};
void setup() {
lcd.begin(16, 2);
lcd.createChar(1, degree);
Serial.begin(9600);
dht.begin();
lcd.setCursor(0, 0);
lcd.print("Monitoring");
lcd.setCursor(0, 1);
lcd.print("Measurement");
delay(2000);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("ESTM");
delay(2000);
}
void loop() {
float temperature = dht.readTemperature();
float humidity = dht.readHumidity();
lcd.setCursor(0, 0);
lcd.print("T:");
lcd.print((int)temperature);
lcd.write(1);
lcd.print("C");
lcd.setCursor(0, 1);
lcd.print("H:");
lcd.print((int)humidity);
lcd.print(" %");
delay(2000);
lcd.clear();
}
Ce code utilise un capteur DHT11 pour mesurer la température et l'humidité, puis affiche ces
valeurs sur un écran LCD. Les données sont mises à jour toutes les 2 secondes.
L'écran LCD affiche que la température est de 27°C et l'humidité est de 80%.
Objets connectes et communication sans fil embarquée
d)- Capteur de température (MAX6675)
Le montage :
Le code :
#include <LiquidCrystal.h>
#include <max6675.h>
const int RS = 12, EN = 11, D4 = 5, D5 = 4, D6 = 3, D7 = 2;
LiquidCrystal lcd(RS, EN, D4, D5, D6, D7);
const int thermoDO = 9;
const int thermoCS = 10;
const int thermoCLK = 13;
MAX6675 thermocouple(thermoCLK, thermoCS, thermoDO);
void setup() {
lcd.begin(16, 2);
lcd.print("Temperature:");
lcd.setCursor(0, 1);
lcd.print("Initializing...");
delay(1000);
}
void loop() {
double celsius = thermocouple.readCelsius();
if (isnan(celsius)) {
Objets connectes et communication sans fil embarquée
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Error reading");
lcd.setCursor(0, 1);
lcd.print("temperature");
delay(1000);
} else {
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Temperature:");
lcd.setCursor(0, 1);
lcd.print(celsius);
lcd.print(" C");
delay(1000);
}
}
Ce code utilise un capteur de température MAX6675 pour mesurer la température et l'afficher
sur un écran LCD. L'écran LCD affiche la température en degrés Celsius. Les données sont
actualisées toutes les secondes. L'écran LCD affiche que la température est de 1086.25 °C
e) -Capteur de lumière LDR
Le montage :
Le code :
#include <LiquidCrystal.h>
const int RS = 12, EN = 11, D4 = 5, D5 = 4, D6 = 3, D7 = 2;
LiquidCrystal lcd(RS, EN, D4, D5, D6, D7);
#define LDR A2
Objets connectes et communication sans fil embarquée
float Vldr = 0.0;
float lightIntensity = 0.0;
float lux = 0.0;
byte degree[8] =
{
0b00011,
0b00011,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
};
unsigned long ctr = 1; // Déclaration et initialisation du compteur
void setup() {
lcd.begin(16, 2);
lcd.createChar(1, degree);
Serial.begin(9600);
}
void loop() {
Vldr = analogRead(LDR);
lightIntensity = (Vldr / 1023.0) * 5;
lux = ((2500 / lightIntensity) - 500) / 10;
delay(10);
lcd.setCursor(0,0);
lcd.print("Intens: ");
lcd.print((int)lux);
lcd.print(" Lux");
/*-->l'affichage sur le moniteur série*/
Serial.print(" <--La mesure numéro : ");
Serial.print(ctr);
Serial.println("-->");
Serial.print(" Intens = ");
Serial.print(lux);
Serial.println("LUX");
delay(1000);
ctr++; // Incrémentation du compteur à chaque itération
}
Ce code utilise un capteur de lumière (LDR) pour mesurer l'intensité lumineuse et l'affiche en
lux sur un écran LCD. Plus précisément, l'écran LCD affiche une intensité lumineuse de 28
lux. Les valeurs sont mises à jour régulièrement.
Objets connectes et communication sans fil embarquée
f) -Ensemble des capteurs :
Le montage :
Le code :
#include <LiquidCrystal_I2C.h>
#include <DHT.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);
#define DHTPIN 8
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
float Temperature = 0.0;
float Humidity = 0.0;
#define currentPin A3
const float analogueFactor = 5000.0/1023.0;
const float sensitivity = 185.0;
const float ACoffset = 2500.0;
float analogueValue= 0.0;
float currentValue = 0.0;
float adcVoltage = 0.0;
#define voltagePin A1
const float R1 = 30000.0;
const float R2 = 7500.0;
float Vout = 0.0;
float Vin = 0.0;
float value = 0.0;
byte degree[8] = {
Objets connectes et communication sans fil embarquée
0b00011,
0b00011,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,};
unsigned long ctr = 1;
void setup() {
lcd.init();
lcd.backlight();
Serial.begin(9600);
dht.begin();
lcd.setCursor(0,0);
lcd.print(" Monitoring ");
lcd.setCursor(0,1);
lcd.print(" Measurement ");
delay(200);
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" ESTM ");
delay(200);}
void loop() {
value = analogRead(voltagePin);
Vout = (value * 5.0) / 1024.0;
Vin = Vout / (R2/(R1+R2));
delay(10);
analogueValue = analogRead(currentPin);
adcVoltage = analogueValue*analogueFactor;
currentValue = ((adcVoltage - ACoffset) / sensitivity);
delay(10);
Temperature = dht.readTemperature();
Humidity = dht.readHumidity();
delay(10);
lcd.setCursor(8,0);
lcd.print("U:");
lcd.print(Vin,1);
lcd.print("V");
lcd.setCursor(8,1);
lcd.print("I:");
lcd.print(currentValue,2);
lcd.print("A");
lcd.setCursor(0,0);
lcd.print("T:");
lcd.print((int)Temperature);
lcd.write(1);
lcd.print("C");
lcd.setCursor(0, 1);
Objets connectes et communication sans fil embarquée
lcd.print("H:");
lcd.print((int)Humidity);
lcd.print(" %");
delay(2000);
Serial.print (" <--La mesure numéro : ");
Serial.print(ctr);
Serial.println("-->");
Serial.print(" Voltage = ");
Serial.print(Vin);
Serial.println(" V");
Serial.print(" Current = ");
Serial.print(currentValue,2);
Serial.println(" A");
Serial.print(" Temperature = ");
Serial.print(Temperature);
Serial.print(" °C");
Serial.print(" || Humidity = ");
Serial.print(Humidity);
Serial.println(" %");
delay(1000);
ctr += 1; }
Ce code utilise un capteur DHT11 pour mesurer la température et l'humidité, ainsi que des
capteurs de courant et de tension pour mesurer l'intensité et la tension électrique. Les valeurs
sont affichées sur un écran LCD 16x2. L'écran LCD affiche que la tension est de 5.0 V, le
courant est de 0.01A, la température est de 27°C et l'humidité est de 88%.
Objets connectes et communication sans fil embarquée
TP N°2 : Transmission de données (température et
tension) en utilisant une station à base de la
Plateforme industrielle IoT G7 Modbus
Principe du système de transmission de paramètres température et tension
Le schéma illustre un système de transmission de paramètres de température et de tension
composé de plusieurs éléments :
1. Capteurs intelligents :
Mesurent la température et la tension.
Envoient les données mesurées à la passerelle via une liaison sans fil (portée d'environ
1200m).
2. Passerelle :
Reçoit les données des capteurs.
Converti les données en format Modbus.
Transmet les données au serveur via une liaison Ethernet.
3. Serveur Modbus :
Stocke les données reçues de la passerelle.
Permet l'accès aux données par des applications tierces.
Fonctionnement du système :
Les capteurs mesurent la température et la tension à intervalles réguliers.
Les capteurs envoient les données mesurées à la passerelle via une liaison sans fil.
La passerelle convertit les données en format Modbus et les transmet au serveur via une
liaison Ethernet.
Le serveur Modbus stocke les données reçues de la passerelle.
Des applications tierces peuvent accéder aux données stockées sur le serveur Modbus.
En conclusion, le système de transmission de paramètres température et tension est un outil
puissant pour surveiller et analyser les données environnementales à distance.
Objets connectes et communication sans fil embarquée
Étude du schéma en utilisant le protocole IP sur un réseau d'accès local (LAN)
1. Attribution des adresses IP :
Serveur : 192.168.2.70
Client PC : 192.168.2.197
2. Communication entre le client et le serveur :
Le client envoie une requête HTTP au serveur sur le port 6900.
La requête HTTP contient les paramètres de température et de tension à transmettre.
Le serveur reçoit la requête HTTP et extrait les paramètres.
Le serveur stocke les paramètres dans sa base de données.
Le serveur envoie une réponse HTTP au client.
3. Fonctionnement du protocole IP :
Le protocole IP est utilisé pour acheminer les paquets de données entre le client et le serveur.
L'adresse IP du client et du serveur est utilisée pour identifier les ordinateurs sur le réseau.
Le port 6900 est utilisé pour identifier le service HTTP sur le serveur.
Objets connectes et communication sans fil embarquée
Procédure de configuration du système :
-Assurez-vous que tous les composants sont installés et que le réseau local est opérationnel.
-Nous lançons l'application G.7-Setup-V2.2 en double-cliquant sur son icône.
-L'application tentera automatiquement de se connecter au serveur. Si la connexion réussit,
nous verrons un message de confirmation. Sinon, nous recevrons un message d'erreur.
-Nous activons la connexion Ethernet ou sans fil selon notre configuration.
-Une fois connectés, nous pouvons configurer le système en définissant les paramètres tels
que l'adresse IP du serveur, le port, les identifiants, l'intervalle d'envoi des données et les
paramètres de sécurité.
Même adresse
IP du serveur
Intervalle d'envoi des
données
Nombres de capteurs
Port du
serveur
Message de
confirmation et
réussite
-En suivant ces étapes, nous pourrons configurer notre système de manière efficace.
Objets connectes et communication sans fil embarquée
Système de transmission de paramètres de 4 capteurs intelligents
Le mode direct permet au client G7 de recevoir directement les données de la station de base
G7 sans passer par un serveur. Cela offre une meilleure réactivité et une réduction du temps
L'interface graphique est conviviale et permet de visualiser facilement les données.
Objets connectes et communication sans fil embarquée
Ce TP nous permettra de comprendre les bases de la transmission de données avec la
Plateforme industrielle IoT G7 Modbus.
Nous apprendrons à configurer une station G7 pour la transmission de données de température
et de tension, ainsi qu'à visualiser ces données dans une interface graphique.
À la fin du TP, nous serons en mesure de configurer une station G7 pour communiquer avec
des capteurs et des serveurs, transmettre des données via le protocole Modbus et visualiser ces
données dans une interface graphique.
Objets connectes et communication sans fil embarquée
TP N°3 : Transmission de données (Température et
Humidité) vers la Platforme IoT Cloud ThingSpeak
en utilisant l'ESP32
I-Principe
Analyse du schéma de principe du système de monitoring et de transmission de données vers
Thingspeak
Composants du système :
Capteurs : DHT11 pour la mesure de la température et de l'humidité.
Microcontrôleur : ESP32 pour la lecture des données des capteurs et leur transmission vers
Thingspeak.
Réseau WiFi : Le ESP32 se connecte à un réseau WiFi pour envoyer les données vers
Thingspeak.
Plateforme IoT cloud : Thingspeak pour le stockage et la visualisation des données.
Fonctionnement du système
-Le capteur DHT11 mesure la température et l'humidité.
-Le microcontrôleur ESP32 lit les données des capteurs.
-Le ESP32 formate les données en utilisant le format JSON.
-Le ESP32 envoie les données formatées vers Thingspeak via une requête HTTP POST.
-Thingspeak stocke les données dans sa base de données.
-Thingspeak permet de visualiser les données sous forme de graphiques et de tableaux.
Objets connectes et communication sans fil embarquée
II- Etude pratique : ESP32
III- Thingspeak :
Pour utiliser la plateforme Thingspeak, il faut d'abord créer un compte et un canal. Voici
comment procéder :
- Aller sur le site web de Thingspeak « IoT Analytics - ThingSpeak Internet of Things » et
cliquer sur le bouton Sign Up en haut à droite. S'inscrire avec un compte MathWorks, ou créer
un nouveau compte avec une adresse e-mail et un mot de passe. Un e-mail de confirmation sera
envoyé pour activer le compte.
Objets connectes et communication sans fil embarquée
- Se connecter au compte et cliquer sur le bouton Channels en haut à gauche, puis sur le bouton
My Channels. La liste des canaux, qui sont des espaces de stockage pour les données,
apparaîtra. Pour créer un nouveau canal, cliquer sur le bouton New Channel.
1
2
3
- Sur la page New Channel, personnaliser les paramètres du canal, comme le nom, la
description, les champs, l'emplacement, etc. Choisir de rendre le canal public ou privé, et de
générer des clés d'API pour contrôler l'accès aux données. Cliquer sur le bouton Save Channel
pour enregistrer le canal.
Objets connectes et communication sans fil embarquée
- Envoyer et recevoir des données au canal, en utilisant des protocoles de communication
comme HTTP ou MQTT, ou des fonctions MATLAB. Visualiser et analyser les données sur le
site web de Thingspeak,
Objets connectes et communication sans fil embarquée
Le code sur le logiciel Arduino IDE :
#include <WiFi.h>
#include "ThingSpeak.h"
#include"DHT.h"
const char* ssid = "TALHIOUIMED"; // SSID de votre réseau (nom)
const char* password = "123456789"; // votre mot de passe réseau
WiFiClient clientESP;
unsigned long myChannelNumber = 2486377; // numero de votre channel
const char * myWriteAPIKey = "2SV32LNW4M348XBY";//APIkey
// Variable de temps
unsigned long tempspre = 0;
unsigned long temps = 30000; //30s entre 2 mesures
#define DHTPIN 4 // Broche numérique connectée au capteur DHT
//TYPE DE CAPTEUR UTILISE
#define DHTTYPE DHT11
// Créer un objet capteur
DHT dht(DHTPIN, DHTTYPE);
// Variables temperature et humidite
float temperature;
float humidite;
void setup() {
Serial.begin(115200); //Initialisation de serial
dht.begin();
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password); //wifi
ThingSpeak.begin(clientESP); // Initialisation de ThingSpeak
}
void loop() {
if ((millis() - tempspre) > temps) {//la condition est vrai apres 30s
// Connecte ou reconnecte WiFi
if(WiFi.status() != WL_CONNECTED){
Serial.print("connecte ...");
while(WiFi.status() != WL_CONNECTED){
WiFi.begin(ssid, password);
delay(5000);
}
Serial.println("\nConnecte :).");
}
// lire la temperature et l'humidite
float humidite = dht.readHumidity();
float temperature = dht.readTemperature();
// Vérifiez si des lectures ont échoué et quittez plus tôt (pour réessayer).
if (isnan(humidite) || isnan(temperature)) {
Serial.println(F("Failed to read from DHT sensor!"));
return;
}
//affichage par le serial
Objets connectes et communication sans fil embarquée
Serial.print(F("Humidite: "));
Serial.print(humidite);
Serial.print(F("% Temperature: "));
Serial.print(temperature);
Serial.print(F("°C "));
// definir les fields avec les values
ThingSpeak.setField(1, temperature);
ThingSpeak.setField(2, humidite);
// tester si les donnees sont envoye
int x = ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey);
if(x == 200){
Serial.println("les donnees sont envoye avec succe.");
}
else{
Serial.println("Probleme ud'envoyer des donnees. HTTP error code " +
String(x));
}
tempspre = millis();//change le temps precedent par le temps actuel
}
}
Ce TP nous permettra de comprendre les bases de la transmission de données vers la
plateforme IoT Cloud ThingSpeak en utilisant l'ESP32.
Plus précisément, nous allons apprendre à :
-Comprendre le fonctionnement de l'ESP32 et de la plateforme ThingSpeak.
-Configurer l'ESP32 pour la communication avec les capteurs de température et d'humidité.
-Développer un programme pour lire les données des capteurs et les envoyer vers
ThingSpeak.
-Visualiser les données transmises dans l'interface graphique de ThingSpeak.
À l'issue de ce TP, nous serons en mesure de :
-Mettre en place un système de monitoring simple pour la température et l'humidité.
-Transmettre des données vers une plateforme IoT Cloud.
-Visualiser les données transmises dans une interface graphique.
Ce TP nous donne les bases nécessaires pour réaliser des applications plus complexes de
transmission de données avec l'ESP32 et ThingSpeak.
