Projet domotique Arduino : maquette de maison connectée et code

Un projet domotique Arduino consiste à automatiser avec des capteurs les lumières, la porte, la fenêtre et les alarmes d'une maquette de maison, puis, si tu le souhaites, à tout piloter depuis ton smartphone. C'est l'un des projets scolaires les plus appréciés, et ce n'est pas un hasard. Une lumière de couloir qui s'allume quand elle détecte un mouvement, une alarme qui sonne en cas de fuite de gaz, un ventilateur qui démarre quand il fait chaud et une porte qui s'ouvre avec un badge forment une copie miniature, mais fonctionnelle, d'une vraie maison connectée. Avec un Arduino Uno ou un ESP32, une dizaine de modules et un week-end, tu peux le faire toi aussi.

Dans ce guide, on commence par le plan de la maquette : quel module va dans quelle pièce, où passe le budget, comment prévoir l'alimentation et comment répartir les broches. Ensuite, on monte et on teste chaque module séparément, puis on écrit le code Arduino complet qui les fait tous fonctionner en même temps sans utiliser delay(). Dans les dernières parties, tu verras comment piloter la maison depuis ton smartphone avec un serveur web sur ESP32 ou avec Blynk, comment corriger les erreurs les plus courantes et comment impressionner le jury lors de ta présentation au collège ou au lycée.

Comment fonctionne une maison connectée ?

Toute maison connectée repose sur la même boucle en trois parties. Les capteurs mesurent l'environnement : quelqu'un bouge-t-il, fait-il nuit, quelle est la température, y a-t-il du gaz ou une flamme dans la cuisine, quel badge a été présenté à la porte ? Le contrôleur, c'est-à-dire l'Arduino ou l'ESP32, compare ces informations à des règles : "s'il fait sombre et qu'il y a du mouvement, allume la lumière", "si la température dépasse 28 °C, démarre le ventilateur". Les actionneurs exécutent la décision : le relais allume la lampe et le ventilateur, le servo fait pivoter la porte et la fenêtre, le buzzer sonne et l'écran affiche l'état. Le pilotage par smartphone ajoute simplement une entrée de plus à cette boucle ; cette fois, c'est ton doigt qui décide au lieu d'une règle.

Bien planifier la maquette

Conçois la maquette autour de l'électronique ; n'essaie pas de caser l'électronique à la fin. Une base d'environ 50×40 cm suffit pour deux ou trois pièces et une entrée. Pour les murs, le carton plume de 5 mm ou le PVC expansé (type Forex) se coupe facilement au cutter ; le MDF de 3–4 mm est plus solide mais demande une scie ou une découpe laser. L'échelle 1:20 est un bon point de départ : un plafond de 2,6 m devient un mur de 13 cm et une porte de 90 cm fait 4,5 cm de large. Rends le toit amovible ou supprime-le ; le jury voudra voir l'intérieur des pièces.

• Local technique ou double plancher : place l'Arduino, la plaque d'essai, le module relais et l'arrivée d'alimentation dans un compartiment à l'arrière de la maison ou sous un double plancher de 3–4 cm de haut. Si tu le couvres de plexiglas transparent, le circuit est à la fois protégé et visible.
• Passages de câbles : perce un trou de 6–8 mm sous chaque capteur et fais passer les câbles sous la base jusqu'au local technique. Plutôt que de raccorder des fils courts entre eux, choisis dès le départ des câbles assez longs pour les capteurs.
• Porte : fixe la porte au mur avec une petite charnière ou du ruban adhésif et relie le palonnier du SG90 à la porte avec un fil de fer tiré d'un trombone. Colle le RC522 sur la face intérieure du mur extérieur ; le lecteur lit généralement le badge à travers une plaque de 5 mm.
• Cuisine : dans une vraie maison, un détecteur de gaz naturel (méthane) se place près du plafond car ce gaz est plus léger que l'air, et un détecteur de GPL (butane, propane) près du sol car ce gaz est plus lourd ; pour une maquette, un emplacement près du plafond suffit. Oriente le capteur de flamme vers la cuisinière.
• Autres capteurs : place le PIR dans un angle qui voit le passage d'entrée de côté, la LDR sur un mur extérieur ou une fenêtre où elle ne voit pas la lumière de la lampe, et le DHT11 loin de la lampe et du boîtier chaud du MQ-2.

Liste du matériel et coût

