Inhaltsverzeichnis
Einleitung
Willkommen zum Einstieg in die spannende Welt des Smart Home mit dem Funduino „Smart Home Education System“! Dieses umfassende Lern- und Experimentierset richtet sich speziell an technikbegeisterte Lernende, Lehrkräfte und Ausbilder, die Grundlagen und fortgeschrittene Anwendungen von Smart-Home-Technologien, Sensorik, Aktorik und IoT (Internet of Things) praxisnah vermitteln möchten.
Mit einer Vielzahl eingebauter Sensoren – etwa für Temperatur, Luftfeuchtigkeit, Licht, Bewegung, Feuchtigkeit (Flüssigkeit), Gasdetektion und Ultraschall –, kombiniert mit Aktoren wie Servos, Lüftern, LEDs, OLED Display, WS2812, Lautsprechern sowie Steuerungsmöglichkeiten via WLAN und Bluetooth, bietet dieses System eine realitätsnahe Plattform zur Entwicklung smarter Anwendungen.
In dieser Anleitung führen wir dich Schritt für Schritt durch:
Aufbau & Vorbereitung – Welche Komponenten Sie benötigen und wie Sie das System anschließen.
Grundkonfiguration – Installation der notwendigen Software, Beispielsketch.
Beispielprojekte – Einstieg in praxisorientierte Szenarien wie Temperatursteuerung, Alarmfunktionen oder Lichtautomation.
Erweiterungsmöglichkeiten & Fehlerbehandlung – Tipps zum Ausbau, zur Anpassung und zur Lösung typischer Probleme.
Nach dem Durcharbeiten dieser Anleitung werden Sie in der Lage sein, eigenständig smarte Steuerungen zu entwickeln, Sensorwerte auszuwerten, Aktoren zu kontrollieren und Ihre Ideen in echte IoT-Projekte umzusetzen. Machen Sie sich bereit: Das Klassenzimmer wird zur IoT-Werkstatt – und Ihre Lernenden werden begeistert sein von dem, was sie selbst erschaffen können.
Hardware Übersicht
Platinenansicht vorne:
Platinenansicht hinten:
7 und 18Das Funduino Smarthome-System besteht aus einer Werkstatt, die um die Elektronik-Platine ergänzt wird, um einen Alltagsbezug herzustellen.
Die Platine besteht aus folgenden Komponenten:
Platinennummer 1: LED rot: Verbunden mit Pin 25
Platinennummer 2: LED grün: Verbunden mit Pin 26
Platinennummer 3: Taster: Verbunden mit Pin 23 (derzeit INPUT)
Platinennummer 4: Buzzer (Piezo Lautsprecher): Verbunden mit Pin 19
Platinennummer 5: Potenziometer: Verbunden mit Pin 39
Platinennummer 6: Ultraschall-Entfernungssensor: Verbunden mit Pin 17 und Pin 18.
Platinennummer 7: OLED Display mit SSD1306 Chip: Verbunden über I2C, welches den Pins SCL 22 und SDA 21 entspricht
Platinennummer 8: Lüfter: Verbunden mit Pin 4 (kann alternativ per Hand über den Taster auf der Vorderseite manuell betätigt werden.)
Platinennummer 9: IR-Empfänger für Fernbedienungen VS1838: Verbunden mit Pin 16
Platinennummer 10: Innenbeleuchtung mehrfarbig WS2812 mit 8 LEDs: Verbunden mit Pin 15
Platinennummer 11: Temperatur- und Luftfeuchtigkeitssensor DHT11: Verbunden mit Pin 14
Platinennummer 12: Lichtstärkesensor LDR: Verbunden mit Pin 35
Platinennummer 13: Bewegungsmelder PIR: Verbunden mit Pin 13
Platinennummer 14: Servo für die automatische Tür: Verbunden mit Pin 12
Platinennummer 15: Gassensor MQ135: Verbunden mit Pin 34
Platinennummer 16: Feuchtigkeitssensor: Verbunden mit Pin 36
Aufbau & Vorbereitung
Der Aufbau des Smarthome besteht aus zwei Abschnitten.
Zunächst muss die Werkstatt aufgebaut werden. Der Aufbau ist schnell und intuitiv zu erledigen. Als kleine Hilfestellung kannst du dir zusätzlich dieses Video ansehen:
Mit dem Laden des Videos akzeptieren Sie die Datenschutzerklärung von YouTube.
Mehr erfahren
Im zweiten Schritt werden die Anbauteile der Platine ergänzt. Das bedeutet, dass auf der Rückseite der Platine die Komponenten Servo, WS2812 LED-Stab, MQ135 Sensor, der Lüfter und der Feuchtigkeitssensor eingesteckt werden.
Wichtige Hinweise:
Servo: Das Servo wird mit dem schwarzen Kunststoffhalter auf der Rückseite montiert. Dazu verwendet man die zwei gleichgroßen, beim Servo beiliegenden Schräubchen. Die Schräubchen werden dabei von vorn durch die Platine gesteckt und in dem Kunststoffhalter eingeschraubt.
Wichtig ist nun, dass die Tür noch nicht eingesetzt wird! Die Tür wird erst eingesetzt, wenn der Servo bereits programmiert wurde.
Der Lüfter wird mit den beiliegenden weißen Nylonschrauben und Nylonmuttern per Hand von hinten befestigt. Der runde Aufkleber des Lüfters befindet sich innen.
Nach dem Aufbau wird die Smarthome Platine in die rechte Seitenwand eingebaut. Dazu nimmt man zunächst die Acrylglasplatten aus dem Modell heraus. Dann hebt man die obere, schwarze Strebe mit den kleinen Scheinwerfern an und platziert die Platine, so dass sie an allen Seiten fixiert ist. Danach setzt man die anderen Acrylglasplatten wieder ein.
Grundkonfiguration
Um das Smarthome programmieren zu können, gibt es aufgrund des ESP32 Mikrocontrollers viele Möglichkeiten. Eine davon ist die Programmierung mit der Arduino IDE Software. Diese werden wir von nun an in dieser Anleitung verweden.
Für alle Fortgeschrittenen Arduino-User stellen wir an dieser Stelle schon einen Beispielsketch zur Nutzung bereit.
Arduino IDE & ESP32 – Grundlagen (Windows)
Diese Anleitung zeigt dir Schritt für Schritt, wie du die Arduino IDE einrichtest und deinen ESP32 programmierst. Es ist besonders für Schülerinnen und Schüler und Einsteiger geeignet.
1. Arduino IDE installieren
1) Öffne deinen Webbrowser und gehe auf die Arduino-Download-Seite (www.arduino.cc).
2) Lade die Arduino IDE für Windows herunter und installiere sie wie gewohnt.
2. ESP32-Unterstützung hinzufügen
Damit die IDE den ESP32 Mikrocontroller kennt, musst du eine zusätzliche Adresse (URL) in den Voreinstellungen eintragen:
1) Starte die Arduino IDE.
2) Klicke oben auf „Datei → Voreinstellungen…“ (englisch: File → Preferences).
3) Suche das Feld „Zusätzliche Boardverwalter-URLs“ und trage die folgende URL ein:
https://dl.espressif.com/dl/package_esp32_index.json
3. ESP32-Boardpaket installieren
1) Gehe zu „Werkzeuge → Board → Boardverwalter…“.
2) Gib im Suchfeld „ESP32“ ein.
3) Wähle „ESP32 by Espressif Systems“ und klicke auf „Installieren“.
4. Richtiges Board und Port auswählen
1) Wähle unter „Werkzeuge → Board“ das passende Board, in diesem Fall ist es das „ESP32 Dev Module“.
2) Wähle unter „Werkzeuge → Port“ den Anschluss (z. B. COM3), an dem dein ESP32 angeschlossen ist.
Tipp: Der richtige Port ist häufig der zuletzt hinzugekommene Eintrag.
5. Aufbau eines Sketches
Ein Arduino-Programm heißt „Sketch“. Es hat zwei wichtige Bereiche: setup() und loop(). In setup() werden Dinge einmalig vorbereitet. In loop() läuft deine Hauptlogik immer wieder.
void setup() {
// Dieser Teil läuft einmal beim Start
}
void loop() {
// Dieser Teil wiederholt sich immer wieder
}
6. Erstes Programm: LED blinken lassen
Stecke den ESP32 auf die Platine und verbinde das USB-Kabel. Der ESP32 ist auf der Platine automatisch mit allen Modulen auf der Platine verbunden. In diesem Fall verwenden wir die Ausgänge 25 und 26 des ESP32-Mikrocontrollerboards, da an diesen beiden Ausgängen die grüne und die rote LED angeschlossen sind.
Mit folgendem Sketch lässt du sie blinken:
int ledPin = 25; // Auf der Platine ist die rote LED mit dem digitalen Pin 25 des ESP32 verbunden.
void setup() {
pinMode(ledPin, OUTPUT);
}
void loop() {
digitalWrite(ledPin, HIGH); // LED an
delay(1000); // 1 Sekunde warten
digitalWrite(ledPin, LOW); // LED aus
delay(1000); // 1 Sekunde warten
}
Klicke auf den Pfeil (Upload), um das Programm auf den ESP32 zu übertragen.
WICHTIGER HINWEIS!!!
Nachdem man auf den „Upload-Pfeil“ geklickt hat, wird das Programm zunächst kompiliert. Dieser Vorgang dauert mehrere Sekunden. Erst danach erfolgt der Upload auf den ESP32. Sobald der Upload startet, muss man am ESP32 die Taste „Boot“ drücken, damit der ESP32 in den Boot-Modus kommt. Nur in diesem Modus kann der ESP32 Speicher beschrieben werden. Wenn man die Taste nicht drückt, erscheint eine Fehlermeldung und das Programm wurde nicht auf den ESP32 übertragen.
Programmieren der einzelnen Module
1. LED rot
Dies ist ein Beispielcode zum Programmieren der roten LED:
int ledPin = 25;
void setup() {
pinMode(ledPin, OUTPUT);
}
void loop() {
digitalWrite(ledPin, HIGH); // LED an
delay(1000); // 1 Sekunde warten
digitalWrite(ledPin, LOW); // LED aus
delay(1000); // 1 Sekunde warten
}
2. LED grün
Die grüne LED wird genauso programmiert wie die rote LED. Wir müssen im Code lediglich den Ausgangspin des Microcontrollers ändern, da die grüne LED an Pin 26 und nicht an Pin 25 angeschlossen ist.
int ledPin = 26;
void setup() {
pinMode(ledPin, OUTPUT);
}
void loop() {
digitalWrite(ledPin, HIGH); // LED an
delay(1000); // 1 Sekunde warten
digitalWrite(ledPin, LOW); // LED aus
delay(1000); // 1 Sekunde warten
}
3. Taster
Der Taster wird in diesem Beispiel verwendet, um die beiden Leuchtdioden (grün und rot) gleichzeitig für 5 Sekunden zu aktivieren, sobald der Taster gedrückt wurde.
Ein Tastendruck bewirkt, dass eine Spannung an den Eingangspin 23 des ESP32 weitergeleitet wird. Parallel zum Taster ist an der Leitung zum Pin 23 ein Pulldown Widerstand montiert (unterhalb des Tasters). Dieser bewirkt, dass der Spannungszustand immer wieder auf das GND Niveau gebracht wird, wenn der Taster nicht mehr gedrückt wird.
#define LED_RED 25
#define LED_GREEN 26
#define BUTTON_PIN 23
void setup() {
pinMode(LED_RED, OUTPUT);
pinMode(LED_GREEN, OUTPUT);
pinMode(BUTTON_PIN, INPUT_PULLUP);
digitalWrite(LED_RED, LOW);
digitalWrite(LED_GREEN, LOW);
}
void loop() {
if (digitalRead(BUTTON_PIN) == HIGH) { // Wenn Taster gedrückt ist
digitalWrite(LED_RED, HIGH); // LED-ROT aktivieren
digitalWrite(LED_GREEN, HIGH); // LED-GRÜN aktivieren
delay(5000); // 5 Sekunden an
digitalWrite(LED_RED, LOW); // LED-ROT deaktivieren
digitalWrite(LED_GREEN, LOW); // LED-GRÜN deaktivieren
}
}
Achtung! Beim Upload unbedigt daran denken, dass am ESP32 die „Boot“ Taste gedrückt wird.
4. Lautsprecher / Buzzer
Der Buzzer auf der Platine wird genauso angesteuert, wie eine Leuchtdiode. Der Piezo-Buzzer benötigt lediglich eine Spannung und erzeugt dann einen Ton. Dieser Ton hat immer die gleiche Tonhöhe und kann nicht, im Gegensatz zur Funktionsweise eines Lautsprechers, verändert werden.
Der Buzzer ist auf der Platine mit Pin 19 verbunden.
int buzzer = 19;
void setup() {
pinMode(buzzer, OUTPUT);
}
void loop() {
digitalWrite(buzzer, HIGH); // LED an
delay(1000); // 1 Sekunde warten
digitalWrite(buzzer, LOW); // LED aus
delay(5000); // 5 Sekunden warten
}
5. Potentiometer
Das Potentiometer ist ein Drehregler. Je nach Position wird eine kleinere oder größere Spannung an den Pin 39 geleitet. Im Sketch wird der Wert mit dem MAP-Befehl umgewandelt und an die rote LED weitergeleitet.
#define LED_RED 25
#define POT_PIN 39 // Poti an ADC39
void setup() {
pinMode(LED_RED, OUTPUT);
}
void loop() {
int v = analogRead(POT_PIN); // Der analoge Wert wird unter der Variablen v gespeichert. Die Messwerte liegen zwischen den Zahlenwerten 0 und 4095
int duty = map(v, 0, 4095, 0, 255); // Der map-Befehl wandelt die Zahlenwerte zwischen 0 und 4095 um in den Zahlenwert 0 bis 255
analogWrite(LED_RED, duty); // Am Pin mit der roten LED wird ein Zahlenwert zwischen 0 und 255 ausgegeben. Je nach Stellung des Potentiometers ist die LED dann heller oder dunkler.
}
6. Ultraschallsensor / Entfernungsmessung
Der Sensor RCW-0001 funktioniert ähnlich wie der bekanntere Sensor HC-SR04. Der Sensor misst Distanzen, indem er einen Ultraschall-Impuls sendet (TRIG) und die Zeit bis zum Echo (ECHO) misst. Aus der Laufzeit wird der Abstand in Zentimetern berechnet. In diesem Beispiel warnt ein Buzzer, sobald ein Objekt näher als 20 cm ist.
Anschluss (ESP32):
TRIG → GPIO 18
ECHO → GPIO 17
Buzzer (aktiv) → GPIO 19
Was macht der folgende Sketch?
Sendet einen 10 µs-TRIG-Impuls.
Misst mit pulseIn() die Echo-Zeit in Mikrosekunden.
Rechnet grob in cm um (cm = us / 58).
Wenn cm < 20: Buzzer piept im Takt (150 ms an/aus).
Sonst: Buzzer bleibt aus.
Damit erhältst du eine einfache, akustische Abstandswarnung für den Nahbereich.
#define TRIG_PIN 18
#define ECHO_PIN 17
#define BUZZER 19
void setup() {
pinMode(TRIG_PIN, OUTPUT);
pinMode(ECHO_PIN, INPUT);
pinMode(BUZZER, OUTPUT);
digitalWrite(BUZZER, LOW);
}
void loop() {
// Messimpuls senden
digitalWrite(TRIG_PIN, LOW); delayMicroseconds(2);
digitalWrite(TRIG_PIN, HIGH); delayMicroseconds(10);
digitalWrite(TRIG_PIN, LOW);
// Echo messen und in cm umrechnen
long messzeit = pulseIn(ECHO_PIN, HIGH); // Messen der Zeit, bis die Schallwelle zurückgeworfen wurde.
long cm = messzeit / 58;
// Buzzer steuern
if (cm < 20) {
digitalWrite(BUZZER, HIGH); delay(150);
digitalWrite(BUZZER, LOW); delay(150);
} else {
digitalWrite(BUZZER, LOW);
delay(50);
}
}
7. OLED Display
Dieses Mini-Beispiel initialisiert ein SSD1306-OLED (I²C, Adresse 0x3C) am ESP32 und zeigt den Text „Funduino“ an. Standard-I²C-Pins beim ESP32 sind SDA = 21 und SCL = 22.
Für das OLED Display muss nun zum ersten Mal eine Programmbibliothek installiert werden.
Die verwendete Library heißt SSD1306Ascii.
Library über den Library Manager installieren:
- Arduino IDE öffnen
- Menü Werkzeuge → Bibliotheken verwalten… (oder Sketch → Bibliothek einbinden → Bibliotheken verwalten…).
- In das Suchfeld SSD1306Ascii eingeben.
- Den Eintrag “SSD1306Ascii” von Bill Greiman auswählen → Installieren.
- Fertig. Weitere Beispiele findest du unter Datei → Beispiele → SSD1306Ascii. Du kannst dort zum Beispiel andere Schriftarten und Schriftgrößen ausprobieren. Außerdem gibt es auch grafische Elemente, die am am Display anzeigen kann.
#include <Wire.h>
#include <SSD1306Ascii.h>
#include <SSD1306AsciiWire.h>
SSD1306AsciiWire oled;
void setup() {
Wire.begin(); // ESP32: SDA=21, SCL=22
oled.begin(&Adafruit128x64, 0x3C); // Display starten (Adresse 0x3C)
oled.setFont(System5x7); // einfache Schrift
oled.clear();
oled.setCursor(0, 0);
oled.println(„Funduino“); // Text ausgeben
}
void loop() {
// nichts weiter nötig
}
8. Lüfter
Dieser Sketch schaltet einen Lüfter an Pin 4 abwechselnd 5 Sekunden EIN und für 5 Sekunden AUS.
Technischer Hinweis: Der Lüfter ist nicht direkt an den digitalen Ausgangspin des ESP32 angeschlossen. Denn die digitalen Ausgänge des ESP32 können nur einen sehr begrenzten Ausgangsstrom bereitstellen. Der digitale Pin 4 gibt daher ein Spannungssignal an einen Transistor. Dieser Transistor schaltet dann die 3.3V Spannungsversorgung des ESP32 direkt auf den Lüfter.
Trotz dieser Leistungsschaltung ist ein Lüfter mit einer vergleichsweise geringen Leistung und Stromaufnahme montiert. Aufgrund des kleinen Volumens der Werkstatt reicht der Luftstrom dennoch aus, um den gesamten Innenraum in kürzester Zeit mit Luft von außen zu füllen.
Hinweis für die erste Verwendung. Neue Lüfter müssen sich ein wenig einlaufen, damit sich die Schmiermittel in dem Kugellager gleichmäßig verteilen. Daher kann es notwendig sein, dass der Lüfter beim ersten Betrieb ein wenig per Hand angeschoben werden muss.
#define FAN_PIN 4
void setup() {
pinMode(FAN_PIN, OUTPUT);
}
void loop() {
digitalWrite(FAN_PIN, HIGH); // EIN
delay(5000);
digitalWrite(FAN_PIN, LOW); // AUS
delay(5000);
}
9. Fernbedienung nutzen mit dem VS1838 IR-Empfänger
Mit einem VS1838 (IR-Empfänger-Modul) kannst du Codes beliebiger Infrarot-Fernbedienungen einlesen. Der VS1838 liefert bereits demodulierte Signale. Der untenstehende Sketch nutzt die Library IRremote und gibt empfangene Codes über die serielle Konsole aus.
Library: In der Arduino IDE vorab die Library „IRremote“ (Autor: Armin Joachimsmeyer) über den Bibliotheksmanager installieren.
Anzeige der ausgelesenen Codes im Seriellen Monitor:
Die erkannten Codes der Fernbedienung werden im Seriellen Monitor angezeigt.
Was ist der Serielle Monitor?
Der Serielle Monitor ist ein Fenster in der Arduino-IDE, das Text über die USB-Verbindung vom Mikrocontroller anzeigt. Alles, was du mit Serial.print(…) sendest, erscheint dort – perfekt, um z. B. IR-Codes oder Sensordaten zu sehen. Du kannst darüber auch Text an den ESP32 zurücksenden (Eingabefeld unten), aber das wird jetzt noch nicht wichtig sein.
So öffnest du den Seriellen Monitor:
Seriellen Monitor öffnen: Rechts oben auf das Lupen-Symbol klicken (oder Menü Werkzeuge → Serieller Monitor).
Baudrate einstellen: Unten rechts im Monitor 115200 Baud wählen (muss zur Serial.begin(115200); im Sketch passen).
Tipp zur Fehlersuche
Wenn nur „Hieroglyphen“ erscheinen: falsche Baudrate.
Nichts erscheint: Port prüfen, Board wirklich verbunden? Reset versuchen.
Monitor vor dem Hochladen schließen – manche Systeme blockieren sonst den Port.
#include <IRremote.hpp>
#define IR_PIN 16 // VS1838 Signal an GPIO16
void setup() {
Serial.begin(115200);
delay(200);
IrReceiver.begin(IR_PIN, ENABLE_LED_FEEDBACK); // Start IR-Empfang
Serial.println(„IR-Ready: Druecke eine Taste auf der Fernbedienung.“);
}
void loop() {
if (IrReceiver.decode()) {
// Kurzinfo + Rohcode in HEX ausgeben
IrReceiver.printIRResultShort(&Serial);
Serial.print(“ Raw: 0x“);
Serial.println(IrReceiver.decodedIRData.decodedRawData, HEX);
// Für naechstes Signal bereit machen
IrReceiver.resume();
}
}
10. Farbiger LED Stick mit 8x WS2812
WS2812-LEDs sind adressierbare RGB-LEDs mit integriertem Controller. Alle 8 Pixel hängen hintereinander an einer Datenleitung und sind mit Pin 15 des ESP32 verbunden.
Warum reicht eine Leitung? Jede LED liest die ersten 24 Bit (R-G-B) aus dem seriellen Datenstrom, übernimmt diese für sich und leitet die restlichen Bits zur nächsten LED weiter (“Daisy-Chain”). So kann der Mikrocontroller alle Pixel nacheinander mit nur einem Pin steuern.
Achtung: Für diesen Sketch musst du vorher wieder eine Library installieren. Die Library lautet „Adafruit NeoPixel“.
#include <Adafruit_NeoPixel.h>
#define WS_PIN 15
#define NUM_LEDS 8
Adafruit_NeoPixel strip(NUM_LEDS, WS_PIN, NEO_GRB + NEO_KHZ800);
void setup() {
// Das Setup wird in diesem Sketch nicht verwendet.
}
void loop() {
strip.begin();
strip.setBrightness(80); // optional
strip.setPixelColor(0, strip.Color(255, 0, 0)); // Rot
strip.setPixelColor(1, strip.Color( 0, 255, 0)); // Grün
strip.setPixelColor(2, strip.Color( 0, 0, 255)); // Blau
strip.setPixelColor(3, strip.Color(255, 255, 0)); // Gelb
strip.setPixelColor(4, strip.Color( 0, 255, 255)); // Cyan
strip.setPixelColor(5, strip.Color(255, 0, 255)); // Magenta
strip.setPixelColor(6, strip.Color(255, 255, 255)); // Weiß
strip.setPixelColor(7, strip.Color(255, 128, 0)); // Orange
strip.show(); // Farben anzeigen
}
11. Luftfeuchtigkeit und Temperatur mit DHT11 messen
Der DHT11 Sensor misst Temperatur und Luftfeuchtigkeit und liefert die Werte digital über eine einzelne Datenleitung. Beim Funduino Smarthome wird dafür der Pin 14 des ESP32 verwendet.
Benötigte Libraries (IDE → Bibliotheken verwalten …):
DHT sensor library (Autor: Adafruit)
Adafruit Unified Sensor (Abhängigkeit)
#include <DHT.h>
#define DHTPIN 14 // Datenpin des DHT am ESP32
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
void setup() {
Serial.begin(115200);
dht.begin();
Serial.println(„DHT gestartet. Lese Temperatur & Feuchte…“);
}
void loop() {
float hum = dht.readHumidity();
float temp = dht.readTemperature(); // °C
if (isnan(hum) || isnan(temp)) {
Serial.println(„Fehler beim Lesen vom DHT!“);
} else {
Serial.print(„Temp: „);
Serial.print(temp, 1); // Die Zahl 1 bedeutet, dass eine Nachkommastelle angezeigt wird)
Serial.print(“ °C Feuchte: „);
Serial.print(hum, 1);
Serial.println(“ %“);
}
delay(2000); // DHT: max. ~0.5 Hz
}
Alternativ können die Messwerte auch auf dem OLED Display angezeigt werden. Hier ein Beispiel dazu:
#include <Wire.h>
#include <SSD1306Ascii.h>
#include <SSD1306AsciiWire.h>
#include <DHT.h>
#define DHTPIN 14
#define DHTTYPE DHT11 // ggf. zu DHT22 ändern
SSD1306AsciiWire oled;
DHT dht(DHTPIN, DHTTYPE);
void setup() {
Wire.begin(); // ESP32: SDA=21, SCL=22
oled.begin(&Adafruit128x64, 0x3C); // OLED-Adresse 0x3C
oled.setFont(System5x7);
oled.clear();
oled.println(„DHT -> OLED“);
dht.begin();
}
void loop() {
float hum = dht.readHumidity();
float temp = dht.readTemperature(); // °C
oled.clear();
oled.setCursor(0, 0);
if (isnan(hum) || isnan(temp)) {
oled.println(„Fehler beim Lesen!“);
} else {
oled.println(„Funduino“);
oled.setCursor(0, 2);
oled.print(„Temp: „);
oled.print(temp, 1);
oled.println(“ C“);
oled.setCursor(0, 3);
oled.print(„Feuchte: „);
oled.print(hum, 1);
oled.println(“ %“);
}
delay(2000); // DHT: ~0.5 Hz
}
12. Lichtstärke mit dem LDR messen
Ein LDR (Fotowiderstand) ändert seinen Widerstand mit der Helligkeit: hell → kleiner Widerstand, dunkel → großer Widerstand. Über einen Spannungsteiler mit einem festen Widerstand, der schon auf der Platine verbaut ist, erhältst du am Pin 35 eine messbare Spannung zwischen 0 V und 3,3 V.
Der folgende Sketch sendet die Messwerte des LDR an den Seriellen Monitor.
Wenn man den Sensor während der Messung ein wenig abdeckt, etwa den Finger daraufhält, erkennt man deutlich eine Abweichung in den Messwerten. Später kann man den Messwert verwenden, um automatisch die Beleuchtung mithilfe der WS2812 LEDs zu aktivieren.
#define LDR_PIN 35 // Pin 35 am ESP32
void setup() {
Serial.begin(115200);
}
void loop() {
int raw = analogRead(LDR_PIN); // Unter dem Wert raw wird der „rohe“ Messwert als Zahlenwert zwischen 0 und 4095 gespeichert.
int pct = map(raw, 0, 4095, 0, 100); // Mit dem MAP-Befehl wandeln wir den Wert in einen Prozentualen Wert um.
Serial.print(„LDR raw: „);
Serial.print(raw);
Serial.print(“ Helligkeit: „);
Serial.print(pct);
Serial.println(“ %“);
delay(200);
}
13. Bewegungsmelder PIR SR602
Ein PIR-Sensor (Passive Infrared) wie der SR602 erkennt schnelle Änderungen der Wärmestrahlung im Sichtfeld (z. B. wenn ein Mensch vorbeigeht). Im Inneren sitzen pyroelektrische Elemente hinter einer Fresnel-Linse. Erkennt der Sensor Bewegung, setzt er sein OUT-Signal auf HIGH und hält es für eine kurze Zeit bei.
Im folgenden Sketch programmieren wir eine kleine Alarmanlage. Wenn der PIR-Sensor eine Bewegung erkennt, soll die rote LED aufleuchten.
#define PIR_PIN 13
#define LED_RED 25
void setup() {
pinMode(PIR_PIN, INPUT); // SR602 liefert aktives HIGH
pinMode(LED_RED, OUTPUT);
digitalWrite(LED_RED, LOW);
}
void loop() {
int motion = digitalRead(PIR_PIN);
if (motion == HIGH) {
digitalWrite(LED_RED, HIGH); // Alarm: Bewegung erkannt
} else {
digitalWrite(LED_RED, LOW); // keine Bewegung
}
}
14. Servo / automatische Türöffnung
Was ist ein Servo (SG90) und wie funktioniert er?
Ein Servo ist ein kleiner Stellmotor mit Getriebe und Positionsrückmeldung (Potentiometer). Die Zielposition wird per Steuersignal vorgegeben. Im Gegensatz zu regulären Motoren kann sich ein Servo nicht im Kreis drehen, sondern bewegt sich nur in einem Bereich von ca. 180°.
Bei unserem Smarthome wird der Servo verwendet, um die Eingangstür automatisch zu öffnen. Dafür müssen später verschiedene Module kombiniert werden. Die Tür kann zum Beispiel öffnen, wenn ein Taster gedrückt wurde, oder wenn der Ultraschall-Entfernungssensor eine Person vor dem Eingang erkennt.
Der SG90 wird mit 3.3V versorgt und kann wie alle Servos kurzzeitig relativ viel Strom ziehen. Daher kann es sein, dass die LEDs flackern, wenn sich der Servomotor bewegt.
Die Sache mit der Tür. Die Tür wird erst nach dieser Anleitung eingebaut, denn der Servo muss elektronisch in eine passende Position gefahren werden, damit sich die Tür nicht in einem beliebigen Bereich bewegt, oder sogar an den Seiten anstößt.
Der Servo muss auf 90° eingestellt werden, wenn die Tür montiert wird.
#include <ESP32Servo.h>
#define SERVO_PIN 12
Servo servo;
void setup() {
servo.attach(SERVO_PIN);
}
void loop() {
servo.write(0); delay(1000); // 0°
servo.write(90); delay(1000); // 90°
servo.write(180); delay(1000); // 180°
servo.write(90); delay(1000); // zurück auf 90°
}
15. Gassensor MG135
Der MQ135 ist ein gassensitiver Widerstand (SnO₂) mit Heizer. Daher wird der Sensor auch warm und ist nicht an die 3,3V-Leitung angeschlossen, sondern an die 5V-Spannungsversorgung des USB-Kabels, da hier etwas mehr Leistung benötigt wird. Gase wie CO₂, NH₃, Alkohole u. a. verändern seinen Widerstand. Auf dem Funduino Smarthome bildet er mit einem Lastwiderstand einen Spannungsteiler. Am Ausgangspin des MQ135-Moduls liegt eine analoge Spannung an, die du mit dem ESP32 ausliest.
Wichtig:
Aufwärmzeit: Der Sensor benötigt ein paar Minuten um aufzuheizen, die Messwerte stabilisieren sich erst dann. Dennoch funktioniert der Sensor für eine grobe Messwertbestimmung unmittelbar nach dem Einschalten.
Werte sind relativ (Luftqualitätstendenz). Exakte Werte erfordern Kalibrierung, Temp/Feuchte-Korrektur und den Abgleich von Datenblattkurven. Eine so detaillierte Auswertung ist für unseren modellhaften Zweck nicht vorgesehen.
Anwendungsbeispiel beim Funduino Smarthome.
In unserer „Werkstatt“ soll der Sensor erkennen, wenn Gase auftreten. Zum Beispiel durch ausgelaufenes Benzin oder austretende Gase eines Fahrzeugs mit Auto- oder Erdgasantrieb, oder aber auch durch austretendes Gas von einem Schweißbrenner. Diese Gase lassen sich gut simulieren, indem man ganz geringe Mengen Gas aus einem Feuerzeug in das Gehäuse leitet. Es reicht aus, das Gas nur 2 Sekunden mithilfe des Lüfters in das Innere zu leiten. Der Lüfter kann dazu mit dem Taster manuell aktiviert werden.
Im folgenden Sketch wird der Sensorwert ausgelesen und mithilfe des Seriellen Monitors angezeigt.
#define MQ135_PIN 34
int messwert = 0;
int prozent = 0;
void setup() {
Serial.begin(115200);
delay(200);
Serial.println(„MQ135 Start – bitte einige Minuten aufwaermen lassen“);
}
void loop() {
messwert = analogRead(MQ135_PIN);
// grobe 0..100%-Skalierung (nur als Tendenz!)
int prozent = map(messwert, 0, 4095, 0, 100);
Serial.print(„MQ135 messwert: „);
Serial.print(messwert);
Serial.print(“ Tendenz: „);
Serial.print(prozent);
Serial.println(“ %“);
delay(500);
}
16. Tropfensensor
Die Sensorplatine des Tropfensensors / Feuchtigkeitssensors hat freiliegende Leiterbahnen. Trifft Feuchtigkeit darauf, leitet diese Feuchtigkeit einen winzigen elektrischen Strom zwischen den Bahnen und der Widerstand sinkt. Das Modul gibt dann am Signalausgang eine zur Nässe proportionale Spannung aus und leitet diese an den Pin 36 des ESP32 weiter.
Anwendungsbeispiel im Funduino Smarthome:
Der Sensor soll erkennen, ob auf dem Boden der Werkstatt Flüssigkeiten vorhanden sind. So kann detektiert werden, ob in der Werkstatt Flüssigkeiten auslaufen, oder gar ein Rohrbruch vorhanden ist.
Zum Testen des Sensors genügt es, einen leicht angefeuchteten Finger auf den Sensor zu drücken.
Unser Beispielsketch zeigt den Messwert im Seriellen Monitor an.
Bei geringer Feuchtigkeit soll die grüne LED leuchten.
Bei hoher Feuchtigkeit soll die rote LED leuchten.
#define Tropfen_PIN 36 // Tropfensensor analog
#define LED_ROT 25
#define LED_GRUEN 26
void setup() {
Serial.begin(115200);
pinMode(LED_ROT, OUTPUT);
pinMode(LED_GRUEN, OUTPUT);
}
void loop() {
int raw = analogRead(Tropfen_PIN); // 0..4095
int Prozent = map(raw, 0, 4095, 0, 100); // grobe Naesse in %
// LEDs schalten
if (raw > 100) { // Schwellwert
digitalWrite(LED_ROT, HIGH);
digitalWrite(LED_GRUEN, LOW);
} else {
digitalWrite(LED_ROT, LOW);
digitalWrite(LED_GRUEN, HIGH);
}
// Ausgabe
Serial.print(„RAW: „);
Serial.print(raw);
Serial.print(“ Nässe in Prozent: „);
Serial.print(Prozent);
Serial.println(“ %“);
delay(200);
}
Heute schon gespart?