Lecture : 14 minutes · Niveau : intermédiaire · Mise à jour : avril 2026
Tutoriel pas-à-pas pour construire un système IoT complet : ESP32 + capteur DHT22 (température/humidité) qui publie en MQTT vers un broker Mosquitto local, données stockées dans InfluxDB, dashboard Grafana, mise à jour Over-The-Air (OTA). Tout est testable sur un montage à environ 15 USD avec un Raspberry Pi comme serveur.
Pourquoi cette stack précisément ? ESP32 + Mosquitto + InfluxDB + Grafana est devenu le stack de référence open-source IoT. Quatre raisons : (1) chaque composant est mature, gratuit, et activement maintenu, (2) la stack scale de 1 capteur à 10 000+ sans réécriture, (3) la documentation et la communauté sont énormes — chaque problème rencontré a déjà sa réponse en ligne, (4) cette pile est portable : on peut commencer en local sur Raspberry Pi puis migrer vers AWS/Azure sans changer le code embarqué. Pour une PME qui démarre en IoT, cette stack est le choix robuste.
Approche pédagogique de ce tutoriel. Construire incrémentalement : d’abord un ESP32 qui se connecte au Wi-Fi, puis qui lit le capteur, puis qui publie en MQTT, puis dashboard, puis OTA. Cette progression permet d’isoler les problèmes à chaque étape — beaucoup de débutants tentent tout d’un coup et bloquent sans comprendre quelle couche pose problème. Patience pour l’incrémentation paye en compréhension durable.
Voir aussi → IoT pratique et sécurité pour PME, Raspberry Pi serveur domestique : tutoriel, Sécurité IoT : MQTT, firmware.
Sommaire
- Matériel et schéma de câblage
- Installer Arduino IDE et drivers ESP32
- Premier programme : Hello Wi-Fi
- Lire le capteur DHT22
- Installer Mosquitto sur Raspberry Pi
- Publier en MQTT depuis ESP32
- InfluxDB + Grafana pour dashboard
- OTA : mise à jour à distance
- Deep sleep pour batterie
- Lab : déploiement multi-capteurs
- FAQ
1. Matériel et schéma de câblage
Liste de courses :
– 1× ESP32 DevKit (DOIT, NodeMCU, etc.) — 5 USD
– 1× DHT22 (température + humidité) — 3 USD
– 1× résistance 10 kΩ
– Câble USB-C (ou microUSB selon module)
– Breadboard + jumpers
– Optionnel : Raspberry Pi 4B (serveur Mosquitto + Grafana)
Le DHT22 demande un pull-up obligatoire sur la ligne de données pour fonctionner correctement. Sans cette résistance, le signal flotte et les lectures retournent NaN. C’est l’erreur la plus fréquente des débutants. Certains modules vendus comme « DHT22 module » intègrent déjà ce pull-up sur la PCB — vérifier la doc du vendeur. Sinon, ajouter un 10kΩ entre la ligne DATA et le rail 3.3V.
Câblage DHT22 → ESP32 :
DHT22 pin 1 (VCC) → ESP32 3.3V
DHT22 pin 2 (DATA) → ESP32 GPIO 4 (+ pull-up 10kΩ vers 3.3V)
DHT22 pin 4 (GND) → ESP32 GND
2. Installer Arduino IDE et drivers ESP32
# Linux
sudo apt install arduino -y
# Ou télécharger depuis arduino.cc/en/software
Ajouter support ESP32 :
1. Ouvrir Arduino IDE
2. File → Preferences → Additional Boards Manager URLs :
https://espressif.github.io/arduino-esp32/package_esp32_index.json
3. Tools → Board → Boards Manager → chercher « esp32 » → Install
4. Tools → Board → ESP32 Arduino → ESP32 Dev Module
Drivers USB CP210x ou CH340 :
– Linux : généralement déjà inclus
– Windows : télécharger CP210x ou CH340 selon la puce USB du module
– macOS : installer le driver correspondant
Test :
– File → Examples → Basics → Blink
– Tools → Port → /dev/ttyUSB0 (Linux) ou COMx (Windows)
– Upload → la LED bleue clignote
3. Premier programme : Hello Wi-Fi
#include <WiFi.h>
const char* ssid = "MonReseau";
const char* password = "MonMotDePasse";
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("\n[*] Connecting to Wi-Fi...");
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("\n[+] Connected!");
Serial.print("IP: ");
Serial.println(WiFi.localIP());
}
void loop() {
delay(10000);
}
Upload + Serial Monitor (Ctrl+Shift+M, 115200 bauds) :
[*] Connecting to Wi-Fi....
[+] Connected!
IP: 192.168.1.42
4. Lire le capteur DHT22
Installer la lib : Sketch → Include Library → Manage Libraries → chercher « DHT sensor library » by Adafruit → Install (+ « Adafruit Unified Sensor » comme dépendance).
#include <DHT.h>
#define DHT_PIN 4
#define DHT_TYPE DHT22
DHT dht(DHT_PIN, DHT_TYPE);
void setup() {
Serial.begin(115200);
dht.begin();
}
void loop() {
delay(2000); // DHT22 = 1 lecture / 2 sec max
float h = dht.readHumidity();
float t = dht.readTemperature();
if (isnan(h) || isnan(t)) {
Serial.println("[!] Read failed");
return;
}
Serial.printf("Temp: %.1f °C | Humid: %.1f %%\n", t, h);
}
Sortie Serial :
Temp: 27.4 °C | Humid: 65.2 %
Temp: 27.4 °C | Humid: 65.3 %
5. Installer Mosquitto sur Raspberry Pi
# Sur Raspberry Pi (Raspbian / Ubuntu)
sudo apt update
sudo apt install -y mosquitto mosquitto-clients
sudo systemctl enable --now mosquitto
# Vérifier
sudo systemctl status mosquitto
mosquitto_pub -t test -m "hello"
mosquitto_sub -t test # dans un autre terminal
Configuration de base avec auth (/etc/mosquitto/conf.d/local.conf) :
listener 1883 0.0.0.0
allow_anonymous false
password_file /etc/mosquitto/passwd
Créer un utilisateur :
sudo mosquitto_passwd -c /etc/mosquitto/passwd capteur1
# Saisir mot de passe
sudo systemctl restart mosquitto
Tester :
mosquitto_pub -h IP_PI -t test -m "hello" -u capteur1 -P motdepasse
mosquitto_sub -h IP_PI -t test -u capteur1 -P motdepasse
6. Publier en MQTT depuis ESP32
Lib : Manage Libraries → « PubSubClient » by Nick O’Leary → Install.
#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>
const char* ssid = "MonReseau";
const char* password = "MonMotDePasse";
const char* mqtt_server = "192.168.1.10"; // IP du Pi
const int mqtt_port = 1883;
const char* mqtt_user = "capteur1";
const char* mqtt_pass = "motdepasse";
#define DHT_PIN 4
DHT dht(DHT_PIN, DHT22);
WiFiClient espClient;
PubSubClient client(espClient);
void setup_wifi() {
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); }
}
void reconnect() {
while (!client.connected()) {
Serial.print("[*] MQTT connecting...");
String clientId = "esp32-" + String(WiFi.macAddress());
if (client.connect(clientId.c_str(), mqtt_user, mqtt_pass)) {
Serial.println("OK");
} else {
Serial.printf(" failed rc=%d, retry in 5s\n", client.state());
delay(5000);
}
}
}
void setup() {
Serial.begin(115200);
setup_wifi();
client.setServer(mqtt_server, mqtt_port);
dht.begin();
}
void loop() {
if (!client.connected()) reconnect();
client.loop();
static unsigned long last = 0;
if (millis() - last > 30000) {
last = millis();
float t = dht.readTemperature();
float h = dht.readHumidity();
if (!isnan(t) && !isnan(h)) {
char payload[64];
snprintf(payload, sizeof(payload),
"{\"temp\":%.1f,\"humid\":%.1f}", t, h);
client.publish("entrepot/zone-A/dht22", payload);
Serial.println(payload);
}
}
}
Vérifier réception sur le Pi :
mosquitto_sub -h localhost -t "entrepot/#" -u capteur1 -P motdepasse -v
Sortie :
entrepot/zone-A/dht22 {"temp":27.4,"humid":65.2}
entrepot/zone-A/dht22 {"temp":27.5,"humid":65.1}
7. InfluxDB + Grafana pour dashboard
Sur le Raspberry Pi :
# InfluxDB v2
sudo apt install -y influxdb2
sudo systemctl enable --now influxdb
# Setup initial : http://IP_PI:8086 → créer org "pme", bucket "iot"
# Grafana
sudo apt install -y software-properties-common
sudo add-apt-repository "deb https://packages.grafana.com/oss/deb stable main"
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
sudo apt update && sudo apt install -y grafana
sudo systemctl enable --now grafana-server
# UI : http://IP_PI:3000 → admin/admin
Pont MQTT → InfluxDB via Telegraf :
sudo apt install -y telegraf
sudo nano /etc/telegraf/telegraf.conf
Ajouter :
[[inputs.mqtt_consumer]]
servers = ["tcp://localhost:1883"]
topics = ["entrepot/#"]
username = "capteur1"
password = "motdepasse"
data_format = "json"
[[outputs.influxdb_v2]]
urls = ["http://localhost:8086"]
token = "VOTRE_TOKEN_INFLUX"
organization = "pme"
bucket = "iot"
sudo systemctl restart telegraf
Grafana dashboard :
1. Add data source → InfluxDB → URL http://localhost:8086 → token + org
2. Create dashboard → Add panel → query Flux :
from(bucket: "iot")
|> range(start: -24h)
|> filter(fn: (r) => r._measurement == "mqtt_consumer")
|> filter(fn: (r) => r._field == "temp")
→ Graphique temps réel des températures des dernières 24h.
8. OTA : mise à jour à distance
Mettre à jour les ESP32 sans les débrancher.
#include <ArduinoOTA.h>
void setup() {
// ... wifi setup ...
ArduinoOTA.setHostname("esp32-zone-A");
ArduinoOTA.setPassword("ota_secret");
ArduinoOTA.onStart([]() { Serial.println("OTA Start"); });
ArduinoOTA.onEnd([]() { Serial.println("OTA End"); });
ArduinoOTA.onError([](ota_error_t e) { Serial.printf("OTA Error %d\n", e); });
ArduinoOTA.begin();
}
void loop() {
ArduinoOTA.handle();
// ... reste de loop ...
}
Depuis Arduino IDE après upload initial USB :
– Tools → Port → ESP32 apparaît en Wi-Fi (esp32-zone-A at 192.168.1.42)
– Upload → entrer mot de passe OTA → upload sans fil
⚠️ Sécurité : changer le mot de passe OTA, ne jamais l’exposer en clair sur Internet. Limiter à VPN ou réseau IoT segmenté.
9. Deep sleep pour batterie
ESP32 en deep sleep consomme ~10 µA — pile 18650 dure des mois.
#include <esp_sleep.h>
#define uS_TO_S 1000000ULL
#define SLEEP_SEC 600 // 10 minutes
void setup() {
Serial.begin(115200);
delay(1000);
// 1. Connecter Wi-Fi rapidement
// 2. Lire capteur
// 3. Publier MQTT
// ... (code précédent simplifié) ...
Serial.println("[*] Going to deep sleep...");
esp_sleep_enable_timer_wakeup(SLEEP_SEC * uS_TO_S);
esp_deep_sleep_start();
// Ne reviens jamais ici, reset au réveil
}
void loop() {
// Pas utilisé en deep sleep
}
Astuces économie :
– Désactiver Bluetooth si non utilisé : btStop();
– Réduire vitesse CPU : setCpuFrequencyMhz(80);
– Lights sleep entre lectures courtes
– Wi-Fi roaming optimisation pour reconnect rapide
Estimation autonomie :
– 18650 3000 mAh, ESP32 en deep sleep ~10µA + 5s actif chaque 10 min
– ~5-8 mois d’autonomie réaliste
10. Lab : déploiement multi-capteurs
Architecture cible :
Zone A (Frigo 1) → ESP32 + DHT22 → MQTT → Pi
Zone B (Frigo 2) → ESP32 + DHT22 → MQTT → Pi
Zone C (Stockage) → ESP32 + DHT22 → MQTT → Pi
│
▼
[InfluxDB + Grafana]
│
▼
[Alerte WhatsApp si > 8°C]
Topics MQTT cohérents :
entrepot/zone-A/temp
entrepot/zone-A/humid
entrepot/zone-B/temp
entrepot/zone-B/humid
entrepot/zone-C/temp
Alerte automatique avec Node-RED ou script Python :
# alert.py - sur le Pi
import paho.mqtt.client as mqtt
import json, requests
WHATSAPP_API = "https://api.whatsapp-business/.../send"
THRESHOLD = 8.0
def on_message(client, userdata, msg):
data = json.loads(msg.payload)
if data['temp'] > THRESHOLD:
zone = msg.topic.split('/')[1]
send_whatsapp(f"⚠️ Alerte: {zone} à {data['temp']}°C")
def send_whatsapp(text):
requests.post(WHATSAPP_API, json={"text": text})
client = mqtt.Client()
client.username_pw_set("capteur1", "motdepasse")
client.on_message = on_message
client.connect("localhost", 1883)
client.subscribe("entrepot/+/dht22")
client.loop_forever()
FAQ
ESP32 ou ESP8266 pour démarrer ?
ESP32 — plus puissant, dual-core, Bluetooth en plus, RAM plus importante, GPIO ADC plus précis. ESP8266 reste valable pour projets très simples économiques en quantité.
Mosquitto local vs broker cloud (HiveMQ Cloud, AWS IoT) ?
Local pour démarrer (zéro coût, contrôle total). Cloud pour scale (centaines+ d’appareils répartis géographiquement). HiveMQ Cloud a un plan gratuit limité utile pour POC.
Quelle distance Wi-Fi avec un ESP32 standard ?
~15-30m en intérieur avec murs, ~50-100m extérieur ligne de vue. Antenne externe (modules avec u.FL) double facilement. Pour très longue distance : ESP32 LoRa hybride.
Mon capteur DHT22 retourne NaN — pourquoi ?
Plusieurs causes : pull-up manquant (10kΩ obligatoire), DATA pin mauvais sur ESP32, alimentation 3.3V trop instable, capteur défectueux (chinois bas de gamme), lecture trop fréquente (DHT22 limite ~1 lecture/2sec).
Comment ajouter une carte SD pour logger localement ?
ESP32 supporte SPI → connecter module SD card adapter → lib <SD.h> → log fichier CSV. Utile pour reprise quand le réseau coupe (sync différée à la reconnexion).
Comment alimenter via batterie + solaire ?
Panneau 5V/1W + TP4056 (charger Li-Po) + batterie 18650 + step-up 5V → ESP32. Calcul : pour 10 minutes deep sleep, panneau 1W suffit largement à recharger continûment. Boîtier IP65 pour extérieur.
MQTT-S (TLS) sur ESP32 — performance ?
Possible avec lib WiFiClientSecure + PubSubClient. Surcoût RAM ~20-30 KB (acceptable sur ESP32). Latence connexion +500ms. À utiliser dès que MQTT traverse Internet — sinon réseau local segmenté suffit pour POC.
Comment choisir entre Arduino IDE et PlatformIO ?
Arduino IDE pour démarrer (simple, multiplateforme). PlatformIO (extension VS Code) pour projets sérieux : versionning libs, multi-environnements, intégration tests, bien meilleur en équipe.
Articles liés (cluster IoT)
- 👉 IoT pratique et sécurité pour PME
- 👉 Raspberry Pi serveur domestique : tutoriel
- 👉 Sécurité IoT : MQTT, firmware, durcissement
Voir aussi : Python pour PME : guide pratique, Cybersécurité PME Sénégal : guide complet.
Article mis à jour le 25 avril 2026. Pour signaler une erreur ou suggérer une amélioration, écrivez-nous.