TP 1 : ENVOI DE DONNEES VERS THINGSPEAK.

I. OBJECTIF :

L'objectif de ce TP est de permettre aux étudiants de comprendre et d'apprendre à utiliser la plateforme

ThingSpeak pour la collecte, la visualisation et l'analyse de données issues de capteurs en temps réel.
Plus précisément, les étudiants seront amenés à :
- Configurer un canal sur ThingSpeak pour recevoir et stocker des données envoyées par des
capteurs.
- Programmer un microcontrôleur (ESP32) pour lire les valeurs de capteurs physiques (température,
humidité, etc.).
- Envoyer des données de manière périodique depuis les capteurs vers le canal ThingSpeak en
utilisant des requêtes HTTP.
- Visualiser et analyser les données envoyées à l'aide des outils de graphiques fournis par
ThingSpeak.
- Comprendre le fonctionnement d'un système IoT et les applications possibles de ce type
d'architecture dans divers domaines.

II. ESP 32 :

L'ESP32 est un microcontrôleur puissant et polyvalent qui offre plusieurs fonctionnalités intégrées, y
compris la connectivité Wi-Fi et Bluetooth, des broches GPIO, des PWM, des ADC, des DAC, et bien
plus encore. Il possède également un capteur de température intégré, mais ce capteur ne mesure que la
température du noyau du microcontrôleur lui-même, ce qui est utile pour surveiller la surchauffe ou la
gestion de l'énergie du module.
 L'image montre un schéma des broches (pins) d'une carte ESP32, basée sur le module ESP-
WROOM-32. L’image étiquette chaque broche avec son numéro GPIO et ses fonctionnalités. Voici
les principaux points :

 Alimentation et GND :
o VIN et 3.3V : Pins pour l'alimentation.
o GND : Broches de masse.
 ADC (Analog-to-Digital Converter) :
o Broches marquées ADC1_x et ADC2_x permettent de lire des signaux analogiques.
1
 DAC (Digital-to-Analog Converter) :
o DAC1 (GPIO25) et DAC2 (GPIO26) : Broches pour convertir des signaux numériques en
signaux analogiques.
 SPI (Serial Peripheral Interface) : Broches dédiées à la communication SPI, comme
HSPI_CLK (GPIO14), HSPI_MISO (GPIO12), HSPI_MOSI (GPIO13).
 I2C (Inter-Integrated Circuit) :
o SCL (GPIO22) et SDA (GPIO21) : Pins pour la communication I2C.
 UART (Universal Asynchronous Receiver-Transmitter) :
o U0_TXD (GPIO1) et U0_RXD (GPIO3) : Pins pour la communication UART.
o Il existe également des broches UART secondaires, comme U2_TXD (GPIO17) et
U2_RXD (GPIO16).
 Touch : Broches marquées Touch_x sont pour les entrées tactiles.
 PWM (Pulse Width Modulation) : Certaines broches, comme GPIO2, sont compatibles avec
le contrôle de signaux PWM.
 Notes sur certaines broches GPIO :
- GPIO 0 : Sortie PWM au démarrage, doit être LOW pour entrer en mode flash.
- GPIO 1 (TX pin) : Utilisée pour le débogage au démarrage.
- GPIO 3 (RX pin) : HIGH au démarrage.
- GPIO 2 : Connectée à une LED intégrée, doit être laissée flottante ou LOW pour entrer en
mode flash.
- GPIOs 6 à 11 : Connectées au SPI flash intégré, déconseillées pour une utilisation en général.
- GPIO 15 : Signal PWM au démarrage, pin de configuration.
- GPIO 34 à 39 : Entrées uniquement, pas utilisables en sortie.
- Comportement au démarrage : Certaines broches, comme les GPIO 0, 2, 4, 5, 12, 15, et
3, ont des comportements spécifiques au démarrage ou sont utilisées pour la configuration
(strapping pins). Leur utilisation peut nécessiter des précautions.
 III. INSTALLATION ET UTILISATION DE LA CARTE ESP32 DANS L’IDE ARDUINO :

