Arduino smart home-project: maquette, sensoren, code en app
Bouw stap voor stap een Arduino smart home-project: plattegrond van de maquette, PIR-verlichting, gas- en brandalarm, RFID-deur, relaislamp, bediening met ESP32 via je telefoon en alle code.
Een Arduino smart home-project maakt van de verlichting, deur, raam en alarmen van een maquettehuis een systeem dat op sensoren zelfstandig draait. Wil je, dan bedien je alles ook met je telefoon. Dit is niet voor niets een van de populairste schoolprojecten. Een gangverlichting die aangaat bij beweging, een alarm dat klinkt bij een gaslek, een ventilator die start als het warm wordt en een deur die opent met een pasje vormen samen een kleine maar werkende kopie van een echt smart home-systeem. Met een Arduino Uno of een ESP32, een stuk of tien modules en een weekend bouw jij er ook een.
In deze gids beginnen we met het plan van de maquette: welke module in welke ruimte komt, waar het budget naartoe gaat, hoe je de voeding plant en hoe je de pins toewijst. Daarna bouwen en testen we elke module apart en schrijven we de complete Arduino-sketch die ze allemaal tegelijk laat draaien zonder delay() te gebruiken. In de laatste delen leer je hoe je het huis met je telefoon bedient via een ESP32-webserver of Blynk, hoe je de meest voorkomende fouten oplost en hoe je indruk maakt op de jury bij je presentatie op school.






