Quel est le coût total pour contrôler l'éclairage avec ESP32 ?

Le coût total est d'environ 10-15€ (ESP32: 5€, relais: 3€, alimentation: 2€, composants divers: 3-5€). C'est 70-80% moins cher qu'une solution commerciale comme Philips Hue (50-100€ par ampoule).

Est-ce dangereux de contrôler du 220V avec Arduino/ESP32 ?

Oui, le 220V est dangereux. Utilisez TOUJOURS un module relais opto-isolé pour séparer le circuit 3.3V (ESP32) du circuit 220V. Placez le montage 220V dans un boîtier isolant et ajoutez un fusible. Si vous débutez, commencez par contrôler des LEDs 12V.

Puis-je contrôler l'éclairage depuis l'extérieur de chez moi ?

Oui, avec ESP32 en WiFi. Deux options : 1) Configuration du port forwarding sur votre box pour accéder à l'IP publique, 2) Intégration avec Home Assistant Cloud ou MQTT broker distant pour un accès sécurisé depuis Internet.

Comment intégrer ce système avec Alexa ou Google Home ?

La méthode la plus simple est d'utiliser Home Assistant comme hub central. Installez Home Assistant sur Raspberry Pi, connectez votre ESP32 via MQTT, puis activez l'intégration Alexa/Google Home dans Home Assistant. Alternative : utilisez ESPHome qui génère automatiquement des entités compatibles.

Quelle est la portée du contrôle Bluetooth ?

La portée Bluetooth classique (HC-05 ou Bluetooth ESP32) est d'environ 10 mètres en intérieur sans obstacle. Pour une portée supérieure, privilégiez le WiFi (ESP32) qui couvre toute la maison via votre routeur.

Contrôle à Distance de l'Éclairage avec Arduino/ESP32 : Guide DIY Complet (2026)

⚠️ AVERTISSEMENT DE SÉCURITÉ : Ce projet implique la manipulation de tensions secteur 220V. Si vous n'êtes pas familier avec l'électricité, faites-vous assister par un professionnel. Utilisez toujours des modules relais isolés et respectez les normes de sécurité électrique.

Schéma de contrôle d'éclairage DIY avec Arduino ESP32 et module relais WiFi pour domotique maison connectée

Apprenez à construire votre propre système de contrôle d'éclairage à distance en utilisant Arduino ou ESP32. Ce guide DIY complet inclut schémas de câblage, code Arduino, modules WiFi/Bluetooth et solutions domotiques économiques pour transformer votre appartement en maison intelligente.

Pourquoi Contrôler l'Éclairage avec Arduino/ESP32 ?

Contrairement aux solutions commerciales coûteuses (Philips Hue, Legrand Netatmo), construire votre propre système de contrôle d'éclairage avec Arduino ou ESP32 vous offre :

Économie : Coût réduit de 70-80% par rapport aux solutions commerciales
Personnalisation totale : Programmez exactement ce que vous voulez
Apprentissage : Maîtrisez les bases de la domotique et de l'électronique
Compatibilité : Intégration facile avec Home Assistant, MQTT, Alexa, Google Home

📦 Méthode 1 : Contrôle WiFi avec ESP32 (Recommandé)

Liste des Composants (BOM) :

ESP32 DevKit V1 : Microcontrôleur WiFi/Bluetooth (~5€)
Module Relais 1 ou 2 canaux 5V : Pour commuter les lampes 220V (~3€)
Module Alimentation 5V : HLK-PM01 ou adaptateur USB (~2€)
Transistor NPN : BC547 ou 2N2222 (protection GPIO)
Résistances : 220Ω, 10kΩ
Breadboard et câbles : Pour le prototypage
Boîtier plastique : Pour sécuriser le montage 220V

Coût total estimé : 10-15€ (contre 50-100€ pour une solution commerciale)

🔌 Schéma de Câblage ESP32 + Relais :

ESP32                Module Relais
─────                ─────────────
GPIO 18 (D18)  ──→  IN (Signal)
3.3V           ──→  VCC (Alimentation)
GND            ──→  GND (Masse commune)

Module Relais      Lampe 220V
─────────────      ──────────
COM (Commun)  ──→  Phase secteur (L)
NO (Normally Open) → Lampe → Neutre (N)

️ Important : Le module relais doit être isolé optiquement pour séparer le circuit 3.3V (ESP32) du circuit 220V (lampe).

💻 Code Arduino pour ESP32 (Serveur Web) :

/*
 * Contrôle d'Éclairage à Distance avec ESP32
 * Projet TechFix Hub - Domotique DIY
 * Interface Web pour allumer/éteindre lampe via WiFi
 */

#include <WiFi.h>
#include <WebServer.h>

