Arduino Smart Home Projekt: Modellhaus, Sensoren, Code und App

Ein Arduino Smart Home Projekt macht die Lichter, die Tür, das Fenster und die Alarme eines Modellhauses mithilfe von Sensoren automatisch, und auf Wunsch steuerst du alles zusätzlich vom Handy aus. Kein Wunder, dass es zu den beliebtesten Schulprojekten gehört. Ein Flurlicht, das bei Bewegung angeht, eine Sirene, die bei austretendem Gas losgeht, ein Lüfter, der bei Wärme anläuft, und eine Tür, die sich mit einer Karte öffnet, ergeben eine kleine, aber funktionierende Kopie eines echten Smart-Home-Systems. Mit einem Arduino Uno oder einem ESP32, rund zehn Modulen und einem Wochenende schaffst du das auch.

In dieser Anleitung beginnen wir mit dem Plan des Modellhauses: Welches Modul kommt in welchen Raum, wofür geht das Budget drauf, wie planst du die Stromversorgung und wie verteilst du die Pins? Danach bauen und testen wir jedes Modul einzeln und schreiben den kompletten Arduino-Sketch, der alle gleichzeitig steuert, ganz ohne delay(). In den letzten Abschnitten erfährst du, wie du das Haus per ESP32-Webserver oder Blynk vom Handy aus steuerst, wie du typische Fehler behebst und wie du bei der Präsentation in der Schule die Jury überzeugst.

Wie funktioniert ein Smart-Home-System?

Jedes Smart Home arbeitet nach demselben dreiteiligen Kreislauf. Sensoren messen die Umgebung: Bewegt sich jemand, ist es dunkel, wie warm ist es, gibt es Gas oder eine Flamme in der Küche, welche Karte wurde an die Tür gehalten? Der Controller, also der Arduino oder ESP32, vergleicht diese Werte mit Regeln: "Wenn es dunkel ist und sich jemand bewegt, Licht an", "Wenn die Temperatur über 28 °C steigt, Lüfter an". Aktoren setzen die Entscheidung um: Ein Relais schaltet Lampe und Lüfter, ein Servo bewegt Tür und Fenster, der Summer piept und das Display zeigt den Status. Die Handysteuerung fügt diesem Kreislauf nur einen weiteren Eingang hinzu; dann entscheidet dein Fingertipp statt einer Regel.

Das Modellhaus planen

Plane das Modell rund um die Elektronik, statt die Elektronik nachträglich hineinzuquetschen. Eine Grundplatte von etwa 50×40 cm reicht für zwei oder drei Räume und einen Eingang. Für die Wände lässt sich 5 mm starke Kapa-Platte (Foam Board) oder PVC-Hartschaumplatte (z. B. Forex) leicht mit dem Cuttermesser schneiden; 3–4 mm MDF ist stabiler, braucht aber eine Säge oder einen Lasercutter. Der Maßstab 1:20 ist ein guter Anfang: Eine Raumhöhe von 2,6 m wird zu einer 13 cm hohen Wand, eine 90 cm breite Tür zu 4,5 cm. Mach das Dach abnehmbar oder lass es ganz weg; die Jury will in die Räume hineinschauen.

• Technikraum oder doppelter Boden: Setze Arduino, Steckbrett, Relaismodul und Stromanschluss in ein Fach an der Rückseite des Hauses oder unter einen 3–4 cm hohen doppelten Boden. Deckst du ihn mit klarem Acrylglas ab, ist die Schaltung geschützt und trotzdem sichtbar.
• Kabelkanäle: Bohre unter jedem Sensor ein 6–8-mm-Loch und führe die Kabel unter der Grundplatte zum Technikraum. Wähle die Sensorkabel gleich lang genug, statt kurze Kabel aneinanderzustückeln.
• Tür: Befestige die Tür mit einem kleinen Scharnier oder Klebeband an der Wand und verbinde das Servohorn des SG90 über einen gebogenen Draht aus einer Büroklammer mit der Tür. Klebe den RC522 innen an die Außenwand; der Leser erkennt die Karte meist auch durch eine 5-mm-Platte hindurch.
• Küche: In echten Wohnungen gehört ein Melder für Erdgas (Methan) unter die Decke, weil es leichter als Luft ist, ein Melder für Flüssiggas (LPG) dagegen in Bodennähe, weil es schwerer ist; im Modell genügt ein Platz unter der Decke. Richte den Flammensensor auf den Herd aus.
• Weitere Sensoren: Setze den PIR in eine Ecke, die den Eingangsweg von der Seite sieht, den LDR an eine Außenwand oder ein Fenster, wo er das Licht der Lampe nicht sieht, und den DHT11 weit weg von der Lampe und dem warmen Gehäuse des MQ-2.