Les prix changent souvent selon le vendeur et dans le temps, donc on ne donne pas de chiffres ; le tableau montre le poids de chaque composant dans le budget. Pris séparément, les capteurs et les modules coûtent peu ; l'essentiel du budget part dans la carte, l'écran LCD, l'alimentation et le matériel de maquette. Si tu as un kit de démarrage Arduino, tu as déjà la carte, la plaque d'essai, les fils, la LDR, le buzzer et souvent un servo et un écran LCD. Avec un petit budget, tu peux te passer de l'écran et du deuxième servo : tu utilises le moniteur série à la place de l'écran et tu gardes la fenêtre pour une deuxième étape. Un DHT22, plus précis que le DHT11, coûte un peu plus cher mais rend tes mesures plus convaincantes lors de la présentation.

Alimentation : pourquoi un bloc 5 V séparé ?

Sur les maquettes de maison connectée, presque toutes les plaintes du type "ça redémarre de temps en temps", "le servo tremble" ou "des caractères bizarres apparaissent sur l'écran" viennent de l'alimentation. Le port USB d'un ordinateur fournit environ 500 mA, et quand la carte est alimentée par USB, la broche 5V de l'Uno dépend elle aussi de cette limite. En additionnant les valeurs ci-dessous, tu verras que le courant total dépasse facilement 1 A quand les deux servos bougent en même temps.

Plan des broches : Arduino Uno et ESP32

Avec autant de modules, l'Uno n'a presque plus de broches libres ; il faut donc les planifier dès le début. Le RC522 utilise le SPI matériel, ses lignes MOSI, MISO et SCK sont donc fixées sur D11, D12 et D13. L'écran n'utilise que A4 et A5 via l'I2C ; c'est pour cela qu'on a choisi un écran avec module I2C plutôt qu'un LCD branché en parallèle. Les broches analogiques fonctionnent aussi comme broches numériques si besoin, ce qui permet de brancher le servo de la fenêtre sur A2. Laisse D0 et D1 libres : cette liaison série sert à téléverser le code et à lire les numéros des badges dans le moniteur série. Tu peux voir le brochage de ta carte avec l'outil Pinout.

Assemblage étape par étape

1. Construis la structure de la maquette et prépare l'emplacement des modules et les trous pour les câbles ; installe l'électronique en dernier.
2. Mets en place la ligne d'alimentation : branche l'alimentation 5 V sur les rails de la plaque d'essai, relie son GND au GND de l'Arduino et vérifie les 5 V au multimètre.
3. Branche l'écran LCD I2C et affiche un texte. Si tu ne trouves pas l'adresse de l'écran, utilise le programme scanner de l'article sur l'écran LCD I2C.
4. Ajoute les capteurs un par un : DHT11, LDR, PIR, MQ-2 et capteur de flamme. Teste chacun avec un petit programme dans le moniteur série et note les valeurs en air propre, dans le noir et à la lumière.
5. Ajoute les actionneurs : teste d'abord les relais sans charge en observant leur clic et leur LED, puis les servos sur l'alimentation externe, et branche enfin le RC522. Présente tes badges et note leurs numéros.
6. Téléverse le programme principal et règle les seuils GAS_LIMIT, DARK_LIMIT et FAN_ON d'après tes notes.
7. Fixe les câbles à la colle chaude et étiquette-les ; laisse le système allumé une demi-heure et surveille les redémarrages, les échauffements ou les fausses alarmes.

Lumière automatique avec PIR et LDR

Le capteur PIR HC-SR501 détecte les variations du rayonnement infrarouge émis par le corps humain et met sa sortie à HIGH quand il voit un mouvement. Avec un PIR seul, la lampe s'allumerait aussi en plein jour ; notre règle a donc deux conditions : allumer s'il y a du mouvement et qu'il fait sombre. La LDR est montée en pont diviseur avec une résistance de 10 kΩ (5V → LDR → A1 → 10 kΩ → GND), et la valeur lue sur A1 baisse quand la lumière diminue. Le code mémorise l'heure du dernier mouvement et éteint la lampe après 20 secondes sans nouveau mouvement ; tant que quelqu'un se déplace, le délai repart à zéro. Mets le cavalier du capteur sur H (déclenchement répété) et son potentiomètre Tx au minimum, et laisse le code gérer la durée. Plus de détails dans les articles sur le détecteur de mouvement PIR et le capteur de lumière LDR.

Alarme gaz et incendie