Avant de commencer la procédure d’installation, vous devez avoir Arduino IDE installé sur votre
ordinateur. Il existe deux versions de l’IDE Arduino que vous pouvez installer : la version 1 et la
version 2. Vous pouvez télécharger et installer Arduino IDE en cliquant sur le lien suivant :
arduino.cc/en/Main/Software
Quelle version de l’IDE Arduino recommandons-nous ? À l’heure actuelle, il existe quelques
plugins pour l’ESP32 (comme le SPIFFS Filesystem Uploader Plugin) qui ne sont pas encore pris en
2 charge sur Arduino 2. Donc, si vous avez l’intention d’utiliser le plugin SPIFFS à l’avenir, nous vous

recommandons d’installer l’ancienne version 1.8.X. Il vous suffit de

faire défiler la page du logiciel Arduino pour le trouver.
1. Installation de ESP32 dans l’IDE Arduino :
Pour installer la carte ESP32 dans votre IDE Arduino, suivez les
instructions suivantes :
A. Dans votre IDE Arduino, allez dans Fichier> Préférences :

B. Entrez ce qui suit dans le champ « URL supplémentaires du

gestionnaire de carte » :
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-
pages/package_esp32_index.json

Ensuite, cliquez sur le bouton « OK ».

 C. Allez dans Outils > Type de carte > Gestionnaire des cartes...

3
D. Recherchez ESP32 et appuyez sur le bouton d’installation pour le « ESP32 by Espressif Systems
»:

Voilà. Il devrait être installé après quelques secondes.

2. Utilisation de ESP32 dans l’IDE Arduino :

Branchez la carte ESP32 sur votre ordinateur. Avec votre IDE Arduino ouvert, procédez comme suit :
A. Sélectionnez votre carte dans le menu Outils > Type de carte (dans notre cas, il s’agit du ESP 32
WROOM-DA Module)
 B. Sélectionnez le port (si vous ne voyez pas le port COM dans votre IDE Arduino, vous devez
installer les pilotes VCP CP210x USB vers UART Bridge) :

IV. Travail Pratique:

1. STATION METEO AVEC DHT11 ET THINGSPEAK.

1.1.Objectif :
- Construire une station météorologique domestique miniature
- Recevoir les données de température sur la Platform thingspeak.
1.2.Introduction :

Pour mesurer la température de l'environnement environnant, il est effectivement nécessaire

d'utiliser un capteur de température externe. Voici quelques exemples de capteurs de température
couramment utilisés avec l'ESP32 pour mesurer la température ambiante :

 DHT11/DHT22 : Ces capteurs de température et d'humidité sont populaires en raison de leur

simplicité d'utilisation et de leur faible coût. Le DHT22 offre une meilleure précision et une
plage de mesure plus large que le DHT11.
 DS18B20 : Ce capteur de température numérique est connu pour sa précision et sa capacité à
mesurer des températures sur une large plage (-55°C à +125°C). Il utilise un bus 1-Wire, ce qui
permet de connecter plusieurs capteurs à une seule broche de l'ESP32.
 BME280 : Ce capteur avancé peut mesurer la température, l'humidité, et la pression
barométrique. Il est très précis et est souvent utilisé dans des projets nécessitant des mesures
environnementales complètes.
 BMP180/BMP280 : Ces capteurs sont similaires au BME280 mais mesurent uniquement la
pression barométrique et la température. Ils sont également utilisés pour des applications de
surveillance environnementale.

Ces capteurs peuvent être facilement interfacés avec l'ESP32 via des protocoles de communication
tels que I2C ou 1-Wire. Selon le capteur choisi, vous pourrez surveiller les conditions
 environnementales dans des espaces tels que la maison, le jardin, ou le bureau et utiliser ces
données pour diverses applications IoT.

1.3.Description du projet :

