Gidsen · 20 min leestijd

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.

HC-SR501 PIR
HC-SR501 PIR
MQ-2
MQ-2
DHT11
DHT11
RC522 RFID
RC522 RFID
SG90
SG90
I2C LCD 16x2
I2C LCD 16x2

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 / zoneModuleWat het doet
VoordeurRC522 RFID + SG90 servoOpent de deur als een geautoriseerde pas wordt gescand en sluit hem 5 seconden later
Gang / woonkamerHC-SR501 PIR + LDR + relaisZet de lamp aan bij beweging in het donker en schakelt hem uit na 20 seconden zonder beweging
KeukenMQ-2-gassensor + vlamsensor + buzzerLaat een piepend alarm klinken zodra er gas of een vlam wordt gedetecteerd
RaamSG90 servoOpent het raam voor ventilatie als er gas wordt gedetecteerd
SlaapkamerDHT11 + relais + ventilatorStart de ventilator bij 28 °C en stopt hem bij 26 °C
Technische ruimteArduino, I2C-LCD, voedingToont 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.
Teken voordat je iets koopt een plattegrond van bovenaf van de maquette en markeer waar elke module komt en welke route de kabel naar de technische ruimte neemt. Bij projecten als dit kost de bedradingsindeling meer tijd dan de code of het solderen; een goed plan halveert die tijd.

Onderdelenlijst en kosten

OnderdeelAantalDoelPrijsniveau
Arduino Uno R3 (een kloon is prima) of ESP32 DevKit1De hersenen van het huisGemiddeld
Breadboard en set jumperdraden (male-male, male-female)1 setVerbindingenLaag
HC-SR501 PIR-bewegingssensor1GangverlichtingLaag
LDR en weerstand van 10 kΩ1 + 1DonkerdetectieZeer laag
MQ-2-gassensormodule1Gas- en rookalarmLaag
Vlamsensormodule (LM393)1BrandalarmLaag
DHT11-module voor temperatuur en luchtvochtigheid1VentilatorbesturingLaag
RC522 RFID-module (met pas en sleutelhanger)1Deur met pasjesbedieningLaag
SG90 servo motor2Deur en raamLaag
2-kanaals 5V-relaismodule1Lamp en ventilatorLaag
Actieve buzzer1AlarmgeluidZeer laag
I2C 16x2 LCD-display1StatusdisplayLaag – gemiddeld
5V-miniventilator en 5V-ledlamp of LED-strip1 + 1Belastingen voor de relaisLaag
5V 2–3 A-adapter en DC-jack of schroefklem1Voeding voor servo's, relais en sensorenGemiddeld
Foamboard of PVC-schuimplaat, hobbymes, hotglue–Behuizing van het huisGemiddeld

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.

OnderdeelOngeveer stroomverbruik bij 5 V
Arduino Uno45–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 vlamsensorSamen 30–40 mA
5V-miniventilator en ledlamp100–400 mA afhankelijk van het model
Voed de servo's, de relaismodule, de MQ-2 of de relaisbelastingen niet via de 5V-pin van de Arduino. Voed ze met een aparte 5 V-adapter van 2–3 A en verbind de GND van de adapter altijd met de GND van de Arduino (gemeenschappelijke massa). De Arduino zelf kun je apart voeden: via USB tijdens het ontwikkelen en later via de DC-jack met een eigen adapter van 7–12 V. Steek de 5 V-adapter niet in de jack, want die heeft minimaal 7 V nodig. Een elco van 470–1000 µF op de voeding van de servo's vlakt de korte spanningsdip af wanneer een servo begint te bewegen. Meer details vind je in de gids Arduino-voeding.

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.