Le MQ-2 contient une couche de dioxyde d'étain maintenue chaude par un élément chauffant ; le GPL, le méthane, le butane, l'hydrogène, l'alcool et la fumée modifient sa résistance. La broche AO du module fournit une tension qui augmente avec la concentration de gaz. Le capteur doit chauffer à chaque mise sous tension, c'est pourquoi le code ignore les alarmes de gaz pendant les 60 premières secondes. Le capteur de flamme détecte la lumière infrarouge de 760–1100 nm émise par le feu ; sur la plupart des modules, la sortie DO passe à LOW et une deuxième LED s'allume sur la carte quand une flamme est vue, mais vérifie toujours ton module avec un briquet tenu à bonne distance. En cas de gaz, l'alarme sonne et la fenêtre s'ouvre pour aérer ; en cas de flamme, la fenêtre reste fermée, car l'air frais attise le feu. Le réglage du seuil et les autres capteurs MQ sont expliqués dans l'article sur le capteur de gaz MQ-2.

Température, humidité et ventilateur automatique

Le DHT11 mesure la température de 0 à 50 °C à ±2 °C près et l'humidité de 20 à 90 % à ±5 % près, et on ne peut pas l'interroger plus d'une fois par seconde ; le code le lit toutes les deux secondes. Au lieu d'un seuil unique, on utilise une hystérésis pour le ventilateur : il démarre à 28 °C mais ne s'arrête que lorsque la température redescend à 26 °C. Avec un seul seuil, le relais claquerait sans arrêt pendant que la température oscille entre 27 et 28 °C, ce qui userait le relais comme le ventilateur. Si le capteur rate une lecture et renvoie "nan", le code ignore cette mesure et garde la dernière valeur valide. Pour des mesures plus précises, le DHT22 fonctionne avec le même code ; il suffit d'écrire DHT22 à la place de DHT11. Plus de détails dans l'article sur le capteur de température et d'humidité DHT11.

Porte à badge RFID avec servo

Le RC522 lit les cartes et porte-clés MIFARE à 13,56 MHz à 3–5 cm de distance. Chaque carte possède un numéro d'identification unique (UID), et le code compare l'UID lu à une liste de badges autorisés. S'il correspond, le servo ouvre la porte à 90 degrés, un bip court retentit et l'écran affiche "Hos geldin!" ("Bienvenue !" en turc) ; 5 secondes plus tard, la porte se referme toute seule. Un badge inconnu déclenche un bip long. Pour connaître l'UID de tes badges, téléverse le code, ouvre le moniteur série à 9600 bauds et présente un badge : tu verras une ligne comme "UID: A1 B2 C3 D4". Écris ces octets dans la liste CARDS sous la forme 0xA1, en ajoutant un zéro devant ceux affichés avec un seul chiffre (0x05 au lieu de 5). Une serrure qui ne vérifie que l'UID convient pour apprendre mais n'offre aucune vraie sécurité ; on explique pourquoi dans l'article sur le RFID RC522.

Fenêtre et rideau

Pour la fenêtre, un deuxième SG90 suffit : relie une petite fenêtre en plexiglas à charnière au palonnier du servo avec un fil de fer ; 0 degré signifie fermée et 90 degrés ouverte. Appeler write(0) avant attach() évite que le servo saute à 90 degrés à la mise sous tension et claque la fenêtre. Un rideau demande plus de course : il faut enrouler le tissu sur une fine tige et faire tourner celle-ci. Pour cela, un moteur pas à pas 28BYJ-48 avec driver ULN2003 est silencieux et précis, mais il demande 4 broches ; comme l'Uno n'en a plus, mieux vaut réserver le rideau à la version ESP32 ou à un Arduino Mega. Si une seule broche doit suffire, un servo à rotation continue FS90R fait aussi l'affaire, mais comme il ne connaît pas sa position, tu ouvres et fermes le rideau en temporisant. Ajouter un capteur de pluie qui ferme la fenêtre automatiquement quand il pleut est aussi une belle extension.

Lampe et ventilateur avec un relais

Une broche d'Arduino ne fournit sans risque qu'environ 20 mA (la limite absolue est de 40 mA), alors qu'un ventilateur ou une lampe demandent bien plus. C'est pourquoi on intercale un module relais : le signal sur sa broche IN active un électroaimant qui ferme les contacts d'un circuit séparé. Branche la charge sur les bornes COM et NO pour que la lampe reste éteinte quand l'Arduino est éteint ou redémarre. La plupart de ces modules sont actifs à l'état bas : le relais colle quand tu écris LOW ; c'est le rôle des constantes RELAY_ON et RELAY_OFF du code. Dans setup(), le code écrit HIGH avant de passer la broche en sortie, si bien que le relais ne colle pas, même un instant, au démarrage de l'Arduino. On a utilisé une hystérésis pour que le ventilateur ne s'allume et ne s'éteigne pas trop souvent, tandis que la lampe reste allumée jusqu'à la fin du délai du PIR.

