diff --git a/e5652004-dbab-44f0-b4fa-85948b357769/draft_overlay.json b/e5652004-dbab-44f0-b4fa-85948b357769/draft_overlay.json
new file mode 100644
index 0000000..8f7c3a9
--- /dev/null
+++ b/e5652004-dbab-44f0-b4fa-85948b357769/draft_overlay.json
@@ -0,0 +1,4 @@
+{
+    "title": "Commander une LED en Wifi",
+    "_updated_at": "2026-05-15 21:44:03"
+}
diff --git a/e5652004-dbab-44f0-b4fa-85948b357769/draft_overlay.md b/e5652004-dbab-44f0-b4fa-85948b357769/draft_overlay.md
new file mode 100644
index 0000000..56bfa3e
--- /dev/null
+++ b/e5652004-dbab-44f0-b4fa-85948b357769/draft_overlay.md
@@ -0,0 +1,146 @@
+# Commander une LED en Wifi
+
+![Schéma : commander la LED intégrée à une carte ESP8266 depuis une page HTML via une connexion Wifi.](architecture-esp-wifi.png)
+
+Nous avons vu dans le chapitre précédent comment la carte ESP8266 peut se connecter à un **point d'accès** Wifi. Nous nous fixons maintenant comme objectif de connecter l'ESP8266 au même réseau qu'un smartphone ou un ordinateur afin de commander une LED depuis ces derniers. Pour ce faire, nous allons configurer l'ESP8266 de manière à ce qu'il joue le rôle de **serveur** : il offrira une page Web à l'utilisateur, et cette page permettra de commander la LED intégrée à la carte de développement.
+
+## La LED intégrée à la carte
+
+![Carte ESP-12F avec la LED intégrée allumée.](esp12f-led-allumee.png)
+
+La plupart des cartes de développement à base d'ESP8266 (NodeMCU, Wemos D1 mini, ESP-12F sur platine, etc.) embarquent une LED soudée directement sur la carte. C'est cette LED qui clignote faiblement lors du téléversement d'un programme, et c'est également elle qui s'allume avec l'exemple classique *Blink*.
+
+Le GPIO sur lequel cette LED est câblée dépend de la carte : il s'agit le plus souvent du **GPIO 2** (NodeMCU, Wemos D1 mini), mais sur certains modules c'est le **GPIO 16**. Plutôt que de retenir ce numéro, nous utiliserons la **constante** `LED_BUILTIN`, définie par le cœur Arduino pour l'ESP8266 et qui pointe automatiquement vers le bon GPIO selon la carte sélectionnée dans l'IDE.
+
+> **À noter — logique inversée.** Sur la quasi-totalité des cartes ESP8266, la LED intégrée est *active à l'état bas* : on l'allume en écrivant `LOW` sur la broche et on l'éteint en écrivant `HIGH`. C'est l'inverse de ce que l'on observerait avec une LED externe câblée classiquement entre le GPIO et la masse.
+
+## Principe de fonctionnement
+
+Le programme suit un schéma **client / serveur HTTP** très simple :
+
+1. L'ESP8266 se connecte au réseau Wifi et démarre un serveur sur le port 80.
+2. Depuis un navigateur (smartphone ou ordinateur connecté au même réseau), l'utilisateur saisit l'adresse IP de l'ESP.
+3. L'ESP reçoit la requête HTTP, l'analyse pour détecter une commande (`/LED=ON` ou `/LED=OFF`), agit sur la LED en conséquence, puis renvoie une page HTML contenant deux liens de commande ainsi que l'état courant de la LED.
+
+## Le code
+
+```c
+#include <ESP8266WiFi.h>
+
+const char* ssid     = "MON-RESEAU-WIFI";
+const char* password = "leMotDePasseDuReseauWifi";
+
+// Variable globale : état courant de la LED.
+// La LED étant active à l'état bas, HIGH = éteinte au démarrage.
+int valeurLED = HIGH;
+
+// Déclaration du serveur sur le port 80
+WiFiServer server(80);
+
+void setup() {
+  // Initialisation de la communication série
+  Serial.begin(115200);
+  delay(100);
+
+  // Initialisation de la sortie pour la LED
+  pinMode(LED_BUILTIN, OUTPUT);
+  digitalWrite(LED_BUILTIN, valeurLED);
+
+  // Connexion au Wifi
+  Serial.println();
+  Serial.print("Connexion au réseau Wifi ");
+  Serial.println(ssid);
+
+  WiFi.begin(ssid, password);
+
+  // Connexion en cours...
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+  Serial.println();
+  Serial.println("Réseau Wifi connecté");
+
+  // Démarrage du serveur
+  server.begin();
+  Serial.println("Serveur démarré !");
+
+  // Affichage de l'adresse IP à utiliser dans le navigateur
+  Serial.print("Utiliser cette adresse URL pour la connexion : http://");
+  Serial.print(WiFi.localIP());
+  Serial.println("/");
+}
+
+void loop() {
+  // Attente de connexion d'un client
+  WiFiClient client = server.available();
+  if (!client) {
+    return;
+  }
+
+  Serial.println("Nouveau client");
+
+  // Attendre que le client envoie des données
+  while (!client.available()) {
+    delay(1);
+  }
+
+  // Lecture de la première ligne de la requête HTTP
+  String request = client.readStringUntil('\r');
+  Serial.println(request);
+  client.flush();
+
+  // Interprétation de la requête
+  if (request.indexOf("/LED=ON") != -1) {
+    valeurLED = LOW;             // logique inversée : LOW allume
+    digitalWrite(LED_BUILTIN, valeurLED);
+  }
+  if (request.indexOf("/LED=OFF") != -1) {
+    valeurLED = HIGH;            // HIGH éteint
+    digitalWrite(LED_BUILTIN, valeurLED);
+  }
+
+  // Réponse HTTP : page HTML simple
+  client.println("HTTP/1.1 200 OK");
+  client.println("Content-Type: text/html");
+  client.println("Connection: close");
+  client.println();
+  client.println("<!DOCTYPE HTML>");
+  client.println("<html><head><meta charset=\"utf-8\"></head><body>");
+
+  client.print("<p>La LED est actuellement : <b>");
+  client.print(valeurLED == LOW ? "ALLUMÉE" : "ÉTEINTE");
+  client.println("</b></p>");
+
+  client.println("<p><a href=\"/LED=ON\">Allumer la LED</a></p>");
+  client.println("<p><a href=\"/LED=OFF\">Éteindre la LED</a></p>");
+  client.println("</body></html>");
+
+  // Fermeture propre de la connexion
+  delay(1);
+  client.stop();
+  Serial.println("Client déconnecté");
+  Serial.println();
+}
+```
+
+## Pour aller plus loin
+
+Jusqu'à présent, l'ESP a assumé trois rôles à lui seul : **présenter une page Web**, **commander la LED** et **informer de son état**. Cette approche est pratique pour apprendre, mais elle ne correspond pas vraiment à ce qui se fait dans l'écosystème des objets connectés.
+
+Dans un déploiement réel, l'ESP se contente le plus souvent d'**exposer une API** (par exemple en JSON), et c'est un service centralisé comme **Domoticz**, **Home Assistant** ou **OpenHAB** qui fournit l'interface utilisateur, agrège les différents objets et orchestre les automatisations. Dans le chapitre suivant, nous modifierons donc ce programme pour qu'il renvoie une réponse JSON plutôt qu'une page HTML, ce qui en fera un véritable objet connecté prêt à être intégré à une plateforme domotique.
+
+---
+
+**Notes sur les corrections apportées par rapport à la version d'origine :**
+
+- Référence au « chapitre [..] » remplacée par « chapitre précédent ».
+- Image placeholder `dummy.png` remplacée par un nom de fichier explicite décrivant un vrai schéma d'architecture à produire.
+- Précision sur le GPIO de la LED (variable selon la carte) ; usage systématique de `LED_BUILTIN` dans le code.
+- Ajout d'un encadré expliquant la **logique inversée** (LOW = allumée).
+- Ajout d'une section « Principe de fonctionnement » avant le code.
+- Conclusion (« Pour aller plus loin ») déplacée à la fin et reformulée pour amorcer le chapitre suivant.
+- **Code corrigé** : commentaires `//` rétablis (les `-` et `*` étaient des artefacts de conversion Markdown), `valeurLED` passée en variable globale, déclaration manquante `WiFiClient client` ajoutée, `"http:*"` corrigé en `"http://"`, en-têtes HTTP complétés (`Connection: close`), `client.stop()` ajouté pour fermer proprement, et **vraie page HTML** renvoyée (avec liens de commande et état de la LED), conforme à la promesse de l'introduction.
+- Orthographe corrigée : « intégrée », « un programme », « utilisé », « connecté », « Démarrage ».
+- « rezo » remplacé par « réseau » dans les chaînes d'exemple.
+- Gras allégé, réservé aux notions clés à la première occurrence.
\ No newline at end of file