Thursday, September 24, 2026

Cours IoT

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

CoucheRôleExemples de ce cours
1. Perceptionmesurer et agirDHT22, TMP36, LED, ESP32
2. Réseautransporter les donnéesWi-Fi, TCP/IP, protocoles MQTT et HTTP
3. Plateformerecevoir, traiter et stockerMosquitto, Node-RED, Flask, SQLite (sur Raspberry Pi)
4. Applicationprésenter à l’utilisateurtableau 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éristiqueValeur (ESP32 classique)
Processeur2 cœurs, jusqu’à 240 MHz
Mémoireenviron 520 Ko de RAM ; flash externe (souvent 4 Mo)
CommunicationWi-Fi 2,4 GHz, Bluetooth classique et BLE
Entrées/sortiesGPIO en 3,3 V (non tolérantes au 5 V), I2C, SPI, UART, PWM
Convertisseur analogiqueADC 12 bits (0 à 4095)
Précautions avec les broches. GPIO34 à 39 sont des entrées seulement et n’ont pas de résistance de tirage interne. Quand le Wi-Fi est actif, l’ADC2 ne peut plus servir : pour mesurer une tension analogique, utilise l’ADC1 (GPIO32 à 39). Les broches GPIO0, 2, 12 et 15 servent à choisir le mode de démarrage : évite d’y brancher un composant qui impose un niveau au démarrage.

2.2 Les capteurs courants

CapteurMesureInterfaceRemarques
DHT22température et humidité1 fil numériqueenviron ±0,5 °C et ±2 à 5 % d’humidité ; une mesure toutes les 2 s au maximum
DHT11température et humidité1 fil numériquemoins précis (±2 °C), moins cher
DS18B20température1-Wireétanche possible, plusieurs capteurs sur un fil
BME280température, humidité, pressionI2C (0x76 ou 0x77)précis, adapté à une station météo
TMP36températureanalogique10 mV par °C avec 500 mV de décalage, alimentable en 3,3 V
LM35températureanalogique10 mV par °C, alimentation d’au moins 4 V
NTC 10 kΩtempératurepont diviseur + ADCnon linéaire, calcul avec le coefficient B
LDR, PIR…lumière, présenceanalogique, 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 :

Valeur ADC Capteur

Ces formules sont idéales. L’ADC de l’ESP32 n’est pas parfaitement linéaire (surtout près de 0 V et de 3,3 V) : pour une mesure précise, compare avec un multimètre ou utilise 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éseauPortéeDébitConsommationUsage typique
Wi-Fidizaines de mètresélevéforteobjet alimenté, dans un bâtiment (notre projet)
Bluetooth LEquelques mètresfaible à moyentrès faiblebracelet, capteur près d’un téléphone
Zigbee / Threaddizaines de mètres, mailléfaiblefaibledomotique
LoRa / LoRaWANplusieurs kmtrès faibletrès faiblecapteur sur batterie, champs, villes
4G, NB-IoT, LTE-Mréseau mobilefaible à élevémoyenne à faibleobjet 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éthodeActionExemple
GETlireGET /api/mesures/derniere
POSTcréerPOST /api/mesures (corps JSON)
PUTremplacerPUT /api/stations/1
DELETEsupprimerDELETE /api/mesures/12
CodeSignificationDans notre API
200 OKsuccèslecture réussie
201 Createdressource crééemesure enregistrée
400 Bad Requestrequête invalideJSON absent ou champ manquant
404 Not Foundintrouvableaucune mesure en base
422 Unprocessable Entitydonnées incohérentestempérature hors limites
500 Internal Server Errorbug du serveurerreur 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 :

Filtre

Qualité de service (QoS), messages retenus et testament

QoSGarantiePaquets pour un messageUsage
0au plus une fois (peut se perdre)1mesure répétée souvent
1au moins une fois (doublon possible)2 (PUBLISH, PUBACK)cas courant
2exactement une fois4 (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 :

QoS

Cycle de vie d’une connexion :

3.5 HTTP ou MQTT ?

HTTPMQTT
Modèlerequête / réponsepublication / abonnement
Connexionune par requête (en général)une connexion longue
Poids des messagesen-têtes volumineuxen-tête de 2 octets minimum
Envoi vers plusieurs destinatairesil faut plusieurs requêtesun seul message, plusieurs abonnés
Commande vers l’objetdifficile (l’objet doit interroger le serveur)naturelle (l’objet est abonné)
Usage dans le projetlire les données stockées (API Flask)transmettre les mesures et les commandes

3.6 La taille des messages

Station Température Humidité

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.

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.

Chapitre 4 : Programmer l’ESP32, pas à pas

Les programmes de ce chapitre ont été vérifiés pour leur syntaxe C++ avec des déclarations de remplacement, mais pas exécutés sur une carte : teste-les sur ton matériel et compare avec les résultats attendus.

4.1 Installer l’IDE Arduino et le support ESP32

  1. Télécharge et installe l’IDE Arduino (arduino.cc, version 2.x).
  2. Menu Fichier → Préférences : dans « URL de gestionnaire de cartes supplémentaires », colle :
    https://espressif.github.io/arduino-esp32/package_esp32_index.json
  3. Menu Outils → Carte → Gestionnaire de cartes : cherche « esp32 », installe esp32 by Espressif Systems (le téléchargement prend plusieurs minutes).
  4. 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).
  5. 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

PartieRô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 PERIODEenvoi toutes les 10 s sans bloquer le programme (un delay(10000) empêcherait mqtt.loop() de tourner)
snprintffabrique 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 ?

Exercice 4.2. Pourquoi utilise-t-on millis() au lieu de delay(10000) pour cadencer les envois ?

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.

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 ?

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

  1. Sur un ordinateur, installe Raspberry Pi Imager, choisis ton modèle, le système Raspberry Pi OS et la carte microSD.
  2. 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.
  3. 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
  4. 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 :

  1. Ajouter la palette du tableau de bord : menu ☰ → Manage palette → onglet Install → cherche node-red-dashboard → Install.
  2. Glisse un nœud mqtt in sur la feuille. Double-clique : serveur localhost, port 1883, topic classe/meteo/+, QoS 0, sortie « a parsed JSON object ».
  3. 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 ];
  4. 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.
  5. Ajoute un nœud chart sur la sortie 1 (courbe de la température) et un nœud notification sur la sortie 3 (alerte).
  6. Ajoute un nœud debug relié à mqtt in pour voir les messages bruts dans la barre latérale.
  7. 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 ?

Exercice 5.2. Pourquoi l’ESP32 n’arrive-t-il pas à se connecter à Mosquitto alors que mosquitto_pub fonctionne sur le Raspberry Pi ?

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é.

Exercice 5.4 (SQL). Écris la requête SQL qui donne la température moyenne des 10 dernières mesures.

Exercice 5.5. Pourquoi la requête GET /api/mesures?limite=500 ne renvoie-t-elle que 100 lignes au maximum ?

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.

Le téléphone doit être connecté au même réseau Wi-Fi que le Raspberry Pi, et l’adresse utilisée est celle du Raspberry Pi (par exemple http://192.168.1.50:5000), pas localhost.

6.1 Option A : MIT App Inventor (sans programmation)

  1. Ouvre appinventor.mit.edu, crée un projet « StationMeteo ».
  2. 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.
  3. Dans les Blocks : quand Button.Click → appeler Web.Get.
  4. Quand Web.GotText (le paramètre responseContent contient le JSON) : décode avec Web.JsonTextDecodeWithDictionaries, puis prends la valeur de la clé temperature et affiche-la dans le Label.
  5. Teste avec l’application MIT AI2 Companion sur le téléphone.

6.2 Option B : Android Studio (Kotlin)

  1. Crée un projet Empty Views Activity en Kotlin.
  2. Dans AndroidManifest.xml, ajoute avant la balise <application> : <uses-permission android:name="android.permission.INTERNET" />.
  3. Pour ce TP en HTTP simple (sans TLS), autorise le trafic non chiffré en ajoutant à la balise <application> l’attribut android:usesCleartextTraffic="true" (à éviter en production : utilise HTTPS).
  4. Dans l’interface, place un TextView d’identifiant texte.
  5. 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" }
}
Ce code Kotlin n’a pas été compilé ni testé ici : suis les messages de l’IDE (imports, versions) et vérifie d’abord l’URL dans le navigateur du téléphone.

6.3 Exercices

Exercice 6.1. Le téléphone affiche « connexion impossible ». Cite quatre vérifications.

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À faireVérification
1. Le capteurcâ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-Fise connecter (exemple 4.3b)l’adresse IP s’affiche
3. Le brokerinstaller Mosquitto et le configurer (5.2)mosquitto_pub puis mosquitto_sub : le message arrive ; une connexion depuis un autre ordinateur fonctionne
4. La publicationté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 bordconstruire le flux Node-RED (5.3)les jauges suivent les mesures sur /ui
6. Le stockagelancer Flask et relier Node-RED (5.4 et 5.5)curl …/api/stats : le nombre de mesures augmente
7. L’applicationApp Inventor ou Android Studio (chapitre 6)le téléphone affiche la dernière température
8. Commandeajouter un interrupteur Node-RED pour la LEDla 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.

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.

Tâche 3. Ajoute un interrupteur au tableau de bord qui allume et éteint la LED.

Tâche 4. Affiche sur le téléphone la température moyenne des 10 dernières mesures.

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.

7.2 Dépannage

SymptômeCause probable
Le moniteur série affiche des caractères étrangesvitesse du moniteur différente de Serial.begin(115200)
Le Wi-Fi ne se connecte pasnom ou mot de passe faux, réseau 5 GHz seulement, portail captif
Connexion MQTT : code d’échec -2broker injoignable : mauvaise adresse IP, Mosquitto non configuré pour le réseau, pare-feu
Quelques messages puis déconnexionmqtt.loop() absent ou boucle bloquée par un delay
Les jauges restent videsmauvais topic dans mqtt in, sortie non réglée sur « parsed JSON object », flux non déployé
Flask : erreur 400 depuis Node-REDcharge utile qui n’est pas un objet JSON, ou champ manquant
Le téléphone n’atteint pas Flaskserveur 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é

RisqueBonne 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éseauchiffrement 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 à jourmise à jour à distance (OTA) signée
Mots de passe par défautles changer dès l’installation
Broker public de testn’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.

Courant actif (mA) Durée active (s) Veille (µA) Période (min) Batterie (mAh)

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

  1. Un objet connecté suit toujours le chemin : capteur → microcontrôleur → réseau → plateforme → application.
  2. MQTT : on publie sur des topics, on s’abonne à des filtres, le broker distribue ; le QoS règle la garantie de livraison.
  3. HTTP/REST : requête et réponse, codes d’état (201, 400, 404, 422).
  4. Sur l’ESP32, appeler mqtt.loop() et ne pas bloquer la boucle avec delay.
  5. Procéder phase par phase et vérifier chaque étape avant la suivante.
  6. Penser sécurité, fiabilité et énergie dès la conception.