ESP32 WiFi : Envoyer vos Donnees IoT sur Internet (Guide Complet)

Mars 2024. Un etudiant ENIT en PFE me montre fierement son projet : un ESP32 qui envoie la temperature de son aquarium sur Internet. Le code marche… 12 heures, puis crash. Le WiFi se deconnecte, il faut redemarrer manuellement. Le mot de passe WiFi est ecrit en clair dans le firmware (probleme si on flash 100 appareils chez des clients). Aucune reconnexion automatique. Aucune mise a jour OTA. Aucun chiffrement HTTPS. Sa note ? 12/20.

Le mois suivant, on a refait le projet ensemble. Resultat : autonomie 6 mois sur 2 piles AA grace au deep sleep, connexion WiFi via portail captif (l’utilisateur configure depuis son telephone), HTTPS avec certificat Let’s Encrypt, MQTT pour la latence faible, OTA pour mises a jour a distance. Note finale : 19/20.

Dans ce guide, on construit ensemble cette architecture professionnelle. Pas du tutoriel “Hello World ThingSpeak”, mais du vrai code production utilise dans 50+ projets deployes en Tunisie.

1. Architecture ESP32 : ce qu’il faut savoir

L’ESP32 d’Espressif (Shanghai, 2016) est probablement le meilleur rapport prix/performances jamais conçu pour l’IoT. Pour 15 TND chez Didactico, vous obtenez :

• CPU dual-core Xtensa LX6 @ 240 MHz : deux fois plus rapide qu’un Arduino UNO multiplie par 100
• 520 KB SRAM + 4 MB Flash (versions standard)
• WiFi 802.11 b/g/n 2,4 GHz avec antenne PCB integree
• Bluetooth 4.2 classic + BLE
• 34 GPIO dont 18 ADC 12-bit, 16 PWM channels, 2 DAC 8-bit, I2C, SPI, UART, CAN, I2S
• Hall sensor, touch sensors, deep sleep < 10 µA
• Cryptographie hardware : AES, SHA, RSA, ECC, RNG

ESP32 vs ESP32-S2/S3/C3 : quel choisir ?

2. Installation core ESP32 dans Arduino IDE 2.x

1. Ouvrir Arduino IDE 2.x > Fichier > Preferences
2. Dans “URL de gestionnaires de cartes supplementaires”, coller : https://espressif.github.io/arduino-esp32/package_esp32_index.json
3. Aller dans Outils > Type de carte > Gestionnaire de cartes
4. Chercher “esp32” et installer “esp32 by Espressif Systems” (version 3.0.x ou +)
5. Selectionner Outils > Carte > ESP32 Arduino > ESP32 Dev Module

3. Connexion WiFi avec WiFiManager (portail captif)

Hardcoder le SSID/mot de passe dans le code est une faute de debutant. Si vous deployez 50 capteurs chez 50 clients differents, vous devez tous les reflasher. Solution professionnelle : WiFiManager.

WiFiManager (lib de tzapu) lance un point d’acces WiFi au demarrage si aucun reseau connu. L’utilisateur se connecte avec son telephone a “DIDACTICO-AP”, est redirige vers une page web ou il choisit son WiFi et entre le mot de passe. Les credentials sont stockes en NVS Flash, jamais perdus.

#include <WiFi.h>
#include <WiFiManager.h>  // installer via Library Manager

void setup() {
  Serial.begin(115200);
  
  WiFiManager wm;
  
  // Si pas de WiFi configure, lance portail captif
  // SSID : "DIDACTICO-IoT-Setup"
  // Pwd  : "didactico2026"
  bool res = wm.autoConnect("DIDACTICO-IoT-Setup", "didactico2026");
  
  if (!res) {
    Serial.println("Echec connexion. Redemarrage...");
    delay(3000);
    ESP.restart();
  }
  
  Serial.print("WiFi connecte ! IP : ");
  Serial.println(WiFi.localIP());
}

void loop() {
  // Verifier connexion regulierement
  if (WiFi.status() != WL_CONNECTED) {
    WiFi.reconnect();
    delay(5000);
  }
}

4. HTTP GET/POST avec HTTPClient

Pour envoyer des donnees a un serveur, utilisez la bibliotheque HTTPClient incluse dans le core ESP32.

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

void envoyerDonnee(float temp, float hum) {
  if (WiFi.status() != WL_CONNECTED) return;
  
  HTTPClient http;
  String url = "http://api.didactico.tn/iot/temp";
  http.begin(url);
  http.addHeader("Content-Type", "application/json");
  http.addHeader("X-API-Key", "VOTRE_CLE_API");
  
  String payload = "{"temp":" + String(temp) 
                 + ","hum":" + String(hum)
                 + ","device":"esp32-01"}";
  
  int httpCode = http.POST(payload);
  
  if (httpCode > 0) {
    String response = http.getString();
    Serial.printf("HTTP %d : %sn", httpCode, response.c_str());
  } else {
    Serial.printf("Echec HTTP : %sn", 
      http.errorToString(httpCode).c_str());
  }
  
  http.end();
}