Le code complet (Arduino Uno)

La règle la plus importante du code d'une maison connectée est qu'aucun module n'attend un autre. Si tu gardais la porte ouverte 5 secondes avec delay(5000), l'alarme de gaz ne fonctionnerait pas et le PIR ne serait pas lu pendant ce temps. C'est pourquoi chaque module a sa propre fonction, et loop() appelle ces fonctions l'une après l'autre des centaines de fois par seconde. Tout ce qui dépend du temps est mesuré avec millis(), et l'état de chaque module est conservé dans des variables comme lightOn, fanOn, doorOpen et alarmOn. Tous les réglages sont regroupés en haut du code sous forme de constantes ; tu n'as donc pas à fouiller le code pour changer un seuil. Tu trouveras la logique de cette approche dans l'article millis() ou delay(). Pour compiler le code, installe depuis le gestionnaire de bibliothèques MFRC522, la DHT sensor library d'Adafruit et LiquidCrystal I2C de Frank de Brabander, et installe toutes les dépendances quand on te le propose. Servo, SPI et Wire sont fournies avec l'IDE Arduino.

1#include <SPI.h>
2#include <MFRC522.h>
3#include <Servo.h>
4#include <DHT.h>
5#include <Wire.h>
6#include <LiquidCrystal_I2C.h>
7
8// Pinler / Pins
9const byte PIR_PIN = 2, FLAME_PIN = 3, DHT_PIN = 4, BUZZER_PIN = 5, DOOR_PIN = 6;
10const byte LAMP_RELAY = 7, FAN_RELAY = 8, RST_PIN = 9, SS_PIN = 10;
11const byte GAS_PIN = A0, LDR_PIN = A1, WINDOW_PIN = A2;
12
13// Ayarlar / Settings
14const byte RELAY_ON = LOW, RELAY_OFF = HIGH;     // aktif LOW röle / active-LOW relay
15const byte FLAME_ACTIVE = LOW;                   // alev görünce DO LOW olur / DO goes LOW on flame
16const int GAS_LIMIT = 400;                       // temiz havaya göre ayarla / tune in clean air
17const int DARK_LIMIT = 300;                      // bunun altı karanlık / below this is dark
18const float FAN_ON = 28.0, FAN_OFF = 26.0;       // fan histerezisi (°C) / fan hysteresis (°C)
19const unsigned long LIGHT_MS = 20000;            // son hareketten sonra ışık / light after last motion
20const unsigned long DOOR_MS = 5000;              // kapı açık kalma süresi / door open time
21const unsigned long WARMUP_MS = 60000;           // MQ-2 ve PIR ısınması / MQ-2 and PIR warm-up
22
23const byte CARDS[][4] = {                        // yetkili kart UID'leri / authorised card UIDs
24  {0xA1, 0xB2, 0xC3, 0xD4},
25  {0x12, 0x34, 0x56, 0x78}
26};
27
28MFRC522 rfid(SS_PIN, RST_PIN);
29Servo door, window;
30DHT dht(DHT_PIN, DHT11);
31LiquidCrystal_I2C lcd(0x27, 16, 2);
32
33float tempC = 0, hum = 0;
34int gas = 0;
35bool lightOn = false, fanOn = false, doorOpen = false, alarmOn = false;
36unsigned long lastMotion = 0, doorAt = 0, lastDht = 0, lastLcd = 0, beepUntil = 0;
37
38void setup() {
39  Serial.begin(9600);
40  digitalWrite(LAMP_RELAY, RELAY_OFF); pinMode(LAMP_RELAY, OUTPUT);  // açılışta kapalı / off at boot
41  digitalWrite(FAN_RELAY, RELAY_OFF);  pinMode(FAN_RELAY, OUTPUT);
42  pinMode(PIR_PIN, INPUT);
43  pinMode(FLAME_PIN, INPUT);
44  pinMode(BUZZER_PIN, OUTPUT);
45  door.write(0);   door.attach(DOOR_PIN);        // önce açı, sonra attach / angle first, then attach
46  window.write(0); window.attach(WINDOW_PIN);
47  dht.begin();
48  SPI.begin();
49  rfid.PCD_Init();
50  lcd.init();
51  lcd.backlight();
52  lcd.print(F("BlueGrays Ev"));
53}
54
55void loop() {
56  unsigned long now = millis();
57  handleLight(now);
58  handleClimate(now);
59  handleSafety(now);
60  handleDoor(now);
61  bool beep = (long)(beepUntil - now) > 0;
62  digitalWrite(BUZZER_PIN, beep || (alarmOn && (now / 250) % 2));   // alarmda kesik bip / pulsed beep on alarm
63  updateLcd(now);
64}
65
66// 1) Hareketle ışık / motion light
67void handleLight(unsigned long now) {
68  if (now < WARMUP_MS) return;                   // PIR ısınıyor / PIR warming up
69  if (digitalRead(PIR_PIN) == HIGH) {
70    lastMotion = now;
71    if (analogRead(LDR_PIN) < DARK_LIMIT) lightOn = true;   // yalnız karanlıkta yak / only when dark
72  }
73  if (lightOn && now - lastMotion > LIGHT_MS) lightOn = false;
74  digitalWrite(LAMP_RELAY, lightOn ? RELAY_ON : RELAY_OFF);
75}
76
77// 2) Sıcaklık ve fan / temperature and fan
78void handleClimate(unsigned long now) {
79  if (now - lastDht < 2000) return;              // DHT11'i sık okuma / don't read DHT11 too often
80  lastDht = now;
81  float t = dht.readTemperature();
82  float h = dht.readHumidity();
83  if (isnan(t) || isnan(h)) return;              // okuma hatası / read error
84  tempC = t;
85  hum = h;
86  if (tempC >= FAN_ON) fanOn = true;
87  if (tempC <= FAN_OFF) fanOn = false;
88  digitalWrite(FAN_RELAY, fanOn ? RELAY_ON : RELAY_OFF);
89}
90
91// 3) Gaz ve yangın / gas and fire
92void handleSafety(unsigned long now) {
93  gas = analogRead(GAS_PIN);
94  bool gasAlarm = now > WARMUP_MS && gas > GAS_LIMIT;
95  bool fire = digitalRead(FLAME_PIN) == FLAME_ACTIVE;
96  alarmOn = gasAlarm || fire;
97  window.write(gasAlarm && !fire ? 90 : 0);      // gazda aç, yangında kapalı tut / open on gas, shut on fire
98}
99
100// 4) RFID kapı / RFID door
101void handleDoor(unsigned long now) {
102  if (doorOpen && now - doorAt > DOOR_MS) {
103    door.write(0);                               // süre dolunca kapat / close when time is up
104    doorOpen = false;
105  }
106  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) return;
107  Serial.print(F("UID:"));                       // yeni kartın UID'sini öğren / learn a new card's UID
108  for (byte i = 0; i < rfid.uid.size; i++) {
109    Serial.print(' ');
110    Serial.print(rfid.uid.uidByte[i], HEX);
111  }
112  Serial.println();
113  if (isAllowed(rfid.uid.uidByte)) {
114    door.write(90);
115    doorOpen = true;
116    doorAt = now;
117    beepUntil = now + 100;                       // kısa bip: hoş geldin / short beep: welcome
118  } else {
119    beepUntil = now + 800;                       // uzun bip: yetkisiz kart / long beep: unknown card
120  }
121  rfid.PICC_HaltA();
122}
123
124bool isAllowed(const byte *uid) {
125  for (byte i = 0; i < sizeof(CARDS) / 4; i++) {
126    if (memcmp(uid, CARDS[i], 4) == 0) return true;
127  }
128  return false;
129}
130
131// 5) Ekran / display
132void updateLcd(unsigned long now) {
133  if (now - lastLcd < 1000) return;
134  lastLcd = now;
135  lcd.setCursor(0, 0);
136  lcd.print(F("T:"));
137  lcd.print(tempC, 0);
138  lcd.print(F("C Nem:%"));
139  lcd.print(hum, 0);
140  lcd.print(F("   "));
141  lcd.setCursor(0, 1);
142  if (alarmOn) {
143    lcd.print(F("!! ALARM !!     "));
144  } else if (doorOpen) {
145    lcd.print(F("Hos geldin!     "));
146  } else {
147    lcd.print(F("Gaz:"));
148    lcd.print(gas);
149    lcd.print(F("        "));
150  }
151}