Hoe werkt een smart home-systeem?
Elk smart home draait op dezelfde lus van drie onderdelen. Sensoren meten de omgeving: beweegt er iemand, is het donker, hoe warm is het, is er gas of een vlam in de keuken, welke pas is voor de deur gehouden? De controller, dus de Arduino of ESP32, vergelijkt die informatie met regels: "als het donker is en er beweging is, doe het licht aan", "als de temperatuur boven 28 °C komt, start de ventilator". Actuatoren voeren het besluit uit: een relais schakelt de lamp en ventilator, een servo draait de deur en het raam, de buzzer klinkt en het display toont de status. Bediening met je telefoon voegt gewoon nog een ingang toe aan deze lus; nu neemt jouw tik het besluit in plaats van een regel.
| Ruimte / zone | Module | Wat het doet |
|---|---|---|
| Voordeur | RC522 RFID + SG90 servo | Opent de deur als een geautoriseerde pas wordt gescand en sluit hem 5 seconden later |
| Gang / woonkamer | HC-SR501 PIR + LDR + relais | Zet de lamp aan bij beweging in het donker en schakelt hem uit na 20 seconden zonder beweging |
| Keuken | MQ-2-gassensor + vlamsensor + buzzer | Laat een piepend alarm klinken zodra er gas of een vlam wordt gedetecteerd |
| Raam | SG90 servo | Opent het raam voor ventilatie als er gas wordt gedetecteerd |
| Slaapkamer | DHT11 + relais + ventilator | Start de ventilator bij 28 °C en stopt hem bij 26 °C |
| Technische ruimte | Arduino, I2C-LCD, voeding | Toont temperatuur, luchtvochtigheid, de gaswaarde en statusmeldingen |
De maquette plannen
Ontwerp de maquette rondom de elektronica; probeer de elektronica er niet achteraf in te proppen. Een basis van ongeveer 50×40 cm is genoeg voor twee of drie ruimtes en een entree. Voor de muren snijdt 5 mm foamboard of PVC-schuimplaat (zoals Forex) makkelijk met een hobbymes; 3–4 mm MDF is steviger maar vraagt een zaag of lasersnijder. Schaal 1:20 is een goed beginpunt: een plafond van 2,6 m wordt een muur van 13 cm en een deur van 90 cm wordt 4,5 cm breed. Maak het dak afneembaar of laat het helemaal weg; de jury wil in de kamers kunnen kijken.
- Technische ruimte of dubbele vloer: zet de Arduino, het breadboard, de relaismodule en de voedingsingang in een compartiment achter in het huis of onder een dubbele vloer van 3–4 cm hoog. Als je die afdekt met doorzichtig acryl, is de schakeling beschermd én zichtbaar.
- Kabelkanalen: boor onder elke sensor een gat van 6–8 mm en leid de kabels onder de basis naar de technische ruimte. Kies liever van begin af aan sensordraden die lang genoeg zijn dan korte draden aan elkaar te knopen.
- Deur: bevestig de deur met een klein scharnier of tape aan de muur en verbind de hoorn van de SG90 met een draadje dat je van een paperclip hebt gebogen. Lijm de RC522 aan de binnenkant van de buitenmuur; de lezer leest de pas meestal ook door 5 mm board heen.
- Keuken: in echte huizen komt een melder voor aardgas (methaan) vlak bij het plafond omdat het lichter is dan lucht, terwijl een melder voor LPG bij de vloer komt omdat LPG zwaarder is; voor een maquette is een plek bij het plafond prima. Richt de vlamsensor op het fornuis.
- Overige sensoren: zet de PIR in een hoek die het toegangspad van opzij ziet, de LDR op een buitenmuur of raam waar hij het licht van de lamp niet kan zien, en de DHT11 uit de buurt van de lamp en het warme lichaam van de MQ-2.
Onderdelenlijst en kosten
| Onderdeel | Aantal | Doel | Prijsniveau |
|---|---|---|---|
| Arduino Uno R3 (een kloon is prima) of ESP32 DevKit | 1 | De hersenen van het huis | Gemiddeld |
| Breadboard en set jumperdraden (male-male, male-female) | 1 set | Verbindingen | Laag |
| HC-SR501 PIR-bewegingssensor | 1 | Gangverlichting | Laag |
| LDR en weerstand van 10 kΩ | 1 + 1 | Donkerdetectie | Zeer laag |
| MQ-2-gassensormodule | 1 | Gas- en rookalarm | Laag |
| Vlamsensormodule (LM393) | 1 | Brandalarm | Laag |
| DHT11-module voor temperatuur en luchtvochtigheid | 1 | Ventilatorbesturing | Laag |
| RC522 RFID-module (met pas en sleutelhanger) | 1 | Deur met pasjesbediening | Laag |
| SG90 servo motor | 2 | Deur en raam | Laag |
| 2-kanaals 5V-relaismodule | 1 | Lamp en ventilator | Laag |
| Actieve buzzer | 1 | Alarmgeluid | Zeer laag |
| I2C 16x2 LCD-display | 1 | Statusdisplay | Laag – gemiddeld |
| 5V-miniventilator en 5V-ledlamp of LED-strip | 1 + 1 | Belastingen voor de relais | Laag |
| 5V 2–3 A-adapter en DC-jack of schroefklem | 1 | Voeding voor servo's, relais en sensoren | Gemiddeld |
| Foamboard of PVC-schuimplaat, hobbymes, hotglue | – | Behuizing van het huis | Gemiddeld |
Prijzen veranderen vaak per verkoper en in de loop van de tijd, dus we noemen geen bedragen; de tabel laat zien hoe zwaar elk onderdeel in het budget weegt. De sensoren en modules zijn stuk voor stuk goedkoop; het grootste deel van het budget gaat naar het board, de LCD, de voedingsadapter en de maquettematerialen. Als je een Arduino-starterkit hebt, zijn het board, het breadboard, de draden, de LDR, de buzzer en vaak een servo en een LCD al gedekt. Met een krap budget kun je de LCD en de tweede servo weglaten: gebruik de Serial Monitor in plaats van een display en bewaar het raam voor een latere fase. Een nauwkeurigere DHT22 in plaats van de DHT11 kost iets meer, maar maakt je metingen tijdens de presentatie overtuigender.
Voedingsplan: waarom een aparte 5V-adapter?
Bij smart home-maquettes komen bijna alle klachten als "hij reset af en toe", "de servo trilt" of "er verschijnen rare tekens op de LCD" neer op de voeding. De USB-poort van een computer levert ongeveer 500 mA, en als het board op USB draait, zit ook de 5V-pin van de Uno achter die limiet. Tel de onderstaande waarden op en je ziet dat de totale stroom makkelijk boven 1 A komt als beide servo's tegelijk bewegen.
| Onderdeel | Ongeveer stroomverbruik bij 5 V |
|---|---|
| Arduino Uno | 45–50 mA |
| MQ-2 (verwarmingselement altijd aan) | Ongeveer 150 mA |
| Relaismodule (per kanaal, relais bekrachtigd) | 70–80 mA |
| SG90-servo (in beweging / onder belasting) | 100–250 mA / tot 0,5–0,7 A |
| I2C-LCD (achtergrondverlichting aan) | 20–30 mA |
| RC522 (vanaf de 3,3V-pin) | 13–26 mA |
| Actieve buzzer, DHT11, PIR en vlamsensor | Samen 30–40 mA |
| 5V-miniventilator en ledlamp | 100–400 mA afhankelijk van het model |
Pinplan: Arduino Uno en ESP32
Met zoveel modules zijn de pins van de Uno bijna op, dus je moet ze vanaf het begin plannen. De RC522 gebruikt hardware-SPI, dus de lijnen MOSI, MISO en SCK liggen vast op D11, D12 en D13. De LCD gebruikt via I2C alleen A4 en A5, daarom kozen we een display met I2C-module in plaats van een parallelle LCD. Analoge pins werken zo nodig ook als digitale pins, zo kunnen we de raamservo op A2 aansluiten. Laat D0 en D1 vrij: die seriële lijn wordt gebruikt als je code uploadt en als je pasnummers leest in de Serial Monitor. De pinindeling van je board zie je in de tool Pinout.
| Modulepin | Arduino Uno | ESP32 |
|---|---|---|
| PIR OUT | D2 | GPIO 16 |
| Vlamsensor DO | D3 | GPIO 17 |
| DHT11 DATA | D4 | GPIO 13 |
| Actieve buzzer (+) | D5 | GPIO 25 |
| Deurservo (signaal) | D6 | GPIO 32 |
| Relais IN1 (lamp) | D7 | GPIO 26 |
| Relais IN2 (ventilator) | D8 | GPIO 27 |
| RC522 RST | D9 | GPIO 4 |
| RC522 SDA (SS) | D10 | GPIO 5 |
| RC522 MOSI / MISO / SCK | D11 / D12 / D13 | GPIO 23 / 19 / 18 |
| MQ-2 AO | A0 | GPIO 34 (via een spanningsdeler) |
| Middelpunt van de LDR-deler | A1 | GPIO 35 (deler gevoed vanaf 3V3) |
| Raamservo (signaal) | A2 | GPIO 33 |
| I2C LCD SDA / SCL | A4 / A5 | GPIO 21 / 22 |
Stap voor stap in elkaar zetten
- Bouw de behuizing van de maquette en bereid de plekken voor de modules en de kabelgaten voor; monteer de elektronica als laatste.
- Leg de voedingslijn aan: verbind de 5V-adapter met de voedingsrails van het breadboard, verbind de GND van de adapter met de GND van de Arduino en controleer de 5 V met een multimeter.
- Sluit de I2C-LCD aan en print er wat tekst op. Als je het adres van het display niet kunt vinden, gebruik dan de scannersketch uit het artikel I2C-LCD.
- Voeg de sensoren één voor één toe: DHT11, LDR, PIR, MQ-2 en vlamsensor. Probeer ze elk met een korte testsketch in de Serial Monitor en noteer de waarden in schone lucht, in het donker en in het licht.
- Voeg de actuatoren toe: test eerst de relais zonder belasting door op hun klik en led te letten, dan de servo's op externe voeding, en sluit als laatste de RC522 aan. Scan je passen en noteer hun nummers.
- Upload de hoofdsketch en stel de drempels GAS_LIMIT, DARK_LIMIT en FAN_ON in op basis van je notities.
- Zet de draden vast met hotglue en labels, laat het systeem dan een half uur aan staan en let op resets, oververhitting of valse alarmen.
Automatisch licht met een PIR en een LDR
De HC-SR501 PIR-sensor detecteert veranderingen in de infraroodstraling van het menselijk lichaam en zet zijn uitgang HIGH als hij beweging ziet. Met alleen een PIR zou de lamp ook overdag aangaan, dus onze regel heeft twee voorwaarden: zet hem aan als er beweging is en het donker is. De LDR is als spanningsdeler aangesloten met een weerstand van 10 kΩ (5V → LDR → A1 → 10 kΩ → GND) en de waarde op A1 daalt naarmate het donkerder wordt. De code bewaart het tijdstip van de laatste beweging en schakelt de lamp uit na 20 seconden zonder nieuwe beweging; zolang iemand rondloopt, start de timer telkens opnieuw. Zet de jumper van de sensor op H (repeat trigger) en de Tx-potmeter op de kortste tijd, en laat de code de timing bepalen. Meer details staan in de artikelen PIR-bewegingssensor en LDR-lichtsensor.
Gas- en brandalarm
In de MQ-2 zit een laag tinoxide die door een verwarmingselement heet wordt gehouden; LPG, methaan, butaan, waterstof, alcohol en rook veranderen de weerstand van die laag. De AO-pin van de module geeft een spanning die stijgt naarmate de gasconcentratie toeneemt. De sensor moet elke keer na het inschakelen opwarmen, daarom negeert de code gasalarmen in de eerste 60 seconden. De vlamsensor detecteert het infrarode licht van 760–1100 nm dat een vuur afgeeft; bij de meeste modules gaat de DO-uitgang LOW en gaat er een tweede led op de print branden als er een vlam wordt gezien, maar test je eigen module altijd met een aansteker op afstand. Bij gasdetectie klinkt het alarm en gaat het raam open voor ventilatie; bij een vlam blijft het raam dicht, want frisse lucht voedt een vuur. Het instellen van de drempel en de andere MQ-sensoren komen aan bod in het artikel MQ-2-gassensor.
Temperatuur, luchtvochtigheid en een automatische ventilator
De DHT11 meet temperatuur van 0 tot 50 °C met een nauwkeurigheid van ±2 °C en luchtvochtigheid van 20 tot 90% met een nauwkeurigheid van ±5%, en kan hooguit eens per seconde worden uitgelezen; de code leest hem om de twee seconden. In plaats van één drempel voor de ventilator gebruiken we hysterese: de ventilator start bij 28 °C maar stopt pas als de temperatuur zakt tot 26 °C. Met één drempel zou het relais blijven klikken als de temperatuur tussen 27 en 28 °C schommelt, wat zowel het relais als de ventilator slijt. Als de sensor een meting mist en "nan" teruggeeft, slaat de code die meting over en houdt hij de laatste geldige waarde aan. Voor nauwkeurigere metingen werkt de DHT22 met dezelfde code; schrijf alleen DHT22 in plaats van DHT11. Meer details staan in het artikel DHT11-sensor voor temperatuur en luchtvochtigheid.
Deur met RFID-pas en een servo
De RC522 leest MIFARE-passen en -sleutelhangers van 13,56 MHz op 3–5 cm afstand. Elke pas heeft een eigen identificatienummer (UID) en de code vergelijkt de gelezen UID met een lijst van geautoriseerde passen. Bij een match zwaait de servo de deur open tot 90 graden, hoor je een korte piep en toont de LCD "Hos geldin!" (Turks voor "Welkom!"); 5 seconden later sluit de deur vanzelf. Een onbekende pas krijgt een lange piep. Om de UID's van je eigen passen te vinden, upload je de code, open je de Serial Monitor op 9600 baud en scan je een pas: je ziet een regel als "UID: A1 B2 C3 D4". Schrijf deze bytes in de lijst CARDS in de vorm 0xA1, en zet een nul voor elke byte die met één cijfer wordt getoond (0x05 in plaats van 5). Een slot dat alleen de UID controleert is prima om mee te leren maar biedt geen echte beveiliging; waarom, leggen we uit in het artikel RFID RC522.
Raam en gordijn
Voor het raam is een tweede SG90 genoeg: verbind een klein acryl raam op scharnieren met een draadje aan de servohoorn, waarbij 0 graden dicht en 90 graden open is. Door write(0) aan te roepen vóór attach() voorkom je dat de servo bij het opstarten naar 90 graden springt en het raam dichtslaat. Een gordijn heeft meer slag nodig: je windt de stof op een dun staafje en draait dat staafje. Een 28BYJ-48-stappenmotor met een ULN2003-driver is hiervoor stil en nauwkeurig, maar heeft 4 pins nodig; omdat de Uno er geen meer over heeft, is het verstandig het gordijn te bewaren voor de ESP32-versie of een Arduino Mega. Moet het met één pin, dan werkt ook een FS90R-servo met continue rotatie, maar omdat die zijn positie niet kent, open en sluit je het gordijn op tijd. Een regensensor toevoegen om het raam automatisch te sluiten als het regent is ook een leuke uitbreiding.
Lamp en ventilator met een relais

Een Arduino-pin kan veilig maar ongeveer 20 mA leveren (de absolute limiet is 40 mA), terwijl een ventilator of lamp veel meer nodig heeft. Daarom zit er een relaismodule tussen: het signaal op de IN-pin bekrachtigt een elektromagneet die contacten sluit in een apart circuit. Sluit de belasting aan op de klemmen COM en NO, zodat de lamp uit blijft zolang de Arduino uit staat of herstart. De meeste van deze modules zijn active LOW, wat betekent dat het relais inschakelt als je LOW schrijft; daar dienen de constanten RELAY_ON en RELAY_OFF in de code voor. In setup() schrijft de code HIGH voordat de pin een uitgang wordt, zodat het relais bij het opstarten van de Arduino zelfs niet heel even klikt. We gebruikten hysterese zodat de ventilator niet te vaak aan- en uitgaat, terwijl de lamp aan blijft tot de PIR-timer afloopt.
De complete sketch (Arduino Uno)
De belangrijkste regel in smart home-code is dat geen enkele module op een andere wacht. Als je de deur met delay(5000) 5 seconden open zou houden, werkte het gasalarm niet en werd de PIR in die tijd niet gelezen. Daarom zetten we elke module in een eigen functie en roept loop() die functies honderden keren per seconde na elkaar aan. Alles wat met tijd te maken heeft, meten we met millis(), en de toestand van elke module bewaren we in variabelen als lightOn, fanOn, doorOpen en alarmOn. Alle instellingen staan als constanten bovenaan de code, zodat je niet door de code hoeft te zoeken om een drempel te wijzigen. De logica achter deze aanpak vind je in het artikel millis() vs delay(). Om de code te compileren installeer je via de Library Manager de bibliotheek MFRC522, Adafruits DHT sensor library en LiquidCrystal I2C van Frank de Brabander, en installeer je alle afhankelijkheden als daarom wordt gevraagd. Servo, SPI en Wire worden met de Arduino IDE meegeleverd.
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}| Functie | Taak | Hoe vaak? |
|---|---|---|
| handleLight() | Schakelt het lamprelais in op basis van de PIR en LDR, en uit na 20 seconden zonder beweging | Elke lus (behalve de eerste 60 seconden) |
| handleClimate() | Leest de DHT11 en stuurt de ventilator aan met hysterese 28/26 °C | Elke 2 seconden |
| handleSafety() | Leest de MQ-2 en de vlamsensor en beheert het alarm en het raam | Elke lus |
| handleDoor() | Leest de pas, print de UID naar de Serial Monitor, opent en sluit de deur | Elke lus |
| updateLcd() | Toont temperatuur, luchtvochtigheid, de gaswaarde of een statusmelding | Eén keer per seconde |
| Buzzerregel in loop() | Maakt de pas-piep en het pulserende alarmgeluid | Elke lus |
Gecompileerd gebruikt deze code ongeveer 38% van het programmageheugen en 28% van het RAM van de Uno, dus er is nog ruimte in het geheugen, maar van de pins blijft alleen A3 vrij. Op A3 kun je een knop of een regensensor aansluiten; voor meer moet je overstappen op een Arduino Mega of een ESP32. Vaste tekst in F() zetten is de makkelijkste manier om het RAM-gebruik laag te houden.
Bediening met je telefoon: ESP32-webserver

De Uno heeft geen Wi-Fi; de makkelijkste manier om het smart home met je telefoon te bedienen is de hersenen te vervangen door een ESP32. De onderstaande code verbindt de ESP32 met je thuisnetwerk en start een kleine webserver. Als je telefoon op hetzelfde wifinetwerk zit, open je in de browser het IP-adres dat de Serial Monitor toont en zie je vier grote knoppen voor lamp, ventilator, deur en raam, plus de actuele temperatuur, luchtvochtigheid en gaswaarde; de pagina ververst zichzelf elke 10 seconden. Elke knop stuurt de ESP32 een kort verzoek met welk apparaat moet schakelen; de ESP32 wijzigt de status en stuurt je terug naar de hoofdpagina. Installeer voor de servo's de bibliotheek ESP32Servo via de Library Manager, want de standaardbibliotheek Servo werkt niet op de 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}Deze code bevat alleen de onderdelen die je op afstand bedient. Je kunt ook de functies handleLight(), handleSafety() en handleDoor() uit de Uno-sketch hierheen verplaatsen: pas de pinnummers aan volgens de ESP32-kolom in de tabel, gebruik ESP32Servo in plaats van Servo en meet de drempels GAS_LIMIT en DARK_LIMIT opnieuw, want de ADC van de ESP32 geeft waarden van 0 tot 4095. De pagina heeft geen wachtwoord, dus iedereen op je thuisnetwerk zou de deur kunnen openen; een eenvoudig wachtwoord toevoegen met de functie authenticate() van de bibliotheek WebServer is een goede gewoonte. Voor een paneel dat in realtime bijwerkt, zie het artikel ESP32 WebSocket.
Overal bedienen met Blynk
De ESP32-webserver bereik je alleen vanaf hetzelfde netwerk. Wil je ook van buiten het huis bedienen via mobiele data, dan maakt een cloudplatform als Blynk IoT het makkelijk: je bouwt de interface met slepen en neerzetten in de app op je telefoon en de ESP32 maakt verbinding met de Blynk-server. Maak in Blynk.Cloud een sjabloon aan, voeg drie datastreams toe met de namen V0 (integer, 0–1, lamp), V1 (double, temperatuur) en V2 (double, luchtvochtigheid), voeg een apparaat toe en plak de Template ID, Template Name en Auth Token die je krijgt bovenaan de code. Koppel in de app gewoon een Switch aan V0 en een Gauge aan elk van V1 en V2. Het gratis abonnement beperkt het aantal apparaten, datastreams en berichten per maand, daarom sturen we de sensordata elke vijf seconden in plaats van elke seconde. De volledige installatie staat in de gids Blynk IoT met 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}Welke bedieningsmethode kies je?
| Methode | Wat je nodig hebt | Van buiten het huis | Moeilijkheid | Het best voor |
|---|---|---|---|---|
| ESP32-webserver | ESP32 en wifi thuis | Nee, alleen op hetzelfde netwerk | Gemiddeld | Schoolpresentaties, demo's zonder internet, helemaal je eigen code |
| Blynk IoT | ESP32, internet en een Blynk-account | Ja | Makkelijk | Kant-en-klare interface, grafieken en meldingen |
| Bluetooth (HC-05) | Uno, HC-05 en een Android-app | Nee, ongeveer 10 m | Makkelijk | Bij de Uno blijven (werkt niet met iPhone) |
| Telegram-bot | ESP32 en internet | Ja | Gemiddeld | Alarmmeldingen en korte commando's |
| MQTT + Home Assistant | ESP32 en een lokale server (bijv. Raspberry Pi) | Ja, moet worden ingesteld | Gevorderd | Echte domotica |
Voor een schoolpresentatie is de ESP32-webserver de veiligste keuze: hij hangt niet af van internet of een cloud en werkt op zijn eigen netwerk, ook als er in de zaal geen wifi is. Wil je bij de Uno blijven en alleen Bluetooth toevoegen, dan kun je met App Inventor je eigen Android-app maken; maar omdat de Uno geen pins meer over heeft, moet je de LCD of de raamservo opgeven om ruimte te maken voor de HC-05. Met een ESP32 Telegram-bot krijg je een bericht op je telefoon als het alarm afgaat, en met MQTT en Home Assistant koppel je het huis aan echte apparaten.
Smart home met de Raspberry Pi Pico
Je kunt hetzelfde systeem ook in MicroPython bouwen met een Raspberry Pi Pico, en de Pico W met Wi-Fi kun je net als de ESP32 met je telefoon bedienen (zie de Pico W-webserver). Omdat de Pico op 3,3 V draait, gelden de ESP32-regels ook hier: voed de LDR-deler vanaf 3V3, breng analoge uitgangen van 5 V omlaag met een spanningsdeler en kies een relaismodule die op 3,3 V kan worden geschakeld. De enige analoge ingangen zijn GP26, GP27 en GP28. De onderstaande code is de MicroPython-versie van de module voor bewegingsverlichting:
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)Tips voor je schoolpresentatie
- Begin met een probleem: beschrijf in één zin een echt probleem, zoals "licht dat aan blijft in een leeg huis, een gaslek dat niemand opmerkt, ouderen die hun sleutels kwijtraken", en laat dan zien hoe je maquette daar een antwoord op geeft.
- Maak een blokschema: sensoren links, de Arduino in het midden en actuatoren rechts; zet bij de pijlen de regels ("donker + beweging → lamp"). De jury leest je code niet, maar dit schema onthouden ze wel.
- Schrijf een script voor een live demo: scan de pas en laat de deur openen, zwaai met je hand voor de PIR, houd een wattenschijfje met isopropylalcohol bij de MQ-2 (alcohol activeert de sensor ook) en verwarm de DHT11 met je vingers. Houd elke demo op 10–20 seconden.
- Geen open vuur: steek geen aansteker of kaars aan in een kartonnen maquette. De meeste vlamsensoren reageren ook op het infrarode licht van een afstandsbediening die je dichtbij houdt; test dat vooraf en gebruik het in de demo.
- Pas de drempels aan op de ruimte: als het op de dag zelf 22 °C is in de zaal, verpest wachten op 28 °C de ventilatordemo; stel FAN_ON 2–3 graden boven de kamertemperatuur in, zodat de ventilator start als je de sensor met je vingers verwarmt.
- Meet en gebruik cijfers: log bijvoorbeeld hoeveel minuten de lamp op een dag aan is met en zonder de PIR en geef de besparing als percentage. Een resultaat met cijfers is veel sterker dan zeggen "het werkt".
- Heb een reserveplan: neem een video op van het werkende systeem, neem reservedraden, een servo en een adapter mee en schrijf de pasnummers en wifi-instellingen op een papiertje.
- Bereid je voor op de vragen van de jury: houd voor "Hoe zou het in een echt huis werken?" korte antwoorden klaar over netspanningsveiligheid, gecertificeerde melders, RFID-beveiliging en wat de deur doet bij een stroomstoring.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| De Arduino reset of de LCD gaat raar doen als een servo beweegt | Servo's en relais worden gevoed via de 5V-pin van de Arduino | Aparte 5V 2–3 A-adapter, gemeenschappelijke GND, condensator van 470–1000 µF op de servovoeding |
| Het relais werkt andersom en staat aan bij het opstarten | De module is active LOW | Wissel de waarden RELAY_ON en RELAY_OFF om |
| Het alarm gaat elke keer af bij het inschakelen | De MQ-2 warmt op en de PIR leert zijn omgeving kennen | Houd de vertraging WARMUP_MS aan; laat de MQ-2 vóór het eerste gebruik lang aan staan |
| De lamp gaat overdag aan of schakelt uit en direct weer in | DARK_LIMIT is verkeerd of de LDR ziet het licht van de lamp | Stel de drempel in aan de hand van de waarden in de Serial Monitor en verplaats de LDR naar een buitenmuur |
| Passen worden niet gelezen | De bedrading van de RC522 klopt niet of de module zit op 5 V | Controleer de SPI-pins en test de module met het voorbeeld DumpInfo |
| De DHT11 geeft nan terug | De DATA-draad zit op de verkeerde pin of een kale sensor heeft geen pull-upweerstand | Controleer de pin, gebruik een module of voeg 10 kΩ toe tussen DATA en VCC |
| De servo trilt af en toe | Zwakke voeding; interrupts pauzeren kort tijdens het lezen van de DHT11 | Verbeter de voeding; gebruik zo nodig detach() op de servo als hij klaar is met bewegen |
| Op de ESP32 is de gaswaarde altijd 0 of 4095 | Een ADC2-pin botst met Wi-Fi of er is geen spanningsdeler | Gebruik een ADC1-pin zoals GPIO 34 of 35 en een spanningsdeler |
| De telefoon opent de pagina van de ESP32 niet | De telefoon zit op een gastnetwerk of mobiele data, of het netwerk is 5 GHz | Maak verbinding met hetzelfde 2,4 GHz-netwerk en haal het IP-adres uit de Serial Monitor |
Een Arduino smart home-project brengt sensoren uitlezen, beslissingen nemen, motoren en relais aansturen, voeding plannen en draadloze bediening samen in één bouwwerk, waardoor het een geweldig onderwerp is om van te leren én te presenteren. Begin met één module, test elke stap en laat het systeem stukje bij beetje groeien. In de BlueGrays-app vind je de projecten slimme trapverlichting, slimme verlichting met PIR en LDR, vlam- en gasalarm, RFID-deurslot en ESP32-webserver stap voor stap, met schakelschema's en code.
Veelgestelde vragen
Wat heb ik nodig om een Arduino smart home-project te bouwen?
Voor een basismaquette zijn een Arduino Uno of ESP32, een PIR-bewegingssensor, een LDR, een MQ-2-gassensor, een vlamsensor, een DHT11, een RC522 RFID-module, twee SG90-servo's, een 2-kanaals relaismodule, een buzzer en een I2C-LCD genoeg. Voeg daar een breadboard, jumperdraden, een 5V 2–3 A-voedingsadapter en maquettemateriaal aan toe. De meeste modules zijn goedkoop; het board, het display, de adapter en de maquette zelf vormen het grootste deel van het budget.
Is Arduino of ESP32 beter voor een smart home-project?
Als je geen bediening met je telefoon nodig hebt, is de Arduino Uno makkelijker: hij werkt direct met 5V-modules en de meeste voorbeelden zijn ervoor geschreven. Kies de ESP32 als je Wi-Fi-bediening vanaf je telefoon, meldingen of meer pins nodig hebt, maar omdat zijn pins op 3,3 V werken, moet je extra opletten bij relaismodules en analoge 5V-sensoren.
Hoe bedien ik een Arduino smart home met mijn telefoon?
De makkelijkste manier is een ESP32 gebruiken en een webserver opzetten; dan bedien je de lamp, ventilator en deur met knoppen in de browser van een telefoon op hetzelfde wifinetwerk. Voor toegang van buiten het huis kun je een cloud-app als Blynk IoT gebruiken, of, als je bij de Arduino Uno wilt blijven, een HC-05 Bluetooth-module en een Android-app.
Wat is het beste materiaal voor een smart home-maquette?
Het praktischste materiaal is 5 mm foamboard of PVC-schuimplaat; het snijdt met een hobbymes en plakt met hotglue. Voor een steviger behuizing kun je 3–4 mm MDF gebruiken. Een basis van ongeveer 50×40 cm, een afneembaar dak en een apart technisch compartiment voor de elektronica maken het werk een stuk makkelijker.
Kan een Arduino een lamp op netspanning aan- en uitzetten?
Ja, met een 5V-relaismodule, die het net elektrisch gescheiden houdt van de Arduino. Maar netspanning kan dodelijk zijn: maak verbindingen alleen met de stekker uit het stopcontact, zet de schakeling in een gesloten, geïsoleerde kast en werk er in een leerlingenproject nooit aan zonder toezicht van een volwassene. Voor een maquette heb je genoeg aan lampen van 5 V of 12 V.
Is een Arduino smart home een goed project voor een wetenschapsbeurs?
Smart homes zijn een heel gangbaar onderwerp, dus een werkende maquette alleen is vaak niet genoeg. Als je het project koppelt aan een meetbare onderzoeksvraag, bijvoorbeeld hoeveel energie verlichting met bewegingsdetectie bespaart of hoe snel het gasalarm reageert, wordt het in de ogen van de jury veel sterker.
Projecten om hierna te bouwen
Alle projecten bekijken
Temperatuur en luchtvochtigheid met DHT11
Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

Slimme trap- en gangverlichting
Stap op de trap of in de gang en de lampjes gaan trede voor trede aan, in de richting waarin je loopt.

ESP32 slimme verlichting (PIR + LDR + relais + OLED)
Met een ESP32, een PIR-bewegingssensor, een LDR-lichtsensor en een relaismodule maak je van je gang, toilet of bijkeuken slimme verlichting. Is het al licht in de ruimte, dan blijft het licht uit, ook bij beweging, zodat overdag geen energie wordt verspild. Het licht blijft 30 seconden aan en de tijd verlengt automatisch zolang er beweging is.

Deurbel en licht met bewegingssensor
Als iemand naar je deur loopt, weet je het al voordat er wordt aangebeld. Zodra de bewegingssensor iemand opmerkt, gaat de led branden en speelt de buzzer een beltoon van drie noten van hoog naar…

Alarm met vlam- en gassensor
Een kleine bewaker die je meteen waarschuwt als er gas lekt of ergens een vlam verschijnt.

ESP32 RFID-deurslot (RC522 + servo + OLED + buzzer + LED)
We bouwen een slim deurslot met een ESP32, een RC522 RFID-module, een SG90-servo, een SSD1306 OLED-display, een actieve buzzer en 2 leds. Bij het scannen van een kaart wordt de UID vergeleken met de geautoriseerde kaarten in de code; bij een match ontgrendelt de servo (groene led + 2 korte piepjes) en vergrendelt na 5 seconden weer. Een onbekende kaart laat de rode led branden, geeft 3 snelle piepjes en toont de UID op de OLED.

230V-lamp laten branden met een afstandsbediening
Zet een echte lamp in huis aan en uit met een tv-afstandsbediening, zonder van de bank te komen.

ESP32 asynchrone webserver (met IP-weergave op lcd)
In dit project maken we van de ESP32 een asynchrone webserver die je met je telefoon of computer op hetzelfde wifinetwerk kunt bedienen. Dankzij de ESPAsyncWebServer-bibliotheek kan de server meerdere verzoeken tegelijk verwerken (anders dan de klassieke WebServer.h, die bij één verzoek blokkeert). Je opent het IP-adres van de ESP32 in een browser en klikt op de knoppen ON/OFF (de routes /on en /off) om de led op GPIO 5 aan en uit te zetten.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