// Configuration WiFi
const char* ssid = "VOTRE_SSID";
const char* password = "VOTRE_MDP";

// Configuration relais
const int relayPin = 18;  // GPIO 18 connecté au relais
WebServer server(80);

// Page HTML interface web
const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE html>
<html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Contrôle Éclairage ESP32</title>
  <style>
    body { font-family: Arial; text-align: center; margin-top: 50px; }
    .button {
      display: inline-block;
      padding: 20px 40px;
      font-size: 24px;
      margin: 10px;
      cursor: pointer;
      border: none;
      border-radius: 10px;
      color: white;
    }
    .on { background-color: #4CAF50; }
    .off { background-color: #f44336; }
    .status { margin-top: 20px; font-size: 20px; }
  </style>
</head>
<body>
  <h1>💡 Contrôle Éclairage</h1>
  <button class="button on" onclick="sendCommand('on')">ALLUMER</button>
  <button class="button off" onclick="sendCommand('off')">ÉTEINDRE</button>
  <div class="status" id="status">État: Inconnu</div>
  
  <script>
    function sendCommand(cmd) {
      fetch('/' + cmd)
        .then(response => response.text())
        .then(data => {
          document.getElementById('status').innerHTML = 'État: ' + data;
        });
    }
    
    // Mise à jour automatique toutes les 5 secondes
    setInterval(() => {
      fetch('/status')
        .then(response => response.text())
        .then(data => {
          document.getElementById('status').innerHTML = 'État: ' + data;
        });
    }, 5000);
  </script>
</body>
</html>
)rawliteral";

void setup() {
  Serial.begin(115200);
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, LOW);  // Relais éteint au démarrage
  
  // Connexion WiFi
  Serial.print("Connexion au WiFi");
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println(" Connecté!");
  Serial.print("Adresse IP: ");
  Serial.println(WiFi.localIP());
  
  // Routes serveur web
  server.on("/", [](){
    server.send(200, "text/html", index_html);
  });
  
  server.on("/on", [](){
    digitalWrite(relayPin, HIGH);  // Allume la lampe
    server.send(200, "text/plain", "ALLUMÉ ✓");
    Serial.println("Lampe ALLUMÉE");
  });
  
  server.on("/off", [](){
    digitalWrite(relayPin, LOW);   // Éteint la lampe
    server.send(200, "text/plain", "ÉTEINT ✗");
    Serial.println("Lampe ÉTEINTE");
  });
  
  server.on("/status", [](){
    String status = digitalRead(relayPin) == HIGH ? "ALLUMÉ ✓" : "ÉTEINT ✗";
    server.send(200, "text/plain", status);
  });
  
  server.begin();
  Serial.println("Serveur HTTP démarré");
}

void loop() {
  server.handleClient();
  delay(2);
}

    

Comment Utiliser :

Téléverser le code : Compilez et téléversez le code sur l'ESP32 via Arduino IDE
Modifier WiFi : Remplacez "VOTRE_SSID" et "VOTRE_MDP" par vos identifiants WiFi
Accéder à l'interface : Ouvrez le Moniteur Série pour voir l'adresse IP (ex: 192.168.1.100)
Contrôler : Tapez cette IP dans votre navigateur smartphone/PC pour contrôler la lampe

Méthode 2 : Contrôle Bluetooth avec Arduino/ESP32

Pour un contrôle sans WiFi, utilisez le Bluetooth intégré de l'ESP32 ou un module HC-05 avec Arduino.

/*
 * Contrôle Éclairage via Bluetooth avec ESP32
 * Application mobile recommandée: "Bluetooth Electronics" ou "Arduino Bluetooth Controller"
 */

#include <BluetoothSerial.h>

#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
#endif

BluetoothSerial BT;
const int relayPin = 18;

void setup() {
  Serial.begin(115200);
  BT.begin("ESP32_Eclairage");  // Nom Bluetooth visible
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, LOW);
  Serial.println("Bluetooth prêt! Appairez-vous avec 'ESP32_Eclairage'");
}

void loop() {
  if (BT.available()) {
    char cmd = BT.read();
    
    if (cmd == '1' || cmd == 'ON' || cmd == 'on') {
      digitalWrite(relayPin, HIGH);
      BT.println("Lampe ALLUMEE");
      Serial.println("Lampe ALLUMEE via Bluetooth");
    }
    else if (cmd == '0' || cmd == 'OFF' || cmd == 'off') {
      digitalWrite(relayPin, LOW);
      BT.println("Lampe ETEINTE");
      Serial.println("Lampe ETEINTE via Bluetooth");
    }
  }
}

    

🌐 Méthode 3 : Intégration avec Home Assistant (MQTT)