Une fois compilé, ce code occupe environ 38 % de la mémoire programme de l'Uno et 28 % de sa RAM ; il reste donc de la mémoire, mais seule la broche A3 est encore libre. Tu peux y brancher un bouton ou un capteur de pluie ; au-delà, il faudra passer à un Arduino Mega ou à un ESP32. Écrire les textes fixes dans F() est le moyen le plus simple de limiter l'utilisation de la RAM.

Pilotage par smartphone : serveur web sur ESP32

L'Uno n'a pas de Wi-Fi ; le plus simple pour piloter la maison depuis ton smartphone est de remplacer le cerveau par un ESP32. Le code ci-dessous connecte l'ESP32 au réseau de la maison et lance un petit serveur web. Avec ton téléphone sur le même réseau Wi-Fi, ouvre dans le navigateur l'adresse IP affichée dans le moniteur série : tu verras quatre grands boutons pour la lampe, le ventilateur, la porte et la fenêtre, ainsi que la température, l'humidité et la valeur de gaz actuelles ; la page se recharge toute seule toutes les 10 secondes. Chaque bouton envoie à l'ESP32 une courte requête indiquant l'appareil à commuter ; l'ESP32 change l'état puis te renvoie vers la page d'accueil. Pour les servos, installe la bibliothèque ESP32Servo depuis le gestionnaire de bibliothèques, car la bibliothèque Servo standard ne fonctionne pas sur l'ESP32.