ModulepinArduino UnoESP32
PIR OUTD2GPIO 16
Vlamsensor DOD3GPIO 17
DHT11 DATAD4GPIO 13
Actieve buzzer (+)D5GPIO 25
Deurservo (signaal)D6GPIO 32
Relais IN1 (lamp)D7GPIO 26
Relais IN2 (ventilator)D8GPIO 27
RC522 RSTD9GPIO 4
RC522 SDA (SS)D10GPIO 5
RC522 MOSI / MISO / SCKD11 / D12 / D13GPIO 23 / 19 / 18
MQ-2 AOA0GPIO 34 (via een spanningsdeler)
Middelpunt van de LDR-delerA1GPIO 35 (deler gevoed vanaf 3V3)
Raamservo (signaal)A2GPIO 33
I2C LCD SDA / SCLA4 / A5GPIO 21 / 22
Voed de RC522 op beide boards via de 3,3V-pin; 5 V kan de module beschadigen. Op de ESP32 gelden nog twee regels: ADC2-pins kunnen geen analoge waarden lezen terwijl Wi-Fi aan staat, daarom hebben we de MQ-2 en de LDR op ADC1-pins (GPIO 32–39) aangesloten. De analoge uitgang van een MQ-2 die op 5 V draait, kan ook boven 3,3 V komen; voeg een spanningsdeler toe, bijvoorbeeld 10 kΩ boven en 15 kΩ onder (5 V × 15 / 25 = 3,0 V). Voed om dezelfde reden de vlamsensor en de DHT11 op de ESP32 vanaf 3V3; beide werken op 3,3 V, dus hun digitale uitgangen blijven binnen 3,3 V. De uitgang van de HC-SR501 is al 3,3 V, ook als hij op 5 V draait. In de ESP32-kolom hebben we de RST-pin van de RC522 verplaatst van GPIO 22 naar GPIO 4, omdat GPIO 22 hier de SCL-lijn van de LCD is.

Stap voor stap in elkaar zetten

  1. Bouw de behuizing van de maquette en bereid de plekken voor de modules en de kabelgaten voor; monteer de elektronica als laatste.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. Upload de hoofdsketch en stel de drempels GAS_LIMIT, DARK_LIMIT en FAN_ON in op basis van je notities.
  7. 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.
Bedraad niet alles in één keer en probeer niet alles in één keer te laten draaien. Als acht modules niet samenwerken, kan het zoeken naar de fout uren duren; modules die je één voor één hebt getest werken meestal meteen als je ze combineert.

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.

Dit alarm is een leerproject; gebruik het nooit als enige bescherming tegen een gaslek of brand in een echt huis, want het is geen vervanging voor gecertificeerde melders uit de handel. Bovendien kan tijdens een echt gaslek zelfs het in- of uitschakelen van een elektrisch apparaat of het starten van een motor een vonk veroorzaken; daarom gebruiken echte systemen explosieveilige (Ex-gecertificeerde) apparatuur. De raamservo en de relais in de maquette zijn er alleen om het idee te demonstreren.

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

5V-relaismodule
Relaismodule: schakelt met een klein signaal van de Arduino een lamp of ventilator in een apart circuit aan en uit; de belasting sluit je aan op de klemmen COM, NO en NC.

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.

Gebruik voor de maquette 5V- of 12V-ledlampen en -ventilatoren. Ook al staat er op het relais "10 A 250 V AC", netspanning kan dodelijk zijn; in een schoolproject mag die alleen onder toezicht van een volwassene worden aangesloten, in een gesloten kast en met een zekering. De veilige bedradingsregels staan in het artikel Wat is een relaismodule?.

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.

C++ (Arduino IDE)
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}
FunctieTaakHoe vaak?
handleLight()Schakelt het lamprelais in op basis van de PIR en LDR, en uit na 20 seconden zonder bewegingElke lus (behalve de eerste 60 seconden)
handleClimate()Leest de DHT11 en stuurt de ventilator aan met hysterese 28/26 °CElke 2 seconden
handleSafety()Leest de MQ-2 en de vlamsensor en beheert het alarm en het raamElke lus
handleDoor()Leest de pas, print de UID naar de Serial Monitor, opent en sluit de deurElke lus
updateLcd()Toont temperatuur, luchtvochtigheid, de gaswaarde of een statusmeldingEén keer per seconde
Buzzerregel in loop()Maakt de pas-piep en het pulserende alarmgeluidElke 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

ESP32-ontwikkelboard
ESP32: Wi-Fi en Bluetooth zijn ingebouwd, dus je hebt geen extra module nodig om het smart home met je telefoon te bedienen.

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.

C++ (Arduino IDE)
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.

De pins van de ESP32 geven 3,3 V af. Op een active-LOW 5V-relaismodule met optocoupler laat een HIGH-signaal van 3,3 V het relais niet altijd volledig los; als het relais nooit uitschakelt, kies dan een module die op 3,3 V kan worden geschakeld, of haal bij modules met een JD-VCC-jumper de jumper weg en voed VCC met 3,3 V en JD-VCC met 5 V. Is er op school geen wifi, vervang dan de verbindingsregels door WiFi.softAP("BlueGrays-Ev", "12345678") zodat de ESP32 een eigen netwerk maakt; je telefoon maakt verbinding met dat netwerk en opent 192.168.4.1.

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.

C++ (Arduino IDE)
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?

MethodeWat je nodig hebtVan buiten het huisMoeilijkheidHet best voor
ESP32-webserverESP32 en wifi thuisNee, alleen op hetzelfde netwerkGemiddeldSchoolpresentaties, demo's zonder internet, helemaal je eigen code
Blynk IoTESP32, internet en een Blynk-accountJaMakkelijkKant-en-klare interface, grafieken en meldingen
Bluetooth (HC-05)Uno, HC-05 en een Android-appNee, ongeveer 10 mMakkelijkBij de Uno blijven (werkt niet met iPhone)
Telegram-botESP32 en internetJaGemiddeldAlarmmeldingen en korte commando's
MQTT + Home AssistantESP32 en een lokale server (bijv. Raspberry Pi)Ja, moet worden ingesteldGevorderdEchte 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:

MicroPython
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.
Bereid je het project voor op een wetenschapsbeurs, stel dan een meetbare onderzoeksvraag in plaats van te zeggen "ik heb een smart home gebouwd", bijvoorbeeld: "Hoeveel energie bespaart verlichting met een PIR en een LDR vergeleken met een lamp die altijd aan staat?" Voor ideeën en beoordelingscriteria, zie het artikel Arduino-projectideeën voor wetenschapsbeurzen.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
De Arduino reset of de LCD gaat raar doen als een servo beweegtServo's en relais worden gevoed via de 5V-pin van de ArduinoAparte 5V 2–3 A-adapter, gemeenschappelijke GND, condensator van 470–1000 µF op de servovoeding
Het relais werkt andersom en staat aan bij het opstartenDe module is active LOWWissel de waarden RELAY_ON en RELAY_OFF om
Het alarm gaat elke keer af bij het inschakelenDe MQ-2 warmt op en de PIR leert zijn omgeving kennenHoud 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 inDARK_LIMIT is verkeerd of de LDR ziet het licht van de lampStel de drempel in aan de hand van de waarden in de Serial Monitor en verplaats de LDR naar een buitenmuur
Passen worden niet gelezenDe bedrading van de RC522 klopt niet of de module zit op 5 VControleer de SPI-pins en test de module met het voorbeeld DumpInfo
De DHT11 geeft nan terugDe DATA-draad zit op de verkeerde pin of een kale sensor heeft geen pull-upweerstandControleer de pin, gebruik een module of voeg 10 kΩ toe tussen DATA en VCC
De servo trilt af en toeZwakke voeding; interrupts pauzeren kort tijdens het lezen van de DHT11Verbeter de voeding; gebruik zo nodig detach() op de servo als hij klaar is met bewegen
Op de ESP32 is de gaswaarde altijd 0 of 4095Een ADC2-pin botst met Wi-Fi of er is geen spanningsdelerGebruik een ADC1-pin zoals GPIO 34 of 35 en een spanningsdeler
De telefoon opent de pagina van de ESP32 nietDe telefoon zit op een gastnetwerk of mobiele data, of het netwerk is 5 GHzMaak 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.

Alle projecten bekijken
Temperatuur en luchtvochtigheid met DHT11
AR-55Gemiddeld

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…

4.7(47)
83
Slimme trap- en gangverlichting
AR-82Gemiddeld
Premium

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.

5.0(36)
52
ESP32 slimme verlichting (PIR + LDR + relais + OLED)
ES-37Gevorderd
Premium

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.

4.3(6)
11
Deurbel en licht met bewegingssensor
AR-25Gemiddeld
Premium

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…

4.7(54)
72
Alarm met vlam- en gassensor
AR-52Gevorderd
Premium

Alarm met vlam- en gassensor

Een kleine bewaker die je meteen waarschuwt als er gas lekt of ergens een vlam verschijnt.

4.8(52)
67
ESP32 RFID-deurslot (RC522 + servo + OLED + buzzer + LED)
ES-35Gevorderd
Premium

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.

4.8(9)
16
230V-lamp laten branden met een afstandsbediening
AR-21Gevorderd
Premium

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.

4.4(23)
31
ESP32 asynchrone webserver (met IP-weergave op lcd)
ES-27Gevorderd

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.

4.8(16)
26