5. HTTPS securise + certificat Let’s Encrypt

En 2026, envoyer des donnees IoT en HTTP clair, c’est inadmissible. Mais HTTPS sur ESP32 demande un detail crucial : integrer le certificat racine pour valider la chaine de confiance.

Let’s Encrypt utilise le root certificate ISRG Root X1. Voici comment l’inclure :

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

// ISRG Root X1 (Let's Encrypt)
const char* root_ca = 
"-----BEGIN CERTIFICATE-----n" 
"MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAwn" 
"...n" 
"-----END CERTIFICATE-----n";

void envoyerHTTPS(float temp) {
  WiFiClientSecure client;
  client.setCACert(root_ca);
  
  HTTPClient https;
  if (https.begin(client, "https://api.didactico.tn/iot")) {
    https.addHeader("Content-Type", "application/json");
    String payload = "{"temp":" + String(temp) + "}";
    int code = https.POST(payload);
    Serial.printf("HTTPS code: %dn", code);
    https.end();
  }
}

6. Envoi vers ThingSpeak avec dashboard

ThingSpeak (MathWorks) est le service IoT le plus simple pour debuter. Compte gratuit limite a 8200 messages/jour, dashboard inclus, MATLAB analytics.

Etapes :

1. Creer compte sur thingspeak.com
2. Creer un nouveau Channel avec 8 fields (temp, hum, etc.)
3. Recuperer la Write API Key
4. Envoyer en HTTP GET

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

String apiKey = "VOTRE_WRITE_API_KEY";
String server = "http://api.thingspeak.com/update";

void envoyerThingSpeak(float temp, float hum, float lux) {
  HTTPClient http;
  String url = server + "?api_key=" + apiKey 
             + "&field1=" + String(temp)
             + "&field2=" + String(hum)
             + "&field3=" + String(lux);
  http.begin(url);
  int code = http.GET();
  Serial.printf("ThingSpeak %dn", code);
  http.end();
}

void loop() {
  envoyerThingSpeak(23.5, 65.2, 480);
  delay(20000);  // Min 15 sec entre envois (free tier)
}

7. MQTT temps reel avec PubSubClient

HTTP, c’est bien pour des envois ponctuels. MQTT, c’est pour le temps reel. Latence < 100 ms, payload minimal (~10 octets de header), QoS 0/1/2, support de millions de connexions simultanees.

Architecture : un broker MQTT (Mosquitto, HiveMQ, EMQX) au centre, des publishers (vos ESP32) et des subscribers (vos dashboards, apps mobiles). Les messages sont organises en topics hierarchiques.

#include <WiFi.h>
#include <PubSubClient.h>

const char* mqtt_server = "broker.hivemq.com";
const int mqtt_port = 1883;  // 8883 pour TLS

WiFiClient espClient;
PubSubClient client(espClient);

void callback(char* topic, byte* payload, unsigned int length) {
  String msg = "";
  for (int i = 0; i < length; i++) msg += (char)payload[i];
  Serial.printf("Recu [%s] : %sn", topic, msg.c_str());
  
  // Exemple : commande LED
  if (String(topic) == "didactico/esp32-01/cmd/led") {
    digitalWrite(LED_BUILTIN, msg == "ON" ? HIGH : LOW);
  }
}

void reconnectMQTT() {
  while (!client.connected()) {
    String clientId = "DIDA-" + String(WiFi.macAddress());
    if (client.connect(clientId.c_str())) {
      Serial.println("MQTT connecte");
      client.subscribe("didactico/esp32-01/cmd/#");
    } else {
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  // WiFi.begin(...) ou WiFiManager
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
}

void loop() {
  if (!client.connected()) reconnectMQTT();
  client.loop();
  
  // Publier toutes les 10 sec
  static unsigned long lastPub = 0;
  if (millis() - lastPub > 10000) {
    lastPub = millis();
    String payload = "{"temp":23.5,"hum":65}";
    client.publish("didactico/esp32-01/data", payload.c_str());
  }
}

8. Firebase Realtime Database

Pour synchroniser un ESP32 avec une app mobile (Flutter, React Native), Firebase Realtime Database est imbattable. La lib Firebase ESP32 Client de Mobizt (mobizt/Firebase-ESP-Client) gere tout.

#include <WiFi.h>
#include <Firebase_ESP_Client.h>

#define API_KEY "VOTRE_API_KEY"
#define DATABASE_URL "https://didactico-iot-default-rtdb.firebaseio.com"
#define USER_EMAIL "esp32@didactico.tn"
#define USER_PASSWORD "motdepasse"

FirebaseData fbdo;
FirebaseAuth auth;
FirebaseConfig config;

void setup() {
  // ... WiFi setup
  config.api_key = API_KEY;
  config.database_url = DATABASE_URL;
  auth.user.email = USER_EMAIL;
  auth.user.password = USER_PASSWORD;
  Firebase.begin(&config, &auth);
}

void loop() {
  if (Firebase.ready()) {
    Firebase.RTDB.setFloat(&fbdo, "/esp32-01/temp", 23.5);
    Firebase.RTDB.setFloat(&fbdo, "/esp32-01/hum", 65.2);
    Firebase.RTDB.setInt(&fbdo, "/esp32-01/ts", millis());
  }
  delay(5000);
}

9. OTA Updates : mises a jour a distance

Imaginez : 100 ESP32 deployes dans 100 maisons clients. Vous trouvez un bug. Il faut tous les recuperer pour reflasher ? Non. OTA (Over The Air) permet de pousser un nouveau firmware via WiFi en 30 secondes.

#include <WiFi.h>
#include <ArduinoOTA.h>

void setup() {
  // ... WiFi setup
  
  ArduinoOTA.setHostname("esp32-didactico-01");
  ArduinoOTA.setPassword("didacticoOTA2026");
  
  ArduinoOTA.onStart([]() {
    Serial.println("OTA Start");
  });
  ArduinoOTA.onEnd([]() {
    Serial.println("OTA End");
  });
  ArduinoOTA.onProgress([](unsigned int p, unsigned int t) {
    Serial.printf("OTA %u%%n", (p / (t / 100)));
  });
  ArduinoOTA.onError([](ota_error_t error) {
    Serial.printf("Erreur OTA: %un", error);
  });
  ArduinoOTA.begin();
}

void loop() {
  ArduinoOTA.handle();
  // ... votre code
}

Dans Arduino IDE : Outils > Port > choisissez l’ESP32 par son hostname (apparait apres 30 sec). Code uploade via WiFi.

10. Deep sleep : autonomie de plusieurs mois sur batterie

Un ESP32 en marche normale consomme 80-160 mA. En deep sleep, 10 µA. La difference est de 1 a 16 000. Pour un capteur qui envoie 1 mesure toutes les 15 min, le deep sleep multiplie l’autonomie par 50-100.

#include <esp_sleep.h>

#define uS_TO_S_FACTOR 1000000ULL
#define TIME_TO_SLEEP  900  // 15 minutes en secondes

void setup() {
  Serial.begin(115200);
  // Reveil rapide, lecture capteur, envoi MQTT, dormir
  
  connectWiFi();  // ~3 secondes
  float temp = readSensor();
  sendMQTT(temp);
  
  Serial.println("Sleep 15 min...");
  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
  esp_deep_sleep_start();
}

void loop() {
  // Jamais execute, le setup() est rejoue apres chaque reveil
}

11. Securite : les 7 commandements de l’ESP32 en production

1. JAMAIS hardcoder les credentials WiFi dans le firmware. Utiliser WiFiManager + NVS Preferences.
2. JAMAIS HTTP en clair. HTTPS avec certificat valide ou MQTT avec TLS sur le port 8883.
3. API keys uniques par device. Generez un token JWT signé par votre serveur.
4. Flash encryption + Secure Boot en production. Active dans menuconfig (ESP-IDF).
5. OTA signe. Verifier la signature du firmware avant flash.
6. Limiter les ports ouverts. Si vous n’utilisez pas Telnet, ne lancez pas le service.
7. WiFi Enterprise (WPA2-EAP) pour entreprises. Authentification par certificat client.

12. FAQ – ESP32 WiFi IoT

Conclusion : l’ESP32 est le futur de l’IoT en Tunisie

L’ESP32 n’est pas juste “l’Arduino avec WiFi”. C’est une plateforme IoT complete avec WiFi, BT, BLE, cryptographie hardware, 18 ADC, et un ecosysteme Arduino mature. Pour 15 TND chez Didactico, vous avez la puissance de calcul d’un PC de 2005 dans un module qui tient sur un dirham.

Pour aller plus loin, decouvrez nos guides ESP32 vs ESP8266 : Lequel Choisir ? et ESP32 LoRa pour l’Agriculture Tunisienne. Livraison 24-48h partout en Tunisie depuis notre stock Sfax. Etudiants ENIT, INSAT, ESPRIT, ISET : tarif preferentiel sur presentation de carte etudiante.

🛒 Matériel nécessaire pour ce guide

Tout le matériel de ce tutoriel est disponible chez Didactico — livraison 24-48h partout en Tunisie, paiement à la livraison.

Module Expressif ESP32-WROOM-32D 8M 64Mbit36,000 TNDCarte de développement ESP32-S3 WiFi Bluetooth BLE 5.0 Mesh N8R240,000 TNDSuper Mini Carte ESP32-C3 WiFi+BT (Type-C)32,000 TND

Voir toute la catégorie « Cartes Programmables » →

📘 Guides liés : ESP32 vs ESP8266 : Lequel Choisir pour votre Projet IoT en Tunisie (2026) · ESP32 LoRa : Reseau Multi-Capteurs Longue Portee pour l'Agriculture Tunisienne