1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4#include <DHT.h>
5
6const char* ssid = "AgAdi";                 // Wi-Fi adın / your Wi-Fi name
7const char* password = "Sifre123";          // Wi-Fi şifren / your Wi-Fi password
8
9const int LAMP_RELAY = 26, FAN_RELAY = 27;
10const int DOOR_PIN = 32, WINDOW_PIN = 33;
11const int DHT_PIN = 13, GAS_PIN = 34;       // GPIO 34: ADC1, bölücüyle / ADC1, through a divider
12const int RELAY_ON = LOW, RELAY_OFF = HIGH; // aktif LOW röle / active-LOW relay
13
14WebServer server(80);
15Servo door, window;
16DHT dht(DHT_PIN, DHT11);
17
18bool lamp = false, fan = false, doorOpen = false, windowOpen = false;
19float tempC = NAN, hum = NAN;
20unsigned long lastDht = 0;
21
22void apply() {                              // durumu donanıma uygula / push the state to the hardware
23  digitalWrite(LAMP_RELAY, lamp ? RELAY_ON : RELAY_OFF);
24  digitalWrite(FAN_RELAY, fan ? RELAY_ON : RELAY_OFF);
25  door.write(doorOpen ? 90 : 0);
26  window.write(windowOpen ? 90 : 0);
27}
28
29String button(const char* id, const char* label, bool on) {
30  return String("<a class='b ") + (on ? "on" : "off") + "' href='/set?d=" + id +
31         "&v=" + (on ? "0" : "1") + "'>" + label + (on ? ": ON" : ": OFF") + "</a>";
32}
33
34void handleRoot() {
35  String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>"
36                "<meta name='viewport' content='width=device-width,initial-scale=1'>"
37                "<meta http-equiv='refresh' content='10'><title>BlueGrays Ev</title>"
38                "<style>body{font-family:sans-serif;text-align:center}"
39                ".b{display:block;margin:12px auto;padding:18px;max-width:320px;border-radius:10px;"
40                "color:#fff;text-decoration:none;font-size:20px}"
41                ".on{background:#2e7d32}.off{background:#607d8b}</style></head><body>"
42                "<h2>BlueGrays Akıllı Ev</h2>";
43  html += "<p>" + String(tempC, 1) + " °C | %" + String(hum, 0) +
44          " | Gaz/Gas: " + String(analogRead(GAS_PIN)) + "</p>";
45  html += button("lamp", "Lamba / Lamp", lamp);
46  html += button("fan", "Fan", fan);
47  html += button("door", "Kapı / Door", doorOpen);
48  html += button("window", "Pencere / Window", windowOpen);
49  html += "</body></html>";
50  server.send(200, "text/html", html);
51}
52
53void handleSet() {                          // /set?d=lamp&v=1
54  String d = server.arg("d");
55  bool v = server.arg("v") == "1";
56  if (d == "lamp") lamp = v;
57  else if (d == "fan") fan = v;
58  else if (d == "door") doorOpen = v;
59  else if (d == "window") windowOpen = v;
60  apply();
61  server.sendHeader("Location", "/");       // ana sayfaya dön / back to the main page
62  server.send(303);
63}
64
65void setup() {
66  Serial.begin(115200);
67  door.attach(DOOR_PIN, 500, 2400);
68  window.attach(WINDOW_PIN, 500, 2400);
69  pinMode(LAMP_RELAY, OUTPUT);
70  pinMode(FAN_RELAY, OUTPUT);
71  apply();                                  // her şey kapalı başlar / everything starts off
72  dht.begin();
73  WiFi.begin(ssid, password);
74  while (WiFi.status() != WL_CONNECTED) {
75    delay(500);
76    Serial.print('.');
77  }
78  Serial.println();
79  Serial.println(WiFi.localIP());           // bu adresi telefonda aç / open this address on your phone
80  server.on("/", handleRoot);
81  server.on("/set", handleSet);
82  server.begin();
83}
84
85void loop() {
86  server.handleClient();
87  if (millis() - lastDht > 2000) {          // 2 sn'de bir ölç / measure every 2 s
88    lastDht = millis();
89    float t = dht.readTemperature();
90    float h = dht.readHumidity();
91    if (!isnan(t) && !isnan(h)) {
92      tempC = t;
93      hum = h;
94    }
95  }
96}