Dans ce TP, nous allons apprendre à interfacer le DHT11 (capteur de température et d’humidité) avec
l’ESP32. Plus loin dans ce TP, nous verrons comment partager les lectures de capteur obtenues à partir
du capteur DHT11 vers un serveur Web.
DHT11 (un capteur de température et d’humidité) :
DHT11 est utilisé pour mesurer l’humidité et la température de son environnement. Il surveille la
5
température ambiante et l’humidité d’une zone donnée. Il se compose d’un capteur de température
NTC (coefficient de température négatif) et d’un capteur d’humidité de type résistif. Il se compose
également d’un microcontrôleur 8 bits. Le microcontrôleur est chargé d’effectuer l’ADC (conversion
analogique-numérique) et fournit une sortie numérique sur le protocole à fil unique.
Le capteur DHT11 peut mesurer l’humidité de 20% à 90% avec une précision de +-5% (HR ou
humidité relative) et peut mesurer la température dans la plage de 0 degrés Celsius à 50 degrés Celsius
avec une précision de +-2C.
Les capteurs DHT11 peuvent également être utilisés pour mettre en œuvre un système de capteurs
filaires à l’aide d’une longueur de câble allant jusqu’à 20 mètres.
Il existe deux modules DHT (DHT11 et DHT22) disponibles sur le marché pour mesurer la
température et l’humidité. L’objectif des deux modules est le même, mais avec des spécifications
différentes. Comme le capteur DHT22 offre des plages de sensibilité à la température et à l’humidité
plus larges. Mais le DHT22 est plus coûteux que le DHT11. Ainsi, vous pouvez préférer utiliser
n’importe quel module, selon vos besoins.
1.4.Montage à réaliser :
Pour connecter le capteur DHT11 à l'ESP32 avec la broche de
données connectée à la broche GPIO 13, vous pouvez suivre les
étapes ci-dessous. Le DHT11 est un capteur de température et
d'humidité numérique qui communique avec le microcontrôleur via
une interface à une seule broche.
1.4.1. Connexions :
1.4.1.1.VCC du DHT11 → 5V ou 3.3V de l'ESP32
1.4.1.2.GND du DHT11 → GND de l'ESP32
1.4.1.3.Data du DHT11 → GPIO 4 de l'ESP32
RQ : GPIOs recommandés pour le DHT11 : GPIO 4, GPIO 5, GPIO 12, GPIO 13, GPIO 14, GPIO 16, GPIO 17, GPIO
18, GPIO 19, GPIO 21, GPIO 22, GPIO 23
 1.4.2. Ajout des bibliothèques requis dans L’IDE arduino :
6
Le capteur DHT11 utilise un protocole à fil unique pour communiquer des données, ce qui nécessite
un timing précis. Afin d’interfacer le capteur DHT11 avec le module ESP32, il est nécessaire d’ajouter
les bibliothèques nécessaires. Pour installer la bibliothèque de capteurs DHT11 ;
A. Accédez à Outils >> Gérer les bibliothèques.

B. Tapez DHT dans la barre de recherche et installez la bibliothèque de capteurs DHT

comme indiqué ci-dessous.

C. Suivez le lien ci-dessous pour télécharger la bibliothèque Arduino ThingSpeak :

https://github.com/mathworks/thingspeak-arduino

D. Allez dans Esquisse >> Inclure la bibliothèque >> Ajouter .ZIP bibliothèque et
sélectionnez le fichier zip téléchargé.
 1.5.Le code arduino :

#include <WiFi.h>
#include <DHT.h>
#include <HTTPClient.h>

// Remplacez ces valeurs par les informations de votre réseau Wi-Fi

const char* ssid = "XXXXXXXXXXXX";
const char* password = "XXXXXXXXXX";

// Remplacez ces valeurs par celles de votre canal ThingSpeak

const char* thingSpeakServer = "http://api.thingspeak.com/update";
const char* apiKey = "XXXXXXXXXXX";
7
// Définir le type de capteur et la broche de connexion
#define DHTPIN 4 // Broche de données du DHT11 sur ESP32
#define DHTTYPE DHT11 // Définir le type de capteur comme DHT11

DHT dht(DHTPIN, DHTTYPE);