Pour une domotique avancée, intégrez votre ESP32 avec Home Assistant via MQTT.

Composants additionnels :

Broker MQTT : Mosquitto installé sur Raspberry Pi ou PC
Bibliothèque PubSubClient : Pour communication MQTT
Home Assistant : Plateforme domotique open-source

Méthode 4 : Contrôle par Détecteur de Mouvement PIR

Automatisez l'éclairage avec un capteur PIR HC-SR501.

Câblage Capteur PIR :

Capteur PIR HC-SR501    ESP32
────────────────────    ─────
VCC                ──→  5V ou 3.3V
OUT                ──→  GPIO 19 (D19)
GND                ──→  GND

// Réglages PIR :
// - Potentiomètre "Time" : Durée d'allumage (5s à 5min)
// - Potentiomètre "Sensitivity" : Distance de détection (3m à 7m)

/*
 * Éclairage Automatique avec Détecteur de Mouvement PIR
 * Allumage automatique lors de détection, extinction après délai
 */

const int pirPin = 19;      // Broche sortie PIR
const int relayPin = 18;    // Broche relais
const unsigned long delayTime = 30000;  // 30 secondes avant extinction

unsigned long lastMotionTime = 0;
bool lightOn = false;

void setup() {
  pinMode(pirPin, INPUT);
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, LOW);
  Serial.begin(115200);
  Serial.println("Système PIR prêt");
}

void loop() {
  int motionDetected = digitalRead(pirPin);
  
  if (motionDetected == HIGH) {
    lastMotionTime = millis();
    if (!lightOn) {
      digitalWrite(relayPin, HIGH);
      lightOn = true;
      Serial.println("Mouvement détecté - Lampe ALLUMÉE");
    }
  }
  
  // Extinction automatique après délai
  if (lightOn && (millis() - lastMotionTime > delayTime)) {
    digitalWrite(relayPin, LOW);
    lightOn = false;
    Serial.println("Délai écoulé - Lampe ÉTEINTE");
  }
  
  delay(100);
}

    

🔧 Dépannage et Sécurité

⛔ Règles de Sécurité Critiques :

Isolation : Utilisez TOUJOURS un module relais opto-isolé pour séparer 3.3V et 220V
Boîtier : Placez le circuit 220V dans un boîtier plastique isolant
Fusible : Ajoutez un fusible 2A sur la ligne 220V
Section de câble : Utilisez du câble 1.5mm² minimum pour le 220V
Coupez le courant : Toujours travailler hors tension lors du câblage 220V

Problèmes Courants :

ESP32 ne se connecte pas au WiFi : Vérifiez les identifiants et la portée du signal
Relais ne commute pas : Vérifiez l'alimentation 5V du relais et la connexion GPIO
Interface web inaccessible : Vérifiez que l'ESP32 et votre smartphone sont sur le même réseau WiFi
Relais clignote : Problème d'alimentation - utilisez une alimentation externe 5V 1A

💡 Améliorations Possibles

Gradation : Utilisez un TRIAC (BT136) au lieu d'un relais pour varier l'intensité
Multi-zones : Ajoutez plusieurs relais pour contrôler différentes pièces
Commande vocale : Intégrez avec Alexa ou Google Home via MQTT
Programmation : Ajoutez une RTC (DS3231) pour allumage automatique horaires
Consommation : Ajoutez un capteur de courant (ACS712) pour suivre la consommation

📊 Comparaison des Solutions

Méthode	Coût	Difficulté	Portée	Fonctionnalités
ESP32 WiFi	10-15€	Moyenne	WiFi (maison)	Interface web, app mobile
Bluetooth	8-12€	Facile	10m	Contrôle local uniquement
PIR Auto	12-17€	Facile	Détection 3-7m	Automatisation complète
Home Assistant	15-20€	Avancée	Internet	Scénarios complexes, voice

Conclusion

Construire votre propre système de contrôle d'éclairage avec ESP32 ou Arduino est non seulement économique (70-80% moins cher que les solutions commerciales), mais vous offre une flexibilité totale. Que vous choisissiez le contrôle WiFi, Bluetooth, l'automatisation PIR ou l'intégration Home Assistant, vous maîtrisez désormais les bases de la domotique DIY.

Prochaines étapes recommandées :

Commencez par la méthode ESP32 WiFi (la plus polyvalente)
Ajoutez un détecteur PIR pour l'automatisation
Intégrez avec Home Assistant pour une domotique complète
Explorez nos autres projets IoT et domotique

Rappel sécurité : La manipulation du 220V est dangereuse. Si vous débutez en électronique, commencez par contrôler des LEDs 12V avant de passer au 220V.

Author Description