Ce code ne contient que les éléments pilotés à distance. Tu peux aussi y reprendre les fonctions handleLight(), handleSafety() et handleDoor() du programme de l'Uno : adapte les numéros de broches à la colonne ESP32 du tableau, utilise ESP32Servo à la place de Servo et mesure à nouveau les seuils GAS_LIMIT et DARK_LIMIT, car l'ADC de l'ESP32 renvoie des valeurs de 0 à 4095. La page n'a pas de mot de passe : n'importe qui sur ton réseau pourrait ouvrir la porte ; ajouter un mot de passe simple avec la fonction authenticate() de la bibliothèque WebServer est une bonne habitude. Pour un tableau de bord mis à jour en temps réel, consulte l'article sur l'ESP32 et WebSocket.

Pilotage à distance avec Blynk

Le serveur web de l'ESP32 n'est accessible que depuis le même réseau. Si tu veux aussi piloter la maison de l'extérieur avec les données mobiles, une plateforme cloud comme Blynk IoT te simplifie la vie : tu construis l'interface par glisser-déposer dans l'application, et l'ESP32 se connecte au serveur Blynk. Crée un modèle (template) dans Blynk.Cloud, ajoute trois datastreams nommés V0 (entier, 0–1, lampe), V1 (décimal, température) et V2 (décimal, humidité), crée un appareil et colle en haut du code les valeurs Template ID, Template Name et Auth Token fournies. Dans l'application, il suffit d'associer un Switch à V0 et une jauge (Gauge) à V1 et à V2. L'offre gratuite limite le nombre d'appareils, de datastreams et de messages par mois, c'est pourquoi on envoie les mesures toutes les cinq secondes plutôt que chaque seconde. La configuration complète est détaillée dans le guide Blynk IoT avec l'ESP32.

1#define BLYNK_TEMPLATE_ID "TMPLxxxxxxx"     // Blynk konsolundan kopyala / copy from the Blynk console
2#define BLYNK_TEMPLATE_NAME "Akilli Ev"
3#define BLYNK_AUTH_TOKEN "TokenBuraya"
4
5#include <WiFi.h>
6#include <BlynkSimpleEsp32.h>
7#include <DHT.h>
8
9const int LAMP_RELAY = 26;                  // aktif LOW röle / active-LOW relay
10DHT dht(13, DHT11);
11BlynkTimer timer;
12
13BLYNK_WRITE(V0) {                           // uygulamadaki anahtar / switch widget in the app
14  digitalWrite(LAMP_RELAY, param.asInt() ? LOW : HIGH);
15}
16
17BLYNK_CONNECTED() {
18  Blynk.syncVirtual(V0);                    // bağlanınca son durumu al / restore the last state
19}
20
21void sendSensors() {
22  float t = dht.readTemperature();
23  float h = dht.readHumidity();
24  if (isnan(t) || isnan(h)) return;
25  Blynk.virtualWrite(V1, t);                // sıcaklık / temperature
26  Blynk.virtualWrite(V2, h);                // nem / humidity
27}
28
29void setup() {
30  pinMode(LAMP_RELAY, OUTPUT);
31  digitalWrite(LAMP_RELAY, HIGH);           // açılışta kapalı / off at boot
32  dht.begin();
33  Blynk.begin(BLYNK_AUTH_TOKEN, "AgAdi", "Sifre123");
34  timer.setInterval(5000L, sendSensors);    // 5 sn'de bir: mesaj kotasını korur / every 5 s saves quota
35}
36
37void loop() {
38  Blynk.run();
39  timer.run();
40}

Quelle méthode de pilotage choisir ?

Pour une présentation scolaire, le serveur web sur ESP32 est le choix le plus sûr : il ne dépend ni d'internet ni d'un cloud et fonctionne avec son propre réseau même s'il n'y a pas de Wi-Fi dans la salle. Si tu veux rester sur l'Uno et simplement ajouter le Bluetooth, tu peux créer ta propre application Android avec App Inventor ; mais comme l'Uno n'a plus de broches libres, il faudra renoncer à l'écran ou au servo de la fenêtre pour faire de la place au HC-05. Recevoir un message sur ton téléphone quand l'alarme se déclenche est possible avec un bot Telegram sur ESP32, et relier la maison à de vrais appareils avec MQTT et Home Assistant.

Maison connectée avec le Raspberry Pi Pico

Tu peux aussi réaliser le même système en MicroPython avec un Raspberry Pi Pico, et le Pico W, équipé du Wi-Fi, se pilote depuis le smartphone comme l'ESP32 (voir le serveur web sur Pico W). Comme le Pico fonctionne en 3,3 V, les règles de l'ESP32 s'appliquent ici aussi : alimente le pont diviseur de la LDR en 3V3, abaisse les sorties analogiques 5 V avec un pont diviseur et choisis un module relais commandable en 3,3 V. Les seules entrées analogiques sont GP26, GP27 et GP28. Le code ci-dessous est la version MicroPython du module de lumière à détection de mouvement :

1from machine import Pin, ADC
2import time
3
4pir = Pin(15, Pin.IN)                  # PIR OUT (3,3 V çıkış / 3.3 V output)
5ldr = ADC(26)                          # GP26: bölücü 3V3'ten / divider fed from 3V3
6relay = Pin(14, Pin.OUT, value=1)      # aktif LOW röle, kapalı başla / active-LOW relay, start off
7
8LIGHT_MS = 20000                       # son hareketten sonra ışık / light after last motion
9DARK = 20000                           # bunun altı karanlık / below this is dark
10last = time.ticks_ms()
11on = False
12
13while True:
14    now = time.ticks_ms()
15    if pir.value():
16        last = now
17        if ldr.read_u16() < DARK:      # yalnız karanlıkta yak / only when dark
18            on = True
19    if on and time.ticks_diff(now, last) > LIGHT_MS:
20        on = False
21    relay.value(0 if on else 1)
22    time.sleep_ms(50)

Conseils pour ta présentation

• Commence par un problème : décris un vrai problème en une phrase, par exemple "des lumières allumées dans une maison vide, une fuite de gaz que personne ne remarque, des personnes âgées qui perdent leurs clés", puis montre comment ta maquette y répond.
• Prépare un schéma fonctionnel : les capteurs à gauche, l'Arduino au milieu et les actionneurs à droite ; légende les flèches avec les règles ("sombre + mouvement → lampe"). Le jury ne lira pas ton code, mais il se souviendra de ce schéma.
• Prévois une démo en direct : présente le badge et montre la porte qui s'ouvre, agite la main devant le PIR, approche du MQ-2 un coton imbibé d'alcool (l'alcool déclenche aussi le capteur) et réchauffe le DHT11 avec tes doigts. Chaque démonstration doit durer 10–20 secondes.
• Pas de flamme : n'allume ni briquet ni bougie dans une maquette en carton. La plupart des capteurs de flamme réagissent aussi à la lumière infrarouge d'une télécommande de télévision tenue de près ; teste-le avant et utilise cette astuce pendant la démo.
• Adapte les seuils à la salle : s'il fait 22 °C dans la salle le jour J, attendre 28 °C gâchera la démo du ventilateur ; règle FAN_ON 2–3 degrés au-dessus de la température ambiante pour que le ventilateur démarre quand tu réchauffes le capteur avec tes doigts.
• Mesure et donne des chiffres : par exemple, note pendant une journée combien de minutes la lampe reste allumée avec et sans PIR et exprime l'économie en pourcentage. Un résultat chiffré est bien plus convaincant que "ça marche".
• Prévois un plan B : filme le système en fonctionnement, emporte des câbles, un servo et une alimentation de rechange, et note sur un papier les numéros des badges et les réglages Wi-Fi.
• Prépare les questions du jury : pour "Comment ça marcherait dans une vraie maison ?", prépare des réponses courtes sur la sécurité du secteur, les détecteurs certifiés, la sécurité du RFID et le comportement de la porte en cas de coupure de courant.

Erreurs fréquentes et solutions

Un projet domotique Arduino réunit en un seul montage la lecture de capteurs, la prise de décision, la commande de moteurs et de relais, la gestion de l'alimentation et le pilotage sans fil ; c'est donc un excellent sujet, autant pour apprendre que pour présenter. Commence par un module, teste chaque étape et fais grandir le système petit à petit. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas et code, les projets d'éclairage intelligent d'escalier, d'éclairage intelligent avec PIR et LDR, d'alarme flamme et gaz, de serrure de porte RFID et de serveur web sur ESP32.