void setup() {
// Initialiser la communication série
Serial.begin(115200);

// Initialiser le capteur DHT11

dht.begin();

// Connexion au réseau Wi-Fi

WiFi.begin(ssid, password);
Serial.print("Connexion au réseau Wi-Fi");

while (WiFi.status() != WL_CONNECTED) {

delay(500);
Serial.print(".");
}

Serial.println();
Serial.println("Connecté au réseau Wi-Fi");
Serial.print("Adresse IP : ");
Serial.println(WiFi.localIP());
}
void loop() {
// Attendre un peu entre les lectures
delay(2000);

// Lire l'humidité en pourcentage

float humidity = dht.readHumidity();
// Lire la température en degrés Celsius
float temperature = dht.readTemperature();

// Vérifier si les lectures ont échoué

if (isnan(humidity) || isnan(temperature)) {
Serial.println("Échec de la lecture du capteur !");
return;
}
 // Afficher les valeurs sur le moniteur série
Serial.print("Humidité: ");
Serial.print(humidity);
Serial.print(" %\t");
Serial.print("Température: ");
Serial.print(temperature);
Serial.println(" *C");
// Envoyer les données à ThingSpeak
if (WiFi.status() == WL_CONNECTED) {
HTTPClient http;

String url = String(thingSpeakServer) + "?api_key=" + apiKey + "&field1=" + temperature + "&field2="

8 + humidity;

http.begin(url);
int httpResponseCode = http.GET();

if (httpResponseCode > 0) {
String response = http.getString();
Serial.println("Réponse de ThingSpeak : " + response);
} else {
Serial.println("Erreur lors de la connexion à ThingSpeak");
}

http.end();
} else {
Serial.println("Erreur de connexion Wi-Fi");
}
}

1.6.Démarrer avec ThingSpeak :

A. Créez un canal sur le serveur MathWorks en cliquant sur le bouton Nouveau canal. Dans cette
étape, nous créons deux champs. Le premier représente la température et l’autre représente
l’humidité mesurée à l’aide du capteur DHT11. Vous pouvez également ajouter d’autres champs
selon vos besoins.
- Le service web ThingSpeak permet à son utilisateur de créer et d’enregistrer gratuitement un maximum de 4 chaînes.,Si
vous souhaitez accéder à plus de chaînes, vous devez effectuer un paiement pour cela.

 B. Une nouvelle URL contenant les détails de la chaîne et les statistiques de la chaîne s’ouvrira une
fois que vous aurez créé la chaîne. Sur la même page/URL, les clés API sont disponibles pour les
services de lecture et d’écriture.

C. Allez dans Clés API et copiez la clé API d’écriture et collez-la dans votre code IDE Arduino. Pour
que l’ESP32 puisse envoyer ou écrire les relevés du capteur DHT sur le serveur MathWorks.
D. Apportez les modifications requises dans le code ci-dessus et les modifications requises
comprennent, les informations d’identification du réseau (SSID et mot de passe), la clé API, le
numéro de chaîne, etc.
 E. Compilez et téléchargez le programme ci-dessus dans le développement ESP32 après avoir
sélectionné la carte de développement et le port COM appropriés.

2. Détection de fumée et gaz :

2.1. Objectifs :

Dans cette application, vous apprendrez à :

 Construire un système de détection des fuites de gaz intelligent.

 Configurez thingspeak pour surveiller les valeurs à distance.
9
2.2. Le capteur du gaz MQ 4 :

Le capteur de gaz MQ-4 est un capteur qui détecte principalement le méthane (CH4) ainsi que

d'autres gaz combustibles comme le butane et le propane. Ce capteur est souvent utilisé dans

des systèmes de détection de gaz pour surveiller les niveaux de gaz inflammables dans un

environnement donné.

2.3. Matériel nécessaire

 ESP32
 Capteur de gaz MQ-4
 fils de connexion
 Source d'alimentation (par exemple via USB pour l'ESP32)
 Compte ThingSpeak pour envoyer des données dans le cloud.

2.4.Schéma de connexion

Connectez le capteur MQ-4 à l'ESP32 comme suit :

 VCC du MQ-4 -> 3.3V ou 5V de

l'ESP32
 GND du MQ-4 -> GND de l'ESP32
 A0 du MQ-4 -> GPIO 34 de l'ESP32
(entrée analogique pour la lecture du
signal).

RQ : La broche VIN sur l'ESP32 fournit une

tension de 5V lorsque l'ESP32 est alimenté
via le port USB. Elle peut être utilisée pour
alimenter des capteurs ou modules qui
nécessitent du 5V.
 2.5. Le code arduino :

#include <WiFi.h>
#include "ThingSpeak.h"

// Paramètres du WiFi
const char* ssid = "XXXXXXXXXXXXXX";
const char* password = "XXXXXXXXXX";

// Paramètres ThingSpeak
10 unsigned long channelID = XXXXXX; // Remplacez par votre ID de channel
const char* writeAPIKey = "XXXXXXXXXXX"; // API Key de ThingSpeak
const char* server = "api.thingspeak.com";
WiFiClient client;

// Pin du capteur MQ-4 (entrée analogique)

int gasPin = 34; // GPIO34
Serial.begin(115200);
void setup() {
// Initialisation du WiFi
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("Connexion au WiFi...");
}
Serial.println("Connecté au WiFi");
// Connexion à ThingSpeak
ThingSpeak.begin(client);
}
void loop() {

// Lire la valeur analogique du capteur de gaz MQ-4

int sensorValue = analogRead(gasPin);
// Conversion en concentration de gaz (par exemple en ppm si vous avez la formule)
float gasConcentration = map(sensorValue, 0, 4095, 0, 100); // Conversion basique, à ajuster
selon vos tests
Serial.print("Concentration de gaz : ");
Serial.println(gasConcentration);

// Envoyer la donnée à ThingSpeak

ThingSpeak.setField(1, gasConcentration);
int result = ThingSpeak.writeFields(channelID, writeAPIKey);
if (result == 200) {
Serial.println("Données envoyées avec succès à ThingSpeak");
} else {
Serial.println("Erreur lors de l'envoi des données");
}
delay(15000); // Attendre 15 secondes avant la prochaine lecture
}
 2.6.Travail demandé :

Configurer et programmer un système qui capture les données d'un capteur du gaz (par exemple, un
capteur MQ4) et les envoie à la plateforme ThingSpeak pour visualiser les données en temps réel
sous forme de graphique.
Les étudiants se concentrer sur plusieurs aspects pratiques :
 Configuration du capteur de distance avec un microcontrôleur (ESP32, etc.).
 Programmation pour capturer les données du capteur.
 Envoi des données à ThingSpeak via une API.
11  Visualisation des données sur la plateforme.
 Configuration d’un service comme ThingHTTP pour envoyer des e-mails en cas de détection
de fuite.

3. Capteur de Distance Ultrason HC-SR04 :

3.1.Objectif

Mesurer la distance à l'aide d'un capteur ultrason et envoyer les données mesurées sur ThingSpeak
pour les visualiser sous forme de graphique.

3.2. Description du fonctionnement :

Un capteur ultrason (ou capteur à ultrasons)

est un dispositif qui utilise des ondes sonores
à haute fréquence, au-delà de la portée de
l'audition humaine, pour détecter la distance
entre lui et un objet. Il fonctionne en
émettant des impulsions ultrasonores et en
mesurant le temps que mettent ces ondes à
revenir après avoir été réfléchies par un objet. Voici le processus détaillé de fonctionnement :

 Émission des ondes ultrasonores

Le capteur possède un émetteur (souvent un transducteur piézoélectrique) qui génère des ondes
sonores à haute fréquence, généralement autour de 40 kHz, ce qui est au-delà de la gamme audible par
l’oreille humaine.

 Propagation des ondes : Les ondes ultrasonores se propagent dans l’air en ligne droite. La vitesse
de propagation est d’environ 343 m/s à température ambiante (20 °C).
  Réflexion sur un objet : Lorsqu'une onde rencontre un objet ou un obstacle sur son chemin, elle
est partiellement réfléchie vers le capteur.
 Réception des ondes réfléchies : Le récepteur (généralement un autre transducteur ou un capteur
intégré) capte les ondes ultrasonores réfléchies par l’objet. Le capteur mesure alors le temps
écoulé entre l’émission de l’onde et la réception du signal réfléchi.
 Calcul de la distance : Le capteur utilise le temps mesuré pour calculer la distance de l’objet. La
formule utilisée est :

Temps mesuré × Vitesse du son

12 Distance ∶
2

La division par 2 est nécessaire, car l’onde ultrasonore fait un aller-retour entre le capteur et l’objet.

10×10−3 ×343 m\s

Exemple de calcul : Si le temps mesuré est de 10 millisecondes (ms), la distance est calculée comme suit : Distance = = 1.715 𝑚
2

L’objet est donc à 1,715 mètre du capteur.

 Sortie du signal :

La distance calculée est ensuite sortie sous forme de signal électrique (souvent numérique ou
analogique) et peut être utilisée pour des actions spécifiques comme l’activation d’une alarme ou le
contrôle d’un robot.

3.3.Connexion du capteur ultrason au microcontrôleur :

Le capteur ultrason HC-SR04 fonctionne en envoyant une impulsion sonore et en mesurant le temps
que met l'écho à revenir.

Connectez le capteur ultrason HC-SR04 à l'ESP32 comme suit :

 VCC du capteur -> 3.3V ou 5V de l'ESP32

 GND du capteur -> GND de l'ESP32
 Trig du-> GPIO 12 de l'ESP32.
 Echo du-> GPIO 14 de l'ESP32.
 3.4.Le code Arduino :

#include <WiFi.h>
#include <HTTPClient.h>

// Remplacez ces valeurs par les informations de votre réseau Wi-Fi

const char* ssid = "XXXXXXXXXXXX";
const char* password = "XXXXXX";

// Remplacez ces valeurs par celles de votre canal ThingSpeak

const char* thingSpeakServer = "http://api.thingspeak.com/update";
const char* apiKey = "XXXXXXXXXXXXXXXx";

// Définir le type de capteur et la broche de connexion

13 int trig = 12 ;
int echo = 14 ;
long duree;
float distance ;

void setup() {
// Initialiser la communication série
Serial.begin(115200);

// Initialiser le capteur DHT11

pinMode(trig, OUTPUT );
pinMode(echo, INPUT );
// Connexion au réseau Wi-Fi
WiFi.begin(ssid, password);
Serial.print("Connexion au réseau Wi-Fi");

while (WiFi.status() != WL_CONNECTED) {

delay(500);
Serial.print(".");
}

Serial.println();
Serial.println("Connecté au réseau Wi-Fi");
Serial.print("Adresse IP : ");
Serial.println(WiFi.localIP());
}

void loop() {
// Attendre un peu entre les lectures
delay(2000);

// impulsion de 10 us sur la broche trig => déclenchement de la mesure

digitalWrite(trig, 1 );
delayMicroseconds(10);
digitalWrite(trig, 0 );
// lecture de la durée d'état haut de l'impulsion en us
duree = pulseIn(echo, HIGH);
distance = 0.017 * duree ;

// Vérifier si les lectures ont échoué

if (isnan(distance)) {
Serial.println("Échec de la lecture du capteur !");
return;
}

// Afficher les valeurs sur le moniteur série

Serial.print("distance en cm : ");
Serial.println(distance);
delay(1000);

http.end();
} else {
Serial.println("Erreur de connexion Wi-Fi");
}
 // Envoyer les données à ThingSpeak
if (WiFi.status() == WL_CONNECTED) {
HTTPClient http;

String url = String(thingSpeakServer) + "?api_key=" + apiKey + "&field1=" + distance;

http.begin(url);
int httpResponseCode = http.GET();

if (httpResponseCode > 0) {
String response = http.getString();
Serial.println("Réponse de ThingSpeak : " + response);
} else {
Serial.println("Erreur lors de la connexion à ThingSpeak");
}
14
http.end();
} else {
Serial.println("Erreur de connexion Wi-Fi");
}
}

3.5.Travail demandé :

Configurer et programmer un système qui capture les données d'un capteur de distance (par exemple,
un capteur à ultrasons) et les envoie à la plateforme ThingSpeak pour visualiser les données en temps
réel sous forme de graphique.
Les étudiants se concentrer sur plusieurs aspects pratiques :
 Configuration du capteur de distance avec un microcontrôleur (ESP32, etc.).
 Programmation pour capturer les données du capteur.
 Envoi des données à ThingSpeak via une API.
 Visualisation des données sur la plateforme.
 Configuration d’un service comme ThingHTTP pour envoyer des e-mails..
4. Capteur du Mouvement PIR :
4.1.Objectif

Détecter le mouvement à l'aide d'un capteur du mouvement PIR et envoyer les données mesurées sur
ThingSpeak pour les visualiser sous forme de graphique.

4.2. Description du fonctionnement :

Un capteur de mouvement PIR (Passive InfraRed) est un dispositif utilisé pour détecter la présence
d'une personne ou d'un animal en mesurant les variations d'énergie infrarouge dans son champ de
vision. Les capteurs PIR sont appelés "passifs" parce qu'ils ne génèrent pas eux-mêmes d'énergie
infrarouge, mais détectent plutôt celle émise par les corps chauds, comme les humains et les animaux.
Voici comment ils fonctionnent :
  Réception infrarouge : Le capteur est conçu pour détecter les variations d'énergie infrarouge
qui proviennent d'objets dans son champ de vision. Lorsque quelque chose de chaud, comme
un corps humain, se déplace, il change la distribution de l'énergie infrarouge.
 Lentilles de Fresnel : Souvent, le capteur est équipé d'une lentille de Fresnel qui permet
d'amplifier et de concentrer les signaux infrarouges sur le détecteur. Cela aide à couvrir un
champ de vision plus large.
 Détection du mouvement : Lorsque le capteur PIR détecte un changement brusque d'énergie
(par exemple, une personne qui se déplace), il déclenche une alerte ou une action (comme

15 allumer une lumière ou activer un système d'alarme).

Le capteur PIR est populaire parce qu'il est économique, fiable et fonctionne bien dans de nombreuses
applications où la détection de mouvement est nécessaire.

4.3.Connexion du capteur PIR à l'ESP32

Connectez les broches du capteur PIR à l'ESP32 :

- VCC du capteur PIR à 3V3 (ou 5V selon le modèle du PIR) de l'ESP32.

- GND du capteur PIR à GND de l'ESP32.
- OUT du capteur PIR à une broche GPIO libre sur l'ESP32 (par exemple, GPIO 13).
16

4.4.Code arduino :

#include <WiFi.h>
#include <HTTPClient.h>

const char* ssid = "XXXXXXXXXXXXX";

const char* password = "XXXXXXXX";

// Remplacez par votre clé API ThingSpeak

const String apiKey = "XXXXXXXXXXXXXXXX";
const String channelID = "XXXXXXX"; // Remplacez par votre ID de canal

const String thingSpeakURL = "https://api.thingspeak.com/update";

const int pirPin = 13; // Broche connectée au OUT du PIR

void setup() {
Serial.begin(115200);
pinMode(pirPin, INPUT);

WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("Connected to WiFi");
}
void loop() {
int sensorValue = digitalRead(pirPin);
if (sensorValue == HIGH) {
sendData(1); // Mouvement détecté
} else {
sendData(0); // Aucun mouvement
}
delay(10000); // Envoie les données toutes les 10 secondes
}
 void sendData(int value) {
if (WiFi.status() == WL_CONNECTED) {
HTTPClient http;
String url = thingSpeakURL + "?api_key=" + apiKey + "&field1=" + String(value);

http.begin(url);
int httpCode = http.GET();

if (httpCode > 0) {
String payload = http.getString();
Serial.println("Data sent: " + String(value));
Serial.println("Response: " + payload);
} else {
Serial.println("Error in sending data");
17 }
http.end();
} else {
Serial.println("Not connected to WiFi");
}
}

4.5.Travail demandé :

Configurer et programmer un système qui capture les données d'un capteur du mouvement (par
exemple, un capteur PIR) et les envoie à la plateforme ThingSpeak pour visualiser les données en
temps réel sous forme de graphique.
V. Travail théorique :

 Décrivez les principales couches d’une architecture IoT et le rôle de chaque couche dans les
systèmes que vous avez mis en place pour ce TP.
 Expliquez l'architecture IoT mise en place dans ce TP. Quels sont les rôles du capteur, du
microcontrôleur (ESP32) et de la plateforme ThingSpeak ?
 Quel rôle joue l'ESP32 dans l'architecture IoT de ce TP ? Comment agit-il comme passerelle
entre les capteurs et le cloud (ThingSpeak) ?
 Pourquoi est-il important d'avoir une connectivité Wi-Fi dans l'ESP32 pour ce type
d'architecture IoT ? Quelles seraient les alternatives ?
 Quel est le rôle du cloud (ThingSpeak) dans cette architecture IoT ? Quels sont les avantages
de traiter et stocker les données dans le cloud par rapport à un traitement local ?
 Comment ThingSpeak gère-t-il les données provenant de plusieurs capteurs dans une
architecture distribuée IoT ?
 Comment cette architecture IoT (ESP32 + ThingSpeak) pourrait-elle être mise à l’échelle pour
gérer un plus grand nombre de capteurs ou de nœuds dans une application industrielle ?
 Donnez des exemples d’applications concrètes où un système similaire, utilisant l'ESP32 et
ThingSpeak, pourrait être déployé dans l’agriculture ou la santé.