Les objets connectés (IoT) : de l’ESP32 au tableau de bord
Cours pour BTS EII, 2ème année : comprendre l’architecture d’un objet connecté, maîtriser les protocoles HTTP et MQTT, programmer l’ESP32, installer un serveur sur Raspberry Pi (Mosquitto, Node-RED, Flask) et réaliser une station météo connectée. Chaque animation a ses boutons d’étapes et chaque exercice a sa correction.
Chapitre 1 : Qu’est-ce que l’Internet des objets ?
1.1 Définition
L’Internet des objets (IoT, Internet of Things) désigne des objets physiques équipés de capteurs, d’un petit calculateur et d’une connexion réseau, qui échangent des données avec des serveurs ou d’autres objets : une station météo qui envoie la température, une serrure ouverte depuis un téléphone, un compteur d’eau qui signale une fuite. La différence avec un système embarqué classique (un STM32 qui allume une LED) : l’objet est connecté, donc on peut le surveiller et le commander à distance, stocker et analyser ses données, mais il faut aussi le sécuriser et le mettre à jour.
1.2 L’architecture en quatre couches
| Couche | Rôle | Exemples de ce cours |
|---|---|---|
| 1. Perception | mesurer et agir | DHT22, TMP36, LED, ESP32 |
| 2. Réseau | transporter les données | Wi-Fi, TCP/IP, protocoles MQTT et HTTP |
| 3. Plateforme | recevoir, traiter et stocker | Mosquitto, Node-RED, Flask, SQLite (sur Raspberry Pi) |
| 4. Application | présenter à l’utilisateur | tableau de bord Node-RED, application mobile |
1.3 Le voyage d’une mesure
Suis une mesure de température du capteur jusqu’à l’écran :
1.4 Notre projet fil rouge : la station météo connectée
Tout au long du cours on construit la même station : un ESP32 lit un DHT22 et publie les mesures en MQTT ; un Raspberry Pi héberge le broker Mosquitto, Node-RED (tableau de bord et alertes) et une API Flask avec une base SQLite ; un navigateur et un téléphone affichent les résultats.
1.5 Exercices
Exercice 1.1. Place chaque élément dans sa couche : DHT22, Wi-Fi, Mosquitto, tableau de bord, ESP32, Flask + SQLite, 4G, application mobile.
Exercice 1.2. Remets dans l’ordre : (a) le broker distribue le message, (b) l’ESP32 lit le capteur, (c) le tableau de bord affiche la valeur, (d) l’ESP32 publie le message sur le Wi-Fi, (e) Node-RED reçoit et traite la mesure.
Exercice 1.3. Donne trois différences entre un système embarqué isolé et un objet connecté.
Chapitre 2 : Le matériel : ESP32 et capteurs
2.1 L’ESP32
L’ESP32 (société Espressif) est un microcontrôleur à deux cœurs, avec Wi-Fi (2,4 GHz) et Bluetooth intégrés, programmable avec l’IDE Arduino. Une carte « DevKit » ajoute le régulateur 3,3 V, la prise USB et l’interface de programmation.
| Caractéristique | Valeur (ESP32 classique) |
|---|---|
| Processeur | 2 cœurs, jusqu’à 240 MHz |
| Mémoire | environ 520 Ko de RAM ; flash externe (souvent 4 Mo) |
| Communication | Wi-Fi 2,4 GHz, Bluetooth classique et BLE |
| Entrées/sorties | GPIO en 3,3 V (non tolérantes au 5 V), I2C, SPI, UART, PWM |
| Convertisseur analogique | ADC 12 bits (0 à 4095) |
2.2 Les capteurs courants
| Capteur | Mesure | Interface | Remarques |
|---|---|---|---|
| DHT22 | température et humidité | 1 fil numérique | environ ±0,5 °C et ±2 à 5 % d’humidité ; une mesure toutes les 2 s au maximum |
| DHT11 | température et humidité | 1 fil numérique | moins précis (±2 °C), moins cher |
| DS18B20 | température | 1-Wire | étanche possible, plusieurs capteurs sur un fil |
| BME280 | température, humidité, pression | I2C (0x76 ou 0x77) | précis, adapté à une station météo |
| TMP36 | température | analogique | 10 mV par °C avec 500 mV de décalage, alimentable en 3,3 V |
| LM35 | température | analogique | 10 mV par °C, alimentation d’au moins 4 V |
| NTC 10 kΩ | température | pont diviseur + ADC | non linéaire, calcul avec le coefficient B |
| LDR, PIR… | lumière, présence | analogique, numérique |
2.3 Câblage
Capteur numérique DHT22 (le DATA va sur GPIO4) :
Capteur analogique TMP36 sur une entrée ADC1 :
Capteur NTC avec un pont diviseur :
Câblage complet du projet : DHT22, une LED commandable à distance (GPIO2) et un bouton (GPIO13, à lire avec INPUT_PULLUP) :
2.4 De la valeur ADC à la grandeur physique
L’ADC 12 bits donne un nombre N de 0 à 4095. Avec une référence de 3,3 V : V = N / 4095 × 3,3. Un pas vaut 3,3 V / 4095 ≈ 0,806 mV. Pour un TMP36 : T = (V − 0,5) × 100. Essaie l’outil :
analogReadMilliVolts() (cœur Arduino-ESP32 2.x), qui applique une calibration.2.5 Exercices
Exercice 2.1. Avec un TMP36, l’ADC renvoie 700 puis 1000. Calcule la tension et la température dans chaque cas.
Exercice 2.2. Quelle variation de température (en °C) correspond à un pas de l’ADC avec un TMP36 ? Est-ce suffisant pour mesurer à 0,1 °C près ?
Exercice 2.3. Un pont diviseur (3,3 V, R fixe 10 kΩ, NTC 10 kΩ à 25 °C, B = 3950, NTC vers la masse) donne N = 1500. Calcule la résistance de la NTC puis la température.
Exercice 2.4. Un capteur analogique est branché sur GPIO25 et le Wi-Fi est activé : les valeurs sont fausses ou nulles. Pourquoi ? Quelle solution ?
Exercice 2.5. Pourquoi ne faut-il pas lire un DHT22 toutes les 100 ms ? Quelle période minimale ?
Chapitre 3 : Les réseaux et les protocoles de l’IoT
3.1 Choisir un réseau
| Réseau | Portée | Débit | Consommation | Usage typique |
|---|---|---|---|---|
| Wi-Fi | dizaines de mètres | élevé | forte | objet alimenté, dans un bâtiment (notre projet) |
| Bluetooth LE | quelques mètres | faible à moyen | très faible | bracelet, capteur près d’un téléphone |
| Zigbee / Thread | dizaines de mètres, maillé | faible | faible | domotique |
| LoRa / LoRaWAN | plusieurs km | très faible | très faible | capteur sur batterie, champs, villes |
| 4G, NB-IoT, LTE-M | réseau mobile | faible à élevé | moyenne à faible | objet mobile, sans Wi-Fi |
Les valeurs sont des ordres de grandeur : elles dépendent du matériel et des conditions. Règle de choix : alimenté et près d’un routeur → Wi-Fi ; sur batterie, très longue portée → LoRaWAN ; près d’un téléphone → Bluetooth LE.
3.2 La pile TCP/IP, adresses et ports
3.3 HTTP et les API REST
HTTP fonctionne en requête / réponse : le client (l’ESP32, un navigateur) demande, le serveur (Flask) répond. Une API REST expose des ressources avec des URL et des méthodes :
| Méthode | Action | Exemple |
|---|---|---|
| GET | lire | GET /api/mesures/derniere |
| POST | créer | POST /api/mesures (corps JSON) |
| PUT | remplacer | PUT /api/stations/1 |
| DELETE | supprimer | DELETE /api/mesures/12 |
| Code | Signification | Dans notre API |
|---|---|---|
| 200 OK | succès | lecture réussie |
| 201 Created | ressource créée | mesure enregistrée |
| 400 Bad Request | requête invalide | JSON absent ou champ manquant |
| 404 Not Found | introuvable | aucune mesure en base |
| 422 Unprocessable Entity | données incohérentes | température hors limites |
| 500 Internal Server Error | bug du serveur | erreur dans le code Flask |
Une requête HTTP réelle de l’ESP32 vers Flask :
POST /api/mesures HTTP/1.1
Host: 192.168.1.50:5000
Content-Type: application/json
Content-Length: 56
{"station":"tanger1","temperature":23.4,"humidite":61.2}
Le corps est en JSON (JavaScript Object Notation) : des paires « clé : valeur » lisibles par l’humain et par toutes les machines. Animation de l’échange :
3.4 MQTT : publier et s’abonner
MQTT est un protocole léger conçu pour l’IoT. Au lieu de parler directement, les appareils passent par un broker (ici Mosquitto) :
- Un éditeur (publisher) publie un message sur un topic (par exemple
classe/meteo/tanger1). - Un abonné (subscriber) s’abonne à un topic ou à un filtre et reçoit tous les messages correspondants.
- Éditeurs et abonnés ne se connaissent pas : on ajoute un abonné sans toucher à l’éditeur.
Topics et jokers
Un topic est une suite de niveaux séparés par « / ». Deux jokers dans les filtres d’abonnement : + remplace un seul niveau ; # remplace tous les niveaux suivants et doit être en dernière position. Un filtre peut contenir des jokers, jamais le topic de publication. Teste un filtre sur plusieurs topics :
Qualité de service (QoS), messages retenus et testament
| QoS | Garantie | Paquets pour un message | Usage |
|---|---|---|---|
| 0 | au plus une fois (peut se perdre) | 1 | mesure répétée souvent |
| 1 | au moins une fois (doublon possible) | 2 (PUBLISH, PUBACK) | cas courant |
| 2 | exactement une fois | 4 (PUBLISH, PUBREC, PUBREL, PUBCOMP) | commande critique, facturation |
- Message retenu (retained) : le broker garde le dernier message d’un topic et le donne tout de suite à un nouvel abonné.
- Keep-alive : intervalle de « ping » (15 s par défaut avec la bibliothèque PubSubClient) ; au bout d’environ 1,5 fois cette durée sans nouvelle, le broker considère le client mort.
- Testament (LWT) : message que le broker publie si le client disparaît sans prévenir.
Choisis un QoS et observe l’échange :
Cycle de vie d’une connexion :
3.5 HTTP ou MQTT ?
| HTTP | MQTT | |
|---|---|---|
| Modèle | requête / réponse | publication / abonnement |
| Connexion | une par requête (en général) | une connexion longue |
| Poids des messages | en-têtes volumineux | en-tête de 2 octets minimum |
| Envoi vers plusieurs destinataires | il faut plusieurs requêtes | un seul message, plusieurs abonnés |
| Commande vers l’objet | difficile (l’objet doit interroger le serveur) | naturelle (l’objet est abonné) |
| Usage dans le projet | lire les données stockées (API Flask) | transmettre les mesures et les commandes |
3.6 La taille des messages
3.7 Exercices
Exercice 3.1 (topics). Pour chaque couple (filtre ; topic), dis si l’abonné reçoit le message : (a) classe/+/temperature ; classe/salle2/temperature, (b) classe/# ; classe, (c) classe/+ ; classe/salle2/temperature, (d) +/meteo/# ; maison/meteo/tanger1/led, (e) classe/meteo ; classe/meteo/tanger1, (f) # ; $SYS/broker/uptime.
classe/+/temperature ; classe/salle2/temperature → oui(b)
classe/# ; classe → oui(c)
classe/+ ; classe/salle2/temperature → non(d)
+/meteo/# ; maison/meteo/tanger1/led → oui(e)
classe/meteo ; classe/meteo/tanger1 → non(f)
# ; $SYS/broker/uptime → nonRappels : + remplace exactement un niveau ; # remplace tous les niveaux suivants et inclut le niveau parent ; sans joker il faut une égalité exacte ; les topics qui commencent par $ (réservés au broker) ne sont pas reçus par un joker en premier niveau.
Exercice 3.2 (QoS). Combien de paquets échange l’éditeur avec le broker pour un message en QoS 0, 1 et 2 ? Quel QoS choisir pour une température envoyée toutes les 10 s ? Pour l’ordre « ouvrir la vanne » ?
Exercice 3.3 (codes HTTP). Quel code renvoie notre API dans chaque cas : (a) mesure ajoutée, (b) JSON absent, (c) température de 120 °C, (d) base vide pour GET /api/mesures/derniere, (e) bug dans le code Python ?
Exercice 3.4 (taille d’un message). Calcule la taille du message JSON {"station":"tanger1","temperature":23.4,"humidite":61.2}, de la version CSV tanger1,23.4,61.2 et de la version binaire (2 nombres sur 4 octets). Pourquoi cela compte-t-il en LoRaWAN ?
Exercice 3.5 (choisir le réseau). Quel réseau pour : (a) une station météo alimentée dans la salle de classe, (b) un capteur de niveau d’eau sur batterie dans un champ à 5 km de tout Wi-Fi, (c) un bracelet qui envoie son pas à un téléphone ?
Exercice 3.6 (concevoir les topics). Trois salles (salle1, salle2, salle3) ont chacune un capteur de température et d’humidité, et une LED commandable. Propose une arborescence de topics et le filtre d’abonnement du tableau de bord pour recevoir toutes les mesures.
classe/salle1/temperature, classe/salle1/humidite, classe/salle1/led (commande), et de même pour salle2 et salle3. Filtre du tableau de bord : classe/+/temperature (toutes les températures) ou classe/+/+. Bonnes pratiques : du général au particulier, pas d’espace ni de majuscules, pas de « / » au début, un topic de commande distinct des topics de mesure.Chapitre 4 : Programmer l’ESP32, pas à pas
4.1 Installer l’IDE Arduino et le support ESP32
- Télécharge et installe l’IDE Arduino (arduino.cc, version 2.x).
- Menu Fichier → Préférences : dans « URL de gestionnaire de cartes supplémentaires », colle :
https://espressif.github.io/arduino-esp32/package_esp32_index.json
- Menu Outils → Carte → Gestionnaire de cartes : cherche « esp32 », installe esp32 by Espressif Systems (le téléchargement prend plusieurs minutes).
- Branche la carte avec un câble USB de données (certains câbles ne servent qu’à charger). Si le port n’apparaît pas, installe le pilote de la puce USB de ta carte (CP210x ou CH340).
- Choisis Outils → Carte → esp32 → ESP32 Dev Module et le port de la carte.
4.2 Exemple 1 : faire clignoter la LED
const int LED = 2; // LED intégrée de la plupart des cartes ESP32 DevKit
void setup() {
pinMode(LED, OUTPUT);
}
void loop() {
digitalWrite(LED, HIGH);
delay(500);
digitalWrite(LED, LOW);
delay(500);
}
Clique sur le bouton Téléverser (flèche). Si le téléversement reste bloqué sur « Connecting… », maintiens le bouton BOOT de la carte jusqu’au début du transfert. Résultat attendu : la LED clignote une fois par seconde.
4.3 Exemple 2 : lire le DHT22
Installe les bibliothèques : Outils → Gérer les bibliothèques, cherche DHT sensor library (Adafruit) et accepte d’installer aussi Adafruit Unified Sensor. Câble le capteur comme au chapitre 2 (DATA sur GPIO4), puis :
#include <DHT.h>
#define BROCHE_DHT 4
DHT dht(BROCHE_DHT, DHT22);
void setup() {
Serial.begin(115200);
dht.begin();
}
void loop() {
float h = dht.readHumidity();
float t = dht.readTemperature();
if (isnan(h) || isnan(t)) {
Serial.println("Erreur de lecture du DHT22");
} else {
Serial.print("Temperature : "); Serial.print(t);
Serial.print(" C, humidite : "); Serial.print(h);
Serial.println(" %");
}
delay(2000); // le DHT22 ne mesure pas plus d'une fois toutes les 2 s
}
Ouvre le moniteur série (Outils → Moniteur série) à 115200 bauds. Résultat attendu : une ligne toutes les 2 secondes avec une température et une humidité plausibles ; si tu vois « Erreur de lecture », vérifie le câblage et la résistance de 10 kΩ.
4.3b Exemple 3 : se connecter au Wi-Fi
#include <WiFi.h>
const char* SSID = "MON_WIFI";
const char* MOT_DE_PASSE = "MON_MOT_DE_PASSE";
void setup() {
Serial.begin(115200);
WiFi.mode(WIFI_STA);
WiFi.begin(SSID, MOT_DE_PASSE);
Serial.print("Connexion");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
Serial.print("Adresse IP : ");
Serial.println(WiFi.localIP());
}
void loop() {}
Remplace le nom et le mot de passe de ton réseau 2,4 GHz (l’ESP32 classique ne gère pas le 5 GHz). Résultat attendu : des points puis « Adresse IP : 192.168.x.x ».
4.4 Exemple 4 : la station complète en MQTT
Installe la bibliothèque PubSubClient (Nick O’Leary). Le programme se connecte au Wi-Fi puis au broker, publie une mesure toutes les 10 secondes et écoute un topic de commande pour la LED. Remplace l’adresse du broker par l’adresse IP de ton Raspberry Pi (chapitre 5).
#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>
const char* SSID = "MON_WIFI";
const char* MOT_DE_PASSE = "MON_MOT_DE_PASSE";
const char* BROKER = "192.168.1.50"; // adresse IP du Raspberry Pi
const int PORT = 1883;
const char* STATION = "tanger1";
const char* TOPIC_DONNEES = "classe/meteo/tanger1";
const char* TOPIC_LED = "classe/meteo/tanger1/led";
#define BROCHE_DHT 4
#define BROCHE_LED 2
DHT dht(BROCHE_DHT, DHT22);
WiFiClient reseau;
PubSubClient mqtt(reseau);
unsigned long dernierEnvoi = 0;
const unsigned long PERIODE = 10000; // un envoi toutes les 10 s
void recevoir(char* topic, byte* charge, unsigned int longueur) {
String msg;
for (unsigned int i = 0; i < longueur; i++) msg += (char)charge[i];
if (msg == "ON") digitalWrite(BROCHE_LED, HIGH);
else if (msg == "OFF") digitalWrite(BROCHE_LED, LOW);
}
void connecterWifi() {
if (WiFi.status() == WL_CONNECTED) return;
WiFi.begin(SSID, MOT_DE_PASSE);
while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); }
Serial.print("\nIP : "); Serial.println(WiFi.localIP());
}
void connecterMqtt() {
while (!mqtt.connected()) {
Serial.print("Connexion MQTT...");
if (mqtt.connect(STATION)) { Serial.println("OK"); mqtt.subscribe(TOPIC_LED); }
else { Serial.print("échec, code "); Serial.println(mqtt.state()); delay(2000); }
}
}
void setup() {
Serial.begin(115200);
pinMode(BROCHE_LED, OUTPUT);
dht.begin();
connecterWifi();
mqtt.setServer(BROKER, PORT);
mqtt.setCallback(recevoir);
}
void loop() {
connecterWifi();
connecterMqtt();
mqtt.loop(); // indispensable : messages reçus et keep-alive
if (millis() - dernierEnvoi >= PERIODE) {
dernierEnvoi = millis();
float t = dht.readTemperature();
float h = dht.readHumidity();
if (isnan(t) || isnan(h)) { Serial.println("Lecture DHT22 impossible"); return; }
char json[96];
snprintf(json, sizeof(json), "{\"station\":\"%s\",\"temperature\":%.1f,\"humidite\":%.1f}", STATION, t, h);
mqtt.publish(TOPIC_DONNEES, json);
Serial.println(json);
}
}
Comprendre le programme
| Partie | Rôle |
|---|---|
connecterWifi(), connecterMqtt() | rétablissent la connexion si elle est perdue : à appeler à chaque tour de loop() |
mqtt.loop() | traite les messages reçus et envoie les pings du keep-alive : indispensable, sinon le broker coupe la connexion |
millis() et PERIODE | envoi toutes les 10 s sans bloquer le programme (un delay(10000) empêcherait mqtt.loop() de tourner) |
snprintf | fabrique le texte JSON dans un tampon de taille fixe |
recevoir() | fonction appelée quand un message arrive sur le topic de la LED |
Animation : la boucle du programme
4.5 Économiser l’énergie : le sommeil profond
Pour une carte sur batterie, on ne reste pas connecté : on se réveille, on mesure, on publie, puis on s’endort (la mémoire RAM est perdue, le programme repart du début de setup()).
#define US_PAR_SECONDE 1000000ULL
void setup() {
Serial.begin(115200);
// ... lire le capteur et publier le message ici ...
esp_sleep_enable_timer_wakeup(10ULL * 60ULL * US_PAR_SECONDE); // réveil dans 10 minutes
esp_deep_sleep_start(); // la carte s'éteint presque complètement
}
void loop() {} // jamais atteinte : au réveil, la carte redémarre dans setup()
4.6 Exercices
Exercice 4.1 (trouver l’erreur). Un élève a retiré la ligne mqtt.loop(); de son programme. La station publie quelques messages puis le broker la déconnecte. Pourquoi ?
mqtt.loop(), la bibliothèque n’envoie plus les pings du keep-alive et ne traite plus les paquets reçus. Le broker ne reçoit plus rien pendant plus de 1,5 fois le keep-alive et ferme la connexion. Il faut appeler mqtt.loop() à chaque tour de boucle.Exercice 4.2. Pourquoi utilise-t-on millis() au lieu de delay(10000) pour cadencer les envois ?
delay(10000) bloque le processeur 10 s : pendant ce temps mqtt.loop() ne tourne pas (connexion coupée, commandes de la LED ignorées). Avec millis(), la boucle tourne en permanence et ne publie que lorsque 10 s se sont écoulées depuis le dernier envoi.Exercice 4.3 (modifier le programme). Modifie le programme pour : (a) publier toutes les 30 s, (b) changer le nom de la station en « oran2 » (les topics doivent suivre), (c) publier aussi un message « en ligne » retenu au démarrage.
const unsigned long PERIODE = 30000; (b) STATION = "oran2", TOPIC_DONNEES = "classe/meteo/oran2", TOPIC_LED = "classe/meteo/oran2/led". (c) après mqtt.connect : mqtt.publish("classe/meteo/oran2/etat", "en ligne", true); (le troisième argument true demande le mode retenu).Exercice 4.4. Avec la version « sommeil profond » toutes les 10 minutes, que devient la valeur d’une variable globale ? Comment conserver un compteur de mesures ?
RTC_DATA_ATTR (mémoire conservée pendant le sommeil profond) ou la mémoire flash (bibliothèque Preferences).Chapitre 5 : Le Raspberry Pi : Mosquitto, Node-RED et Flask
Le Raspberry Pi joue le rôle de passerelle et de serveur : il héberge le broker MQTT, le tableau de bord et l’API de stockage.
5.1 Préparer le Raspberry Pi
- Sur un ordinateur, installe Raspberry Pi Imager, choisis ton modèle, le système Raspberry Pi OS et la carte microSD.
- Dans les réglages avancés (personnalisation du système) : nom d’hôte, nom d’utilisateur et mot de passe, réseau Wi-Fi, et active SSH. Écris la carte.
- Insère la carte, démarre le Raspberry Pi et connecte-toi (par SSH ou avec un écran). Relève son adresse IP :
hostname -I
- Mets le système à jour :
sudo apt update sudo apt full-upgrade -y
5.2 Mosquitto, le broker MQTT
sudo apt install mosquitto mosquitto-clients -y sudo systemctl enable mosquitto sudo systemctl status mosquitto
Dans un premier terminal, abonne-toi à tous les topics de test :
mosquitto_sub -h localhost -t "test/#" -v
Dans un second terminal, publie un message :
mosquitto_pub -h localhost -t test/bonjour -m "salut"
Résultat attendu dans le premier terminal :
test/bonjour salut
Par défaut, Mosquitto (version 2 et suivantes) n’accepte que les connexions locales. Pour que l’ESP32 se connecte, crée un fichier de configuration (réseau de classe isolé uniquement, car il autorise tout le monde) :
sudo nano /etc/mosquitto/conf.d/local.conf
avec ce contenu :
listener 1883 allow_anonymous true
puis :
sudo systemctl restart mosquitto
Sur un réseau réel, on active l’authentification : sudo mosquitto_passwd -c /etc/mosquitto/passwd utilisateur, puis dans le fichier de configuration password_file /etc/mosquitto/passwd et allow_anonymous false.
5.3 Node-RED : le tableau de bord
Node-RED est un outil de programmation par blocs qu’on assemble dans un navigateur. Installation sur Raspberry Pi OS (script officiel, qui installe aussi Node.js) :
bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered) sudo systemctl enable nodered.service node-red-start
Ouvre ensuite un navigateur sur http://ADRESSE_IP_DU_PI:1880. Étapes pour le tableau de bord :
- Ajouter la palette du tableau de bord : menu ☰ → Manage palette → onglet Install → cherche
node-red-dashboard→ Install. - Glisse un nœud mqtt in sur la feuille. Double-clique : serveur
localhost, port1883, topicclasse/meteo/+, QoS 0, sortie « a parsed JSON object ». - Glisse un nœud function, règle son nombre de sorties à 3 et colle ce code :
const t = msg.payload.temperature; const h = msg.payload.humidite; if (typeof t !== "number" || typeof h !== "number") { return null; } // message invalide : on l'ignore const alerte = t > 30; return [ { payload: t }, { payload: h }, alerte ? { payload: "ALERTE : " + t + " °C" } : null ]; - Relie mqtt in → function. Ajoute deux nœuds gauge : le premier (température, 0 à 50, unité °C) sur la sortie 1, le second (humidité, 0 à 100, unité %) sur la sortie 2. Crée un onglet « Météo » et un groupe « Station » pour les ranger.
- Ajoute un nœud chart sur la sortie 1 (courbe de la température) et un nœud notification sur la sortie 3 (alerte).
- Ajoute un nœud debug relié à mqtt in pour voir les messages bruts dans la barre latérale.
- Clique sur Deploy.
Tester sans l’ESP32 : dans un terminal du Raspberry Pi :
mosquitto_pub -h localhost -t classe/meteo/test -m '{"station":"test","temperature":22.5,"humidite":55}'
Résultat attendu : le nœud debug affiche l’objet, les jauges affichent 22,5 °C et 55 % sur http://ADRESSE_IP_DU_PI:1880/ui. Avec une température de 31 °C, la notification d’alerte s’affiche. La logique du nœud function a été testée : pour 23,4 °C et 61,2 % elle renvoie [{payload:23.4},{payload:61.2},null] ; pour 31,5 °C la sortie 3 contient « ALERTE : 31.5 °C ».
5.4 Flask et SQLite : stocker les mesures
Node-RED affiche les valeurs en direct, mais ne les garde pas dans le temps. L’API Flask les enregistre dans une base SQLite (un simple fichier). Installation dans un environnement virtuel :
python3 -m venv ~/iot-env source ~/iot-env/bin/activate pip install flask
Crée un fichier app.py avec le code suivant (testé : toutes les réponses ci-dessous viennent d’une exécution réelle) :
from flask import Flask, request, jsonify
import sqlite3, time
app = Flask(__name__)
BASE = "meteo.db"
def requete(sql, params=(), un=False, ecriture=False):
c = sqlite3.connect(BASE)
c.row_factory = sqlite3.Row
try:
cur = c.execute(sql, params)
if ecriture:
c.commit()
return cur.lastrowid
lignes = cur.fetchall()
return (lignes[0] if lignes else None) if un else lignes
finally:
c.close()
def init_base():
requete("""CREATE TABLE IF NOT EXISTS mesures (
id INTEGER PRIMARY KEY AUTOINCREMENT,
station TEXT NOT NULL,
temperature REAL NOT NULL,
humidite REAL NOT NULL,
horodatage INTEGER NOT NULL)""", ecriture=True)
@app.post("/api/mesures")
def ajouter():
d = request.get_json(silent=True)
if not d:
return jsonify(erreur="JSON manquant"), 400
try:
station = str(d["station"])
t = float(d["temperature"])
h = float(d["humidite"])
except (KeyError, ValueError, TypeError):
return jsonify(erreur="champs station, temperature et humidite requis"), 400
if not (-40 <= t <= 85 and 0 <= h <= 100):
return jsonify(erreur="valeurs hors limites"), 422
nouvel_id = requete("INSERT INTO mesures (station, temperature, humidite, horodatage) VALUES (?, ?, ?, ?)",
(station, t, h, int(time.time())), ecriture=True)
return jsonify(id=nouvel_id), 201
@app.get("/api/mesures/derniere")
def derniere():
r = requete("SELECT * FROM mesures ORDER BY id DESC LIMIT 1", un=True)
if r is None:
return jsonify(erreur="aucune mesure"), 404
return jsonify(dict(r))
@app.get("/api/mesures")
def liste():
limite = min(request.args.get("limite", 10, type=int), 100)
lignes = requete("SELECT * FROM mesures ORDER BY id DESC LIMIT ?", (limite,))
return jsonify([dict(r) for r in lignes])
@app.get("/api/stats")
def stats():
r = requete("SELECT COUNT(*) AS n, AVG(temperature) AS moy, MIN(temperature) AS mini, MAX(temperature) AS maxi FROM mesures", un=True)
return jsonify(n=r["n"], moyenne=None if r["n"] == 0 else round(r["moy"], 2), mini=r["mini"], maxi=r["maxi"])
if __name__ == "__main__":
init_base()
app.run(host="0.0.0.0", port=5000)
Lance le serveur :
python3 app.py
Dans un autre terminal, teste chaque route avec curl :
curl -X POST http://localhost:5000/api/mesures -H "Content-Type: application/json" -d '{"station":"tanger1","temperature":23.4,"humidite":61.2}'
curl http://localhost:5000/api/mesures/derniere
curl "http://localhost:5000/api/mesures?limite=2"
curl http://localhost:5000/api/stats
Résultats obtenus (base vide au départ, trois mesures ajoutées, puis des requêtes volontairement invalides) :
GET /api/mesures/derniere -> 404 NOT FOUND {"erreur":"aucune mesure"}
POST /api/mesures -> 201 CREATED {"id":1}
POST /api/mesures -> 201 CREATED {"id":2}
POST /api/mesures -> 201 CREATED {"id":3}
POST /api/mesures -> 400 BAD REQUEST {"erreur":"champs station, temperature et humidite requis"}
POST /api/mesures -> 422 UNPROCESSABLE ENTITY {"erreur":"valeurs hors limites"}
POST /api/mesures -> 400 BAD REQUEST {"erreur":"JSON manquant"}
GET /api/mesures/derniere -> 200 {"horodatage": "<temps>", "humidite": 58.3, "id": 3, "station": "tanger1", "temperature": 25.0}
GET /api/mesures?limite=2 -> 200 2 lignes, la plus récente a id 3
GET /api/stats -> 200 OK {"maxi":25.0,"mini":23.4,"moyenne":24.17,"n":3}
Lecture : le code 201 confirme la création ; 400 signale un champ manquant ou un corps qui n’est pas du JSON ; 422 signale une température hors limites ; 404 une base vide.
5.5 Relier Node-RED à Flask
Pour stocker chaque mesure reçue en MQTT : ajoute à la feuille un nœud http request relié à la sortie du nœud mqtt in (celui dont la charge utile est l’objet JSON). Réglages : méthode POST, URL http://localhost:5000/api/mesures, retour « a parsed JSON object ». Relie la sortie à un nœud debug pour voir la réponse {"id":…}. Vérifie ensuite avec curl http://localhost:5000/api/stats que le nombre de mesures augmente.
5.6 Exercices
Exercice 5.1. Quelle commande publie « ON » sur le topic de la LED de la station tanger1, et quelle commande permet de voir tous les messages de la classe ?
mosquitto_pub -h localhost -t classe/meteo/tanger1/led -m "ON" et mosquitto_sub -h localhost -t "classe/#" -v (l’option -v affiche le topic avec le message).Exercice 5.2. Pourquoi l’ESP32 n’arrive-t-il pas à se connecter à Mosquitto alors que mosquitto_pub fonctionne sur le Raspberry Pi ?
localhost) : mosquitto_pub -h localhost marche, mais pas une connexion venant du réseau. Il faut ajouter un listener 1883 (et autoriser les connexions, ou configurer des utilisateurs), puis redémarrer le service. Vérifie aussi l’adresse IP du broker, le pare-feu et que l’ESP32 est sur le même réseau.Exercice 5.3 (Node-RED). Modifie le nœud function pour que l’alerte se déclenche aussi quand l’humidité dépasse 80 %, avec un message adapté.
const t = msg.payload.temperature;
const h = msg.payload.humidite;
if (typeof t !== "number" || typeof h !== "number") { return null; }
let alerte = null;
if (t > 30) alerte = { payload: "ALERTE : " + t + " °C" };
else if (h > 80) alerte = { payload: "ALERTE : humidité " + h + " %" };
return [ { payload: t }, { payload: h }, alerte ];
Exercice 5.4 (SQL). Écris la requête SQL qui donne la température moyenne des 10 dernières mesures.
SELECT AVG(temperature) FROM (SELECT temperature FROM mesures ORDER BY id DESC LIMIT 10); La sous-requête garde les 10 dernières lignes (tri par identifiant décroissant), puis AVG calcule la moyenne. (Testée sur une base d’essai de 15 mesures : résultat 22,0.)Exercice 5.5. Pourquoi la requête GET /api/mesures?limite=500 ne renvoie-t-elle que 100 lignes au maximum ?
min(…, 100) : on protège le serveur (et le réseau) d’une demande démesurée. C’est une bonne pratique d’une API : toujours borner les paramètres venant du client.Chapitre 6 : L’application mobile
Le téléphone lit l’API Flask (HTTP, méthode GET) et affiche la dernière mesure. Deux options.
http://192.168.1.50:5000), pas localhost.6.1 Option A : MIT App Inventor (sans programmation)
- Ouvre appinventor.mit.edu, crée un projet « StationMeteo ».
- Dans le Designer, ajoute un Label (pour la température), un Button « Actualiser » et le composant non visible Web. Règle la propriété Url du composant Web sur
http://ADRESSE_IP_DU_PI:5000/api/mesures/derniere. - Dans les Blocks : quand Button.Click → appeler Web.Get.
- Quand Web.GotText (le paramètre responseContent contient le JSON) : décode avec Web.JsonTextDecodeWithDictionaries, puis prends la valeur de la clé
temperatureet affiche-la dans le Label. - Teste avec l’application MIT AI2 Companion sur le téléphone.
6.2 Option B : Android Studio (Kotlin)
- Crée un projet Empty Views Activity en Kotlin.
- Dans
AndroidManifest.xml, ajoute avant la balise<application>:<uses-permission android:name="android.permission.INTERNET" />. - Pour ce TP en HTTP simple (sans TLS), autorise le trafic non chiffré en ajoutant à la balise
<application>l’attributandroid:usesCleartextTraffic="true"(à éviter en production : utilise HTTPS). - Dans l’interface, place un
TextViewd’identifianttexte. - Dans
MainActivity, lis l’API sur un fil secondaire (jamais sur le fil principal) :
import org.json.JSONObject
import java.net.URL
import kotlin.concurrent.thread
// dans onCreate, après setContentView(...)
val texte = findViewById<TextView>(R.id.texte)
thread {
val reponse = URL("http://192.168.1.50:5000/api/mesures/derniere").readText()
val j = JSONObject(reponse)
val t = j.getDouble("temperature")
runOnUiThread { texte.text = "Température : $t °C" }
}
6.3 Exercices
Exercice 6.1. Le téléphone affiche « connexion impossible ». Cite quatre vérifications.
host="0.0.0.0" (sinon il n’accepte que les connexions locales). (4) Test de l’URL dans le navigateur du téléphone ; vérifier aussi le pare-feu et, sous Android, l’autorisation du trafic HTTP.Exercice 6.2. Pourquoi ne faut-il pas faire la requête réseau directement dans le fil principal de l’application ?
Chapitre 7 : Projet : la station météo connectée
Ce projet réunit tout le cours. Avance phase par phase : ne passe à la suivante que si la vérification est réussie. C’est la meilleure façon de trouver une panne : on sait que tout ce qui précède fonctionne.
| Phase | À faire | Vérification |
|---|---|---|
| 1. Le capteur | câbler le DHT22 et lire les valeurs (exemple 4.3) | le moniteur série affiche des valeurs plausibles toutes les 2 s |
| 2. Le Wi-Fi | se connecter (exemple 4.3b) | l’adresse IP s’affiche |
| 3. Le broker | installer Mosquitto et le configurer (5.2) | mosquitto_pub puis mosquitto_sub : le message arrive ; une connexion depuis un autre ordinateur fonctionne |
| 4. La publication | téléverser le programme de la station (4.4) | mosquitto_sub -h localhost -t "classe/#" -v affiche une mesure toutes les 10 s |
| 5. Le tableau de bord | construire le flux Node-RED (5.3) | les jauges suivent les mesures sur /ui |
| 6. Le stockage | lancer Flask et relier Node-RED (5.4 et 5.5) | curl …/api/stats : le nombre de mesures augmente |
| 7. L’application | App Inventor ou Android Studio (chapitre 6) | le téléphone affiche la dernière température |
| 8. Commande | ajouter un interrupteur Node-RED pour la LED | la LED de l’ESP32 s’allume depuis le tableau de bord |
7.1 Tâches pour s’entraîner
Tâche 1. Change la période de mesure à 30 s et vérifie le résultat dans Node-RED.
PERIODE (30000 ms), téléverse, puis observe que les mesures arrivent toutes les 30 s dans le nœud debug et que la courbe du graphique avance plus lentement.Tâche 2. Ajoute une deuxième station (autre ESP32 ou un second programme) avec un autre nom et affiche les deux sur le tableau de bord.
STATION et d’autres topics (classe/meteo/oran2). Le filtre classe/meteo/+ reçoit les deux. Dans Node-RED, utilise msg.topic (ou msg.payload.station) pour séparer les courbes du graphique ; l’API Flask distingue déjà les stations par la colonne station.Tâche 3. Ajoute un interrupteur au tableau de bord qui allume et éteint la LED.
classe/meteo/tanger1/led. L’ESP32 est abonné à ce topic (fonction recevoir()).Tâche 4. Affiche sur le téléphone la température moyenne des 10 dernières mesures.
/api/moyenne qui exécute la requête de l’exercice 5.4 et renvoie un JSON ; l’application la lit comme la dernière mesure.Tâche 5 (défi). Fais envoyer un e-mail ou une notification quand la température dépasse un seuil pendant plus de 5 minutes.
flow.get / flow.set) mémorise l’heure du premier dépassement ; un nœud d’envoi d’e-mail (palette node-red-node-email) ou la notification du tableau de bord se déclenche quand la durée dépasse 5 minutes. Remets le compteur à zéro dès que la température repasse sous le seuil.7.2 Dépannage
| Symptôme | Cause probable |
|---|---|
| Le moniteur série affiche des caractères étranges | vitesse du moniteur différente de Serial.begin(115200) |
| Le Wi-Fi ne se connecte pas | nom ou mot de passe faux, réseau 5 GHz seulement, portail captif |
| Connexion MQTT : code d’échec -2 | broker injoignable : mauvaise adresse IP, Mosquitto non configuré pour le réseau, pare-feu |
| Quelques messages puis déconnexion | mqtt.loop() absent ou boucle bloquée par un delay |
| Les jauges restent vides | mauvais topic dans mqtt in, sortie non réglée sur « parsed JSON object », flux non déployé |
| Flask : erreur 400 depuis Node-RED | charge utile qui n’est pas un objet JSON, ou champ manquant |
| Le téléphone n’atteint pas Flask | serveur lancé sans host="0.0.0.0", mauvaise adresse IP, réseaux différents |
Chapitre 8 : Sécurité, énergie et synthèse
8.1 Sécuriser un objet connecté
| Risque | Bonne pratique |
|---|---|
| Broker ouvert à tous (allow_anonymous true) | utilisateurs et mots de passe, listes de contrôle d’accès par topic |
| Messages lisibles sur le réseau | chiffrement TLS : MQTT sur le port 8883, HTTPS (443) |
| Mot de passe du Wi-Fi écrit dans le code partagé | fichier secrets.h non publié ; ne jamais envoyer ses mots de passe sur un dépôt public |
| Objet jamais mis à jour | mise à jour à distance (OTA) signée |
| Mots de passe par défaut | les changer dès l’installation |
| Broker public de test | n’y mettre aucune donnée privée : tout le monde peut lire |
8.2 Fiabilité
- Reconnexion automatique au Wi-Fi et au broker (déjà dans notre programme).
- Chien de garde (watchdog) : redémarre la carte si le programme se bloque.
- Horodatage : l’ESP32 n’a pas d’horloge fiable ; on met l’heure côté serveur (comme notre API) ou via NTP.
- Mise en tampon : en cas de coupure, mémoriser les mesures pour les envoyer ensuite.
8.3 Énergie : calculer l’autonomie
Le Wi-Fi consomme beaucoup (de l’ordre de 100 mA en émission) alors que le sommeil profond de la puce ne consomme que quelques dizaines de µA. Autonomie = capacité / courant moyen, avec courant moyen = (I_actif × t_actif + I_veille × t_veille) / période.
8.4 Exercices
Exercice 8.1 (autonomie). Une station consomme 120 mA pendant 3 s à chaque cycle, puis 20 µA en sommeil profond, avec une batterie de 2000 mAh. Calcule l’autonomie pour un cycle toutes les 10 minutes, puis toutes les minutes, et compare avec une carte toujours active.
Exercice 8.2 (audit de sécurité). Un élève utilise le broker public broker.hivemq.com avec le topic « temperature » et laisse son mot de passe Wi-Fi dans le code publié sur internet. Relève les problèmes.
Exercice 8.3. Quand faut-il choisir HTTP plutôt que MQTT pour envoyer une mesure ?
8.5 QCM
8.6 Ce qu’il faut retenir
- Un objet connecté suit toujours le chemin : capteur → microcontrôleur → réseau → plateforme → application.
- MQTT : on publie sur des topics, on s’abonne à des filtres, le broker distribue ; le QoS règle la garantie de livraison.
- HTTP/REST : requête et réponse, codes d’état (201, 400, 404, 422).
- Sur l’ESP32, appeler
mqtt.loop()et ne pas bloquer la boucle avecdelay. - Procéder phase par phase et vérifier chaque étape avant la suivante.
- Penser sécurité, fiabilité et énergie dès la conception.