Teileliste und Kosten

Die Preise ändern sich je nach Händler und mit der Zeit oft, deshalb nennen wir keine Beträge; die Tabelle zeigt, welches Gewicht jedes Teil im Budget hat. Sensoren und Module sind einzeln alle günstig; den Großteil des Budgets machen Board, LCD, Netzteil und Modellbaumaterial aus. Hast du ein Arduino-Starterkit, sind Board, Steckbrett, Kabel, LDR, Summer und oft auch ein Servo und ein LCD schon vorhanden. Bei knappem Budget kannst du LCD und zweiten Servo weglassen: Statt des Displays nutzt du den seriellen Monitor, und das Fenster kommt in einer späteren Ausbaustufe dazu. Ein genauerer DHT22 statt des DHT11 kostet etwas mehr, macht deine Messwerte bei der Präsentation aber glaubwürdiger.

Stromversorgung: Warum ein eigenes 5-V-Netzteil?

Bei Smart-Home-Modellen haben fast alle Beschwerden wie "startet ab und zu neu", "der Servo zittert" oder "auf dem LCD erscheinen seltsame Zeichen" dieselbe Ursache: die Stromversorgung. Ein USB-Anschluss am Computer liefert etwa 500 mA, und wenn das Board über USB läuft, hängt auch der 5V-Pin des Uno an dieser Grenze. Zählst du die Werte unten zusammen, siehst du, dass der Gesamtstrom leicht über 1 A steigt, wenn sich beide Servos gleichzeitig bewegen.

Pinbelegung: Arduino Uno und ESP32

So viele Module belegen fast alle Pins des Uno, deshalb solltest du die Belegung von Anfang an planen. Der RC522 nutzt Hardware-SPI, daher liegen MOSI, MISO und SCK fest auf D11, D12 und D13. Das LCD braucht über I2C nur A4 und A5; genau deshalb haben wir ein Display mit I2C-Modul statt eines parallel angeschlossenen LCD gewählt. Analoge Pins funktionieren bei Bedarf auch als digitale Pins, so können wir den Fensterservo an A2 anschließen. Lass D0 und D1 frei: Über diese serielle Leitung lädst du Code hoch und liest die Kartennummern im seriellen Monitor. Die Pinbelegung deines Boards siehst du im Tool Pinout.

Schritt für Schritt zusammenbauen

1. Baue das Gehäuse des Modells und bereite die Positionen der Module und die Kabellöcher vor; die Elektronik kommt zuletzt hinein.
2. Richte die Stromversorgung ein: Schließe das 5-V-Netzteil an die Versorgungsschienen des Steckbretts an, verbinde dessen GND mit dem GND des Arduino und miss die 5 V mit einem Multimeter nach.
3. Schließe das I2C-LCD an und lass einen Text anzeigen. Findest du die Adresse des Displays nicht, nutze den Scanner-Sketch aus dem Artikel zum I2C-LCD.
4. Füge die Sensoren einzeln hinzu: DHT11, LDR, PIR, MQ-2 und Flammensensor. Teste jeden mit einem kurzen Sketch im seriellen Monitor und notiere die Werte in sauberer Luft, im Dunkeln und im Hellen.
5. Füge die Aktoren hinzu: Teste zuerst die Relais ohne Last am Klicken und an ihrer LED, dann die Servos mit externer Versorgung, und schließe zuletzt den RC522 an. Halte deine Karten an den Leser und notiere ihre Nummern.
6. Lade den Hauptsketch hoch und stelle die Schwellen GAS_LIMIT, DARK_LIMIT und FAN_ON nach deinen Notizen ein.
7. Fixiere die Kabel mit Heißkleber und beschrifte sie; lass das System eine halbe Stunde laufen und achte auf Neustarts, Überhitzung oder Fehlalarme.

Automatisches Licht mit PIR und LDR

Der PIR-Sensor HC-SR501 erkennt Änderungen der Infrarotstrahlung, die der menschliche Körper abgibt, und setzt seinen Ausgang bei Bewegung auf HIGH. Mit einem PIR allein würde die Lampe auch tagsüber angehen, deshalb hat unsere Regel zwei Bedingungen: Licht an, wenn sich jemand bewegt und es dunkel ist. Der LDR wird mit einem 10-kΩ-Widerstand als Spannungsteiler angeschlossen (5V → LDR → A1 → 10 kΩ → GND); je dunkler es wird, desto kleiner der Wert an A1. Der Code merkt sich den Zeitpunkt der letzten Bewegung und schaltet die Lampe nach 20 Sekunden ohne neue Bewegung aus; solange jemand herumläuft, beginnt die Zeit jedes Mal neu. Stell den Jumper des Sensors auf H (wiederholte Auslösung) und das Tx-Poti auf die kürzeste Zeit, die Dauer bestimmt der Code. Mehr dazu in den Artikeln PIR-Bewegungsmelder und LDR-Lichtsensor.

Gas- und Feueralarm

Im MQ-2 steckt eine Zinndioxidschicht, die eine Heizung warm hält; LPG, Methan, Butan, Wasserstoff, Alkohol und Rauch verändern ihren Widerstand. Der AO-Pin des Moduls liefert eine Spannung, die mit der Gaskonzentration steigt. Der Sensor muss nach jedem Einschalten eine Weile aufheizen, deshalb ignoriert der Code Gasalarme in den ersten 60 Sekunden. Der Flammensensor erkennt das Infrarotlicht von 760–1100 nm, das ein Feuer abstrahlt; bei den meisten Modulen geht der DO-Ausgang bei einer Flamme auf LOW und eine zweite LED auf der Platine leuchtet, prüfe dein Modul aber unbedingt mit einem Feuerzeug aus sicherem Abstand. Bei Gas ertönt der Alarm und das Fenster öffnet sich zum Lüften; bei einer Flamme bleibt das Fenster dagegen zu, weil frische Luft ein Feuer anfacht. Wie du die Schwelle einstellst und welche anderen MQ-Sensoren es gibt, steht im Artikel zum MQ-2-Gassensor.

Temperatur, Luftfeuchtigkeit und automatischer Lüfter

Der DHT11 misst die Temperatur von 0 bis 50 °C auf ±2 °C und die Luftfeuchtigkeit von 20 bis 90 % auf ±5 % genau und darf höchstens einmal pro Sekunde abgefragt werden; der Code liest ihn alle zwei Sekunden. Statt einer einzigen Schwelle nutzen wir für den Lüfter eine Hysterese: Er startet bei 28 °C, stoppt aber erst, wenn die Temperatur auf 26 °C gefallen ist. Mit nur einer Schwelle würde das Relais ständig klicken, während die Temperatur zwischen 27 und 28 °C schwankt, und dabei sich selbst und den Lüfter verschleißen. Liefert der Sensor einen Lesefehler und gibt "nan" zurück, überspringt der Code diese Messung und behält den letzten gültigen Wert. Für genauere Messungen funktioniert der DHT22 mit demselben Code, du schreibst einfach DHT22 statt DHT11. Mehr dazu im Artikel zum DHT11-Temperatur- und Feuchtigkeitssensor.

RFID-Tür mit Servo

Der RC522 liest MIFARE-Karten und Schlüsselanhänger mit 13,56 MHz aus 3–5 cm Entfernung. Jede Karte hat eine eigene Kennnummer (UID), und der Code vergleicht die gelesene UID mit einer Liste berechtigter Karten. Passt sie, dreht der Servo die Tür auf 90 Grad, ein kurzer Piepton ertönt und auf dem LCD steht "Hos geldin!" (Türkisch für "Willkommen!"); nach 5 Sekunden schließt sich die Tür von selbst. Eine unbekannte Karte bekommt einen langen Piepton. Um die UIDs deiner Karten herauszufinden, lädst du den Code hoch, öffnest den seriellen Monitor mit 9600 Baud und hältst eine Karte an den Leser: Du siehst eine Zeile wie "UID: A1 B2 C3 D4". Trage diese Bytes in der Form 0xA1 in die Liste CARDS ein und ergänze bei einstellig angezeigten Bytes eine führende Null (0x05 statt 5). Ein Schloss, das nur die UID prüft, eignet sich zum Lernen, bietet aber keine echte Sicherheit; warum, erklären wir im Artikel zum RFID RC522.

Fenster und Vorhang

Für das Fenster genügt ein zweiter SG90: Du verbindest ein kleines Fenster aus Acrylglas mit Scharnier über einen Draht mit dem Servohorn; 0 Grad heißt zu, 90 Grad heißt offen. Wenn du write(0) vor attach() aufrufst, springt der Servo beim Einschalten nicht auf 90 Grad und schlägt das Fenster nicht auf. Ein Vorhang braucht mehr Weg: Du wickelst den Stoff auf einen dünnen Stab und drehst diesen. Ein Schrittmotor 28BYJ-48 mit ULN2003-Treiber ist dafür leise und präzise, braucht aber 4 Pins; da beim Uno keiner mehr frei ist, gehört der Vorhang sinnvollerweise in die ESP32-Version oder an einen Arduino Mega. Muss ein Pin reichen, geht auch ein FS90R-Servo mit Endlosdrehung; da er seine Position aber nicht kennt, öffnest und schließt du den Vorhang über die Laufzeit. Ein Regensensor, der das Fenster bei Regen automatisch schließt, ist ebenfalls eine schöne Erweiterung.

Lampe und Lüfter mit Relais

Ein Arduino-Pin liefert sicher nur etwa 20 mA (absolute Grenze 40 mA), Lüfter und Lampe brauchen viel mehr. Deshalb sitzt ein Relaismodul dazwischen: Das Signal am IN-Pin aktiviert einen Elektromagneten, der die Kontakte in einem getrennten Stromkreis schließt. Schließe die Last an COM und NO an, damit die Lampe aus bleibt, solange der Arduino aus ist oder neu startet. Die meisten dieser Module sind Low-aktiv, das Relais zieht also an, wenn du LOW ausgibst; dafür gibt es im Code die Konstanten RELAY_ON und RELAY_OFF. In setup() schreibt der Code HIGH, bevor der Pin zum Ausgang wird, sodass das Relais beim Start des Arduino nicht einmal kurz anzieht. Beim Lüfter sorgt die Hysterese dafür, dass er nicht zu oft schaltet; die Lampe bleibt an, bis die PIR-Zeit abgelaufen ist.

Der komplette Sketch (Arduino Uno)

Die wichtigste Regel im Smart-Home-Code lautet: Kein Modul wartet auf ein anderes. Hieltest du die Tür mit delay(5000) fünf Sekunden offen, würde in dieser Zeit weder der Gasalarm funktionieren noch der PIR gelesen. Deshalb steckt jedes Modul in einer eigenen Funktion, und loop() ruft diese Funktionen nacheinander hunderte Male pro Sekunde auf. Alles, was mit Zeit zu tun hat, wird mit millis() gemessen, und der Zustand jedes Moduls steckt in Variablen wie lightOn, fanOn, doorOpen und alarmOn. Alle Einstellungen stehen als Konstanten ganz oben im Code, du musst also nicht im Code suchen, um eine Schwelle zu ändern. Die Idee dahinter erklärt der Artikel millis() statt delay(). Zum Kompilieren installierst du über den Bibliotheksverwalter die Bibliotheken MFRC522, die DHT sensor library von Adafruit und LiquidCrystal I2C von Frank de Brabander; wenn nach Abhängigkeiten gefragt wird, installierst du alle. Servo, SPI und Wire sind in der Arduino IDE bereits enthalten.

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}

Kompiliert belegt dieser Code etwa 38 % des Programmspeichers und 28 % des RAM des Uno; Speicher ist also noch frei, bei den Pins ist aber nur noch A3 übrig. An A3 kannst du einen Taster oder einen Regensensor anschließen; für mehr musst du auf einen Arduino Mega oder einen ESP32 umsteigen. Feste Texte in F() zu schreiben, ist der einfachste Weg, den RAM-Verbrauch niedrig zu halten.

Steuerung per Handy: ESP32-Webserver

Der Uno hat kein WLAN; am einfachsten steuerst du das Smart Home vom Handy aus, wenn du das Gehirn gegen einen ESP32 tauschst. Der folgende Code verbindet den ESP32 mit deinem Heimnetz und startet einen kleinen Webserver. Ist dein Handy im selben WLAN, öffnest du die im seriellen Monitor angezeigte IP-Adresse im Browser und siehst vier große Schaltflächen für Lampe, Lüfter, Tür und Fenster sowie die aktuelle Temperatur, Luftfeuchtigkeit und den Gaswert; die Seite lädt sich alle 10 Sekunden neu. Jede Schaltfläche schickt dem ESP32 eine kurze Anfrage, welches Gerät geschaltet werden soll; der ESP32 ändert den Zustand und leitet dich zurück zur Startseite. Für die Servos installierst du über den Bibliotheksverwalter die Bibliothek ESP32Servo, denn die normale Servo-Bibliothek läuft auf dem ESP32 nicht.

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}

Dieser Code enthält nur die Teile, die du aus der Ferne steuerst. Du kannst aber auch die Funktionen handleLight(), handleSafety() und handleDoor() aus dem Uno-Sketch übernehmen: Passe die Pinnummern an die ESP32-Spalte der Tabelle an, nutze ESP32Servo statt Servo und miss die Schwellen GAS_LIMIT und DARK_LIMIT neu, weil der ADC des ESP32 Werte von 0 bis 4095 liefert. Die Seite hat kein Passwort, jeder in deinem Heimnetz könnte also die Tür öffnen; ein einfaches Passwort mit der Funktion authenticate() der WebServer-Bibliothek ist eine gute Gewohnheit. Für ein Panel, das sich in Echtzeit aktualisiert, lies den Artikel zu ESP32 und WebSocket.

Mit Blynk von überall steuern

Den ESP32-Webserver erreichst du nur aus demselben Netz. Willst du auch von unterwegs über mobile Daten steuern, macht es dir eine Cloud-Plattform wie Blynk IoT leicht: Die Oberfläche baust du per Drag-and-drop in der Handy-App, und der ESP32 verbindet sich mit dem Blynk-Server. Lege in Blynk.Cloud eine Vorlage (Template) an, füge drei Datastreams namens V0 (Integer, 0–1, Lampe), V1 (Double, Temperatur) und V2 (Double, Luftfeuchtigkeit) hinzu, lege ein Gerät an und kopiere die angezeigten Werte für Template ID, Template Name und Auth Token an den Anfang des Codes. In der App verknüpfst du V0 mit einem Switch und V1 und V2 mit je einem Gauge. Der kostenlose Tarif begrenzt die Zahl der Geräte, Datastreams und Nachrichten pro Monat, deshalb senden wir die Sensorwerte alle fünf Sekunden statt jede Sekunde. Die ausführliche Einrichtung steht in der Anleitung Blynk IoT mit dem 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}

Welche Steuerung passt zu dir?

Für eine Schulpräsentation ist der ESP32-Webserver die sicherste Wahl: Er hängt weder vom Internet noch von einer Cloud ab und läuft auch ohne WLAN im Saal über sein eigenes Netz. Willst du beim Uno bleiben und nur Bluetooth ergänzen, kannst du mit App Inventor deine eigene Android-App bauen; da beim Uno aber kein Pin mehr frei ist, musst du für den HC-05 auf das LCD oder den Fensterservo verzichten. Eine Nachricht aufs Handy bei Alarm bekommst du mit einem ESP32-Telegram-Bot, und mit echten Geräten verbindest du das Haus über MQTT und Home Assistant.

Smart Home mit dem Raspberry Pi Pico

Dasselbe System kannst du auch mit einem Raspberry Pi Pico in MicroPython aufbauen, und der Pico W mit WLAN lässt sich wie der ESP32 vom Handy aus steuern (siehe Pico-W-Webserver). Da der Pico mit 3,3 V arbeitet, gelten die ESP32-Regeln auch hier: Versorge den LDR-Spannungsteiler aus 3V3, teile 5-V-Analogausgänge herunter und wähle ein Relaismodul, das mit 3,3 V schaltet. Analoge Eingänge sind nur GP26, GP27 und GP28. Der folgende Code ist die MicroPython-Version des Bewegungslichts:

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)

Tipps für die Präsentation in der Schule

• Beginne mit einem Problem: Beschreibe ein echtes Problem in einem Satz, etwa "Licht, das im leeren Haus brennt, ein Gasleck, das niemand bemerkt, ältere Menschen, die ihren Schlüssel verlieren", und zeige dann, wie dein Modell darauf antwortet.
• Bereite ein Blockschaltbild vor: links die Sensoren, in der Mitte der Arduino, rechts die Aktoren; beschrifte die Pfeile mit den Regeln ("dunkel + Bewegung → Lampe"). Die Jury liest deinen Code nicht, aber an dieses Bild erinnert sie sich.
• Plane eine Live-Vorführung: Halte die Karte an den Leser und zeige, wie sich die Tür öffnet, winke vor dem PIR, halte einen Wattebausch mit Desinfektionsalkohol an den MQ-2 (Alkohol löst den Sensor ebenfalls aus) und wärme den DHT11 mit den Fingern. Jede Vorführung sollte 10–20 Sekunden dauern.
• Kein offenes Feuer: Zünde im Pappmodell kein Feuerzeug und keine Kerze an. Die meisten Flammensensoren reagieren auch auf das Infrarotlicht einer nah gehaltenen TV-Fernbedienung; probiere es vorher aus und nutze das für die Vorführung.
• Passe die Schwellen an den Raum an: Hat der Saal am Tag der Präsentation 22 °C, verdirbt dir eine Schwelle von 28 °C die Lüfter-Vorführung; setze FAN_ON 2–3 Grad über die Raumtemperatur, damit der Lüfter anläuft, wenn du den Sensor mit den Fingern wärmst.
• Miss nach und nenne Zahlen: Zeichne zum Beispiel einen Tag lang auf, wie viele Minuten die Lampe mit und ohne PIR brennt, und gib die Einsparung in Prozent an. Ein Ergebnis mit Zahlen wirkt viel stärker als "es funktioniert".
• Habe einen Plan B: Nimm ein Video des laufenden Systems auf, bring Ersatzkabel, einen Servo und ein Netzteil mit und schreib die Kartennummern und WLAN-Daten auf einen Zettel.
• Bereite dich auf Fragen der Jury vor: Für die Frage "Wie wäre das in einem echten Haus?" solltest du kurze Antworten zu Netzspannung, zertifizierten Meldern, RFID-Sicherheit und zum Verhalten der Tür bei Stromausfall parat haben.

Häufige Fehler und ihre Lösungen

Ein Arduino Smart Home Projekt vereint Sensoren auslesen, Entscheidungen treffen, Motoren und Relais ansteuern, Stromversorgung planen und drahtlose Steuerung in einem einzigen Aufbau; deshalb ist es ein großartiges Thema zum Lernen und zum Präsentieren. Fang mit einem Modul an, teste jeden Schritt und lass das System Stück für Stück wachsen. In der BlueGrays-App findest du die Projekte intelligente Treppenbeleuchtung, smarte Beleuchtung mit PIR und LDR, Flammen- und Gasalarm, RFID-Türschloss und ESP32-Webserver Schritt für Schritt mit Schaltplänen und Code.