Ratgeber · 9 Min. Lesezeit

ESP32 Projekte für Anfänger: 20 Ideen von leicht bis schwer

20 ESP32 Projekte für Anfänger: von der Onboard-LED und dem Webserver über NTP-Uhr und DHT22-Webseite bis zum Telegram-Alarm; Bauteile, Zeit, Bibliotheken.

Wer ESP32 Projekte für Anfänger sucht, tappt am leichtesten in eine Falle: am ersten Tag gleich eine Alarmanlage mit Telegram-Benachrichtigung bauen zu wollen und dann gleichzeitig mit Kabeln, Treibern, WLAN und Bibliotheken zu kämpfen. Die 20 Projekte in dieser Anleitung sind von leicht nach schwer sortiert, und jedes fügt dem vorherigen genau eine neue Sache hinzu. Zuerst lässt du die eingebaute LED blinken, dann kommen Taster, Sensoren und Displays dazu, danach verbindest du dich mit dem WLAN und baust Seiten, die du vom Handy aus steuerst, und zum Schluss Geräte, die Daten aus dem Internet holen, Benachrichtigungen schicken und monatelang mit einem Akku laufen.

Die Projekte sind in vier Stufen aufgeteilt und stehen alle in einer Tabelle, damit du Bauteile, ungefähre Dauer und Bibliothek auf einen Blick siehst. Unter jeder Stufe erfährst du, was jedes Projekt dir beibringt, auf welche Pins du achten musst und in welchen Artikeln die ausführliche Anleitung steht. Den Code von drei Projekten findest du direkt auf dieser Seite: LED mit Touch-Pin, NTP-Internetuhr und DHT22-Temperatur-Webseite.

ESP32-DevKit-Entwicklungsboard
ESP32 DevKit: Dual-Core-Board mit WLAN und Bluetooth; alle 20 Projekte dieser Liste entstehen mit diesem einen Board.

Bevor du anfängst: Einrichtung und Grundregeln

  • Arduino IDE und ESP32-Paket: Installiere über den Boardverwalter das Paket esp32 von Espressif und wähle als Board ESP32 Dev Module; die Schritte stehen im Artikel Arduino IDE installieren.
  • Kein Port sichtbar: Tausche zuerst das Kabel und installiere dann den Treiber für den USB-Chip deines Boards (CP2102 oder CH340); Details im Artikel CH340 Treiber installieren.
  • Die 3,3-V-Regel: Die Pins des ESP32 arbeiten mit 3,3 V und vertragen keine 5 V. Bei Sensoren mit 5-V-Ausgang gehört ein Spannungsteiler dazwischen.
  • Sichere Pins: GPIO 6 bis 11 hängen am Flash-Speicher, GPIO 34 bis 39 sind reine Eingänge. Die Belegung deines Boards zeigt das Werkzeug Pinout.
  • WLAN: Der ESP32 verbindet sich nur mit 2,4-GHz-Netzen; 5-GHz-Netze sieht er nicht.
  • Stromversorgung: Beim Einschalten des WLANs zieht das Board kurzzeitig bis zu 250 mA; ein schlechtes Kabel oder ein schwacher Port lässt es ständig neu starten. Die Lösung steht im Artikel ESP32 Brownout.

Alle 20 ESP32 Projekte in einer Tabelle

#ProjektBauteileZeitBibliothek
1Eingebaute LED blinken lassenNur der ESP3210 minKeine
2LED mit Taster (Tastend und Umschalten)Taster, LED, 220 Ω20 minKeine
3Ampel3 LEDs, 3 × 220 Ω20 minKeine
4LED mit PWM dimmenLED, 220 Ω20 minKeine (LEDC ist im Core)
5LED mit Touch-PinEin Jumperkabel15 minKeine
6Nachtlicht mit LDRLDR, 10 kΩ, LED30 minKeine
7LED-Helligkeit mit Potentiometer10-kΩ-Potentiometer, LED30 minKeine
8Entfernungsmesser mit HC-SR04HC-SR04, Widerstände 1 kΩ und 2 kΩ40 minKeine
9Thermometer mit DHT22 und I2C-LCDDHT22, 16x2-I2C-LCD45 minDHT sensor library, LiquidCrystal_I2C
10Automatisches Licht mit PIRHC-SR501, LED oder Relais30 minKeine
11Mit dem WLAN verbinden und die IP anzeigenNur der ESP3215 minWiFi (Core)
12LED vom Handy aus steuernLED, 220 Ω30 minWiFi, WebServer (Core)
13NTP-InternetuhrNur der ESP32 (OLED optional)30 minWiFi, time.h (Core)
14DHT22-Temperatur-WebseiteDHT2245 minDHT sensor library, WebServer
15RGB-Farbwähler auf dem HandyRGB-LED, 3 Widerstände45 minWebServer (Core)
16Wetteranzeige0,96-Zoll-OLED1 StundeHTTPClient, ArduinoJson, Adafruit SSD1306
17Live-Bedienfeld mit WebSocket2 Taster, LED1 StundeESPAsyncWebServer, AsyncTCP
18Bewegungsalarm mit TelegramHC-SR501, Summer1 StundeUniversalTelegramBot, ArduinoJson
19Akku-Sensor mit Deep SleepDHT22, 18650-Zelle, TP40561 Stundeesp_sleep (Core)
20Code kabellos per OTA hochladenNur der ESP3230 minArduinoOTA (Core)
Für fast alle 20 Projekte reicht eine einzige Einkaufsliste: ESP32 DevKit, Steckbrett, Jumperkabel, ein paar LEDs, Widerstände mit 220 Ω, 1 kΩ, 2 kΩ und 10 kΩ, zwei Taster, ein LDR, ein Potentiometer, eine RGB-LED, ein DHT22, ein HC-SR04, ein PIR-Sensor HC-SR501, ein 16x2-I2C-LCD, ein 0,96-Zoll-OLED und ein aktiver Summer. Kaufst du alles auf einmal, gehst du von einem Projekt zum nächsten, ohne auf Teile zu warten.

Stufe 1: Erste Schritte ohne WLAN (1–5)

Die ersten fünf Projekte dienen dazu, den ESP32 kennenzulernen, und keines nutzt WLAN. In Projekt 1 lässt du die blaue LED blinken, die bei den meisten DevKits an GPIO 2 hängt, und siehst, dass pinMode, digitalWrite und delay genauso funktionieren wie beim Arduino. In Projekt 2 schließt du einen Taster zwischen GPIO 4 und GND an und nutzt INPUT_PULLUP; in der Umschalt-Variante lernst du, das Prellen des Tasters (Debounce) zu lösen, ausführlich im Artikel Taster am Arduino anschließen. Projekt 3 schaltet drei LEDs nacheinander und bringt dir bei, in Zeiten und Zuständen zu denken. In Projekt 4 lässt du mit LEDC, der PWM-Einheit des ESP32, eine LED langsam auf- und abblenden, als würde sie atmen; hier merkst du, dass sich die Funktionen im Core 3.x geändert haben, die Grundlagen stehen im Artikel Was ist PWM.

Projekt 5 zeigt die erste Funktion, die den ESP32 vom Arduino Uno abhebt: Touch-Pins. Zehn Pins des ESP32 können die winzige Kapazitätsänderung messen, die ein Finger bei der Berührung verursacht; GPIO 4, auch T0 genannt, ist einer davon. Steck einfach ein Jumperkabel in den Pin und berühre sein Ende. Im Seriellen Monitor siehst du ohne Berührung Werte um 60 bis 80 und mit Berührung um 10 bis 20; die Schwelle dazwischen zu legen genügt. Die übrigen Touch-Pins und stabile Messverfahren erklärt der Artikel ESP32 Touch-Pins.

C++ (Arduino IDE)
1// Proje 5: ESP32 dokunmatik pin ile LED / project 5: LED with an ESP32 touch pin
2const int TOUCH_PIN = T0;        // T0 = GPIO 4
3const int LED_PIN = 2;           // çoğu DevKit'te dahili LED / onboard LED on most DevKits
4const int THRESHOLD = 30;        // Seri Monitör'deki değere göre ayarla / tune to the Serial Monitor value
5
6void setup() {
7  Serial.begin(115200);
8  pinMode(LED_PIN, OUTPUT);
9}
10
11void loop() {
12  int value = touchRead(TOUCH_PIN);    // dokununca değer düşer / the value drops when touched
13  Serial.println(value);
14  digitalWrite(LED_PIN, value < THRESHOLD ? HIGH : LOW);
15  delay(100);
16}

Stufe 2: Sensoren und Displays (6–10)

In der zweiten Stufe nutzt du die analogen Eingänge des ESP32 und Sensoren. Der ADC des ESP32 hat 12 Bit: analogRead liefert Werte von 0 bis 4095 und misst damit viermal feiner als der Bereich 0–1023 des Arduino. In Projekt 6 schließt du den LDR mit einem 10-kΩ-Widerstand als Spannungsteiler an und schaltest die LED ein, wenn es dunkel wird (LDR-Lichtsensor). In Projekt 7 rechnest du den Potentiometerwert 0–4095 mit map in PWM um und stellst damit die LED-Helligkeit ein (Was ist ein Potentiometer).

In Projekt 8 misst du mit dem HC-SR04 Entfernungen; da der Sensor mit 5 V arbeitet, musst du den ECHO-Pin mit einem Teiler aus 1 kΩ und 2 kΩ auf 3,3 V herunterholen (Ultraschallsensor HC-SR04). Projekt 9 ist ein echtes Thermometer, das Temperatur und Luftfeuchtigkeit des DHT22 auf einem 16x2-I2C-LCD anzeigt (DHT11 und DHT22, I2C-LCD-Display). In Projekt 10 schaltet der PIR-Sensor HC-SR501 bei Bewegung eine LED oder über ein Relais eine Lampe ein; sein Ausgang liefert bereits 3,3 V und wird direkt angeschlossen (PIR-Bewegungsmelder).

Sensor oder ModulESP32-PinHinweis
LDR (Teiler mit 10 kΩ)GPIO 34ADC1-Pin, nur Eingang
Potentiometer (Schleifer)GPIO 35ADC1-Pin, Enden an 3V3 und GND
HC-SR04 TRIG / ECHOGPIO 5 / GPIO 18ECHO mit Teiler aus 1 kΩ und 2 kΩ auf 3,3 V
DHT22 DatenGPIO 4Ohne Modulplatine einen 10-kΩ-Pull-up ergänzen
I2C-LCD SDA / SCLGPIO 21 / GPIO 22LCD an 5V (VIN); am sichersten mit Pegelwandler
Ausgang des HC-SR501GPIO 273,3-V-Ausgang, direkt anschließen
Gewöhn dir von Anfang an, analoge Sensoren an die ADC1-Pins (GPIO 32 bis 39) anzuschließen. Die ADC2-Pins (GPIO 0, 2, 4, 12 bis 15 und 25 bis 27) können bei eingeschaltetem WLAN nicht analog messen; ein LDR-Projekt, das in Stufe 2 bestens läuft, liefert in Stufe 3 Unsinn, sobald WLAN dazukommt.

Stufe 3: Die ersten Schritte mit WLAN (11–15)

Die dritte Stufe öffnet die eigentliche Stärke des ESP32. In Projekt 11 verbindest du dich mit deinem Heimnetz und gibst die IP-Adresse, die der Router vergibt, im Seriellen Monitor aus; klappt die Verbindung nicht, findest du die Ursachen Punkt für Punkt im Artikel ESP32 verbindet sich nicht mit dem WLAN. In Projekt 12 wird der ESP32 zum kleinen Webserver, und du schaltest die LED mit zwei Knöpfen auf einer Seite, die du im Browser deines Handys öffnest; der komplette Code steht im Artikel Was ist der ESP32. Projekt 13 holt die echte Uhrzeit aus dem Internet: Der ESP32 fragt NTP-Server, berechnet Zeitzone und Sommerzeit selbst, und ein RTC-Modul brauchst du nicht mehr.

C++ (Arduino IDE)
1// Proje 13: NTP ile internet saati / project 13: internet clock with NTP
2#include <WiFi.h>
3#include <time.h>
4
5const char* WIFI_SSID = "AgAdi";        // Wi-Fi adın / your Wi-Fi name
6const char* WIFI_PASS = "Sifre123";     // Wi-Fi şifren / your Wi-Fi password
7
8// Saat dilimi (POSIX) / time zone (POSIX):
9// Orta Avrupa / Central Europe: "CET-1CEST,M3.5.0,M10.5.0/3"
10// Türkiye: "<+03>-3"   México: "CST6"   Argentina: "<-03>3"   UK: "GMT0BST,M3.5.0/1,M10.5.0"
11const char* TZ_INFO = "CET-1CEST,M3.5.0,M10.5.0/3";
12
13void setup() {
14  Serial.begin(115200);
15  WiFi.begin(WIFI_SSID, WIFI_PASS);
16  while (WiFi.status() != WL_CONNECTED) {
17    delay(500);
18    Serial.print(".");
19  }
20  Serial.println();
21  configTzTime(TZ_INFO, "pool.ntp.org", "time.google.com");   // saati internetten al / get the time online
22}
23
24void loop() {
25  struct tm now;
26  if (getLocalTime(&now)) {
27    char text[32];
28    strftime(text, sizeof(text), "%d.%m.%Y %H:%M:%S", &now);
29    Serial.println(text);
30  } else {
31    Serial.println("Saat bekleniyor / waiting for time");
32  }
33  delay(1000);
34}

Die Zeile TZ_INFO im Code legt die Zeitzone im POSIX-Format fest, inklusive der Umstellung auf Sommerzeit; für Deutschland, Österreich und die Schweiz passt die Voreinstellung für Mitteleuropa bereits. configTzTime baut die Verbindung zu den NTP-Servern im Hintergrund auf, und getLocalTime gibt false zurück, solange die Zeit noch nicht da ist; die Meldung "waiting" in den ersten Sekunden ist also normal. Um die Uhrzeit auf einem OLED oder LCD anzuzeigen und einen Wecker einzurichten, geht es im Artikel ESP32 NTP-Uhr weiter.

Projekt 14 verbindet Stufe zwei und drei: Du zeigst Temperatur und Luftfeuchtigkeit des DHT22 auf einer Webseite, die jedes Handy im selben Netz öffnen kann. Die Seite lädt sich alle fünf Sekunden neu; der DHT22 mag es nicht, öfter als alle zwei Sekunden abgefragt zu werden, daher passt dieses Tempo auch zum Sensor. In Projekt 15 stellst du die Farbe einer RGB-LED mit dem Farbwähler des Handys ein; die Umrechnung von HEX in RGB und die Gammakorrektur erklärt Schritt für Schritt der Artikel ESP32 RGB LED Webserver.

Temperatur- und Feuchtesensor DHT22
DHT22: misst die Temperatur auf 0,5 °C und die Luftfeuchtigkeit auf 2 bis 5 % genau; er ist der gemeinsame Sensor der Projekte 9, 14 und 19.
C++ (Arduino IDE)
1// Proje 14: DHT22 sıcaklık ve nemi web sayfasında göster
2// Project 14: show DHT22 temperature and humidity on a web page
3#include <WiFi.h>
4#include <WebServer.h>
5#include <DHT.h>
6
7const char* WIFI_SSID = "AgAdi";        // Wi-Fi adın / your Wi-Fi name
8const char* WIFI_PASS = "Sifre123";     // Wi-Fi şifren / your Wi-Fi password
9const int DHT_PIN = 4;                  // DHT22 veri pini / DHT22 data pin
10
11DHT dht(DHT_PIN, DHT22);
12WebServer server(80);
13
14void handleRoot() {
15  float t = dht.readTemperature();
16  float h = dht.readHumidity();
17  String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>"
18                "<meta name='viewport' content='width=device-width'>"
19                "<meta http-equiv='refresh' content='5'>"      // 5 saniyede bir yenile / refresh every 5 s
20                "<title>ESP32 DHT22</title></head>"
21                "<body style='font-family:sans-serif;text-align:center'>";
22  if (isnan(t) || isnan(h)) {
23    html += "<h2>Sensör okunamadı / sensor read failed</h2>";
24  } else {
25    html += "<h1>" + String(t, 1) + " &deg;C</h1>";
26    html += "<h2>" + String(h, 0) + " %</h2>";
27  }
28  html += "</body></html>";
29  server.send(200, "text/html", html);
30}
31
32void setup() {
33  Serial.begin(115200);
34  dht.begin();
35  WiFi.begin(WIFI_SSID, WIFI_PASS);
36  while (WiFi.status() != WL_CONNECTED) {
37    delay(500);
38    Serial.print(".");
39  }
40  Serial.println();
41  Serial.println(WiFi.localIP());       // bu adresi tarayıcıda aç / open this address in a browser
42  server.on("/", handleRoot);
43  server.begin();
44}
45
46void loop() {
47  server.handleClient();
48}
Der Router kann dem ESP32 bei jedem Start eine andere IP-Adresse geben. Damit das Lesezeichen auf dem Handy gleich bleibt, reserviere in den Router-Einstellungen eine feste IP für die MAC-Adresse des ESP32 (DHCP-Reservierung), oder gib dem Gerät mit der Bibliothek ESPmDNS einen Namen wie esp32.local.

Stufe 4: Internet, Benachrichtigungen und Akku (16–20)

In der letzten Stufe spricht der ESP32 nicht nur mit deinem Heimnetz, sondern mit dem Internet. In Projekt 16 schickst du mit HTTPClient eine Anfrage an einen Wetterdienst, wertest die JSON-Antwort mit ArduinoJson aus und zeigst die Temperatur auf einem OLED-Display (ESP32 Wetter-API). In Projekt 17 baust du ein Live-Bedienfeld, das ohne Neuladen der Seite funktioniert: Dank WebSocket ändert sich der Zähler auf dem Handy in dem Moment, in dem du den Taster am Board drückst (ESP32 WebSocket).

Projekt 18 ist eine Alarmanlage: Erkennt der PIR eine Bewegung, piept der Summer und auf deinem Handy landet eine Telegram-Nachricht; die Einrichtung des Bots steht im Artikel ESP32 Telegram-Bot. In Projekt 19 lernst du den Deep Sleep kennen: Das Board wacht alle zehn Minuten auf, misst und schläft wieder ein. Der nackte ESP32-Chip zieht im Deep Sleep etwa 10 µA; auf DevKit-Boards verbrauchen Spannungsregler und USB-Chip weiter einige mA, die echte Akkulaufzeit hängt also vom Board ab (ESP32 Deep Sleep). Projekt 20 zeigt, wie du Code ohne USB-Kabel per WLAN hochlädst (OTA); so aktualisierst du ein Gerät an der Decke oder im Garten, ohne es abzubauen (ESP32 OTA-Update).

Mit welchem Projekt solltest du anfangen?

Deine AusgangslageBeginne mitDanach weiter mit
Du hast noch nie etwas mit Elektronik gemacht1, 2 und 36 und 7
Du kennst Arduino, der ESP32 ist neu für dich4 und 511, 12 und 13
Du hast nur den ESP32, keine weiteren Teile1, 5, 11 und 1320
Du bereitest eine Schulaufgabe oder ein Jugend-forscht-Projekt vor9 und 1418 und 19
Dich interessiert Hausautomation10 und 1217, danach MQTT

Nach den 20 Projekten: die nächsten Schritte

  • ESP-NOW: Lass zwei ESP32 ohne Router über Hunderte Meter miteinander sprechen (ESP-NOW).
  • Bluetooth Low Energy: Tausche per BLE Daten mit dem Handy aus (ESP32 Bluetooth BLE).
  • Home Assistant: Binde deine Sensoren per MQTT in dein Smart Home ein (ESP32, MQTT und Home Assistant).
  • WiFiManager: Statt Netzname und Passwort in den Code zu schreiben, nutzt du eine Einrichtungsseite, die du am Handy ausfüllst (ESP32 WiFiManager).
  • Datenlogger: Schick deine Messwerte an Google Sheets und mach ein Diagramm daraus (ESP32 und Google Sheets).
  • Zwei Kerne: Lass mit FreeRTOS-Tasks das WLAN auf einem Kern und die Messungen auf dem anderen laufen (ESP32 FreeRTOS).

Die häufigsten Anfängerfehler mit dem ESP32

  • GPIO 6 bis 11 verwenden: Diese Pins hängen am Flash-Speicher des Boards; nutzt du sie, startet das Board nicht oder stürzt ab.
  • Ein 5-V-Signal direkt an einen Pin legen: 5-V-Ausgänge wie ECHO beim HC-SR04 mit einem Teiler auf 3,3 V herunterholen.
  • ADC2-Pin in einem WLAN-Projekt: Den analogen Sensor auf die ADC1-Pins GPIO 32 bis 39 umziehen.
  • Langes delay im Webserver: Ein delay(5000) in loop lässt die Seite fünf Sekunden unbeantwortet; Zeitsteuerung mit millis lösen.
  • Fehler "Failed to connect": Beim Start des Uploads die BOOT-Taste gedrückt halten; die dauerhafte Lösung steht im Artikel ESP32 Failed to Connect.
  • Alten Code aus dem Netz kopieren: Im ESP32-Core 3.x haben sich die Funktionen für LEDC und Timer geändert; PWM-Code von 2020 kompiliert womöglich nicht.

Nutze diese Liste als Fahrplan: Hast du ein Projekt geschafft, hak seine Zeile in der Tabelle ab und nimm dir das nächste vor. In der BlueGrays-App findest du die meisten dieser ESP32-Projekte, von der eingebauten LED bis zum Telegram-Alarm, Schritt für Schritt mit Schaltplan, Bauteilliste und fertigem Code; wenn du hängen bleibst, schau im passenden Artikel nach den Details.

Häufige Fragen

Welches Projekt sollte man als Erstes mit dem ESP32 machen?

Der beste Einstieg ist das Blinken der eingebauten LED an GPIO 2: Es braucht keine Bauteile und zeigt, dass die Einrichtung stimmt. Danach geht es mit LED und Taster sowie einer per PWM gedimmten LED weiter; zum WLAN wechselst du erst, wenn diese Grundprojekte problemlos laufen.

Ist der ESP32 für Anfänger geeignet?

Ja. Der ESP32 wird mit der Arduino IDE und denselben Arduino-Funktionen programmiert, die meisten Arduino-Sketche laufen mit kleinen Änderungen. Die wichtigsten Unterschiede sind die 3,3-V-Pins, dass ADC2-Pins bei aktivem WLAN nicht analog messen, und dass GPIO 6 bis 11 tabu sind.

Welche Bauteile brauche ich für ESP32 Projekte?

Für den Anfang genügen ein ESP32 DevKit, ein Steckbrett, Jumperkabel, ein paar LEDs und Widerstände, ein Taster, ein LDR und ein Potentiometer. Mit DHT22, HC-SR04, PIR-Sensor, I2C-LCD und OLED-Display baust du fast alle 20 Projekte dieser Liste.

Funktioniert der ESP32 ohne Internet?

Ja. Die ersten zehn Projekte dieser Liste nutzen gar kein WLAN, und ohne Internet arbeitet der ESP32 wie ein sehr leistungsfähiger Arduino. Außerdem kann er ein eigenes WLAN aufspannen oder per ESP-NOW ohne Router mit anderen ESP32 kommunizieren.

ESP32 oder Arduino Uno: Womit sollen Anfänger starten?

Willst du Projekte mit WLAN, Bluetooth oder Handysteuerung, starte mit dem ESP32. Der Arduino Uno arbeitet mit 5 V und passt direkt zu vielen älteren Sensoren, was absoluten Anfängern weniger Überraschungen bereitet; am ESP32 brauchst du für 5-V-Sensoren einen Spannungsteiler.

ESP32 mit Arduino IDE oder MicroPython programmieren?

Die Beispiele dieser Liste nutzen die Arduino IDE, weil es dafür weit mehr Anleitungen und Bibliotheken gibt. MicroPython läuft auf dem ESP32 ebenfalls gut und lässt dich Code ohne Kompilieren ausprobieren; kennst du Python schon, ist es für einfache Projekte eine gute Wahl.

Alle Projekte ansehen
LED Blinken mit ESP32
ES-1Anfänger

LED Blinken mit ESP32

Lehrt die grundlegende Verwendung von GPIO-Ausgängen mit ESP32. Wir erreichen einen Blinkeffekt, indem wir eine LED über einen digitalen Pin ein- und ausschalten. ESP32-Version des klassischen Blink-Projekts auf Arduino UNO; die grundlegenden Blink-Befehle in der Arduino-Umgebung bleiben gleich, aber die Pinbelegung und die GPIO-Pegel von 3,3 V des ESP32 unterscheiden sich von denen des Arduino UNO.

4.7(37)
108
ESP32 Interne LED Blinken
ES-4Anfänger

ESP32 Interne LED Blinken

Die eingebaute blaue LED auf dem ESP32 DevKit V1 zum Blinken bringen. Keine externen Komponenten erforderlich! Das erste Projekt, das Sie ausprobieren sollten, wenn Sie einen ESP32 kaufen. GPIO 2 ist mit der internen LED verbunden.

4.8(29)
54
ESP32 LED-Steuerung mit Drucktaste (Push)
ES-2Anfänger

ESP32 LED-Steuerung mit Drucktaste (Push)

Die LED leuchtet auf, wenn die Taste gedrückt wird und geht aus, wenn sie losgelassen wird. Zeigt, wie der digitale Eingangspin des ESP32 und der interne Pull-up-Widerstand verwendet werden. Dank des INPUT_PULLUP-Modus ist kein externer Widerstand erforderlich.

4.6(36)
57
ESP32 Ampel
ES-5Anfänger

ESP32 Ampel

Simulation einer echten Ampel mit 3 rot-gelb-grünen LEDs. Die Zeiten sind nahe an der realen Verkehrslogik: rot lang, gelb kurz, grün lang. Klassisches Beispiel für sequenzielle GPIO-Steuerung.

4.4(22)
45
Messung der Lichtintensität mit dem ESP32-LDR-Modul
ES-11Anfänger

Messung der Lichtintensität mit dem ESP32-LDR-Modul

Echtzeit-Anzeige des ADC-Rohwerts des LDR-Moduls und des anhand von Dunkel- und Hellreferenzwerten berechneten relativen Lichtwerts in Prozent im Serial Monitor. Dieser Prozentwert ist keine Lux-Messung. Vermittelt die Kalibrierungslogik des Moduls. Sollte idealerweise vor Projekt 10 durchgeführt werden, da es zur Festlegung des Schwellenwerts dient.

4.6(36)
55
ESP32: Echtzeit aus dem Internet per NTP
ES-26Fortgeschritten
Premium

ESP32: Echtzeit aus dem Internet per NTP

Der ESP32 verbindet sich mit dem WLAN und holt die Uhrzeit millisekundengenau von NTP-Servern (Network Time Protocol). Mit configTzTime() gilt automatisch die türkische Zeitzone (TRT, UTC+3); in Ländern mit Sommerzeit regelt ein POSIX-TZ-String die Umstellung (DST) von selbst. Die Uhrzeit erscheint im Serial Monitor und auf einem optionalen I2C-LCD.

4.5(13)
22
ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
ES-27Fortgeschritten

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)

Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

4.8(16)
26
ESP32 Bewegungsalarmsystem (PIR + Buzzer + LED + Telegram)
ES-41Fortgeschritten
Premium

ESP32 Bewegungsalarmsystem (PIR + Buzzer + LED + Telegram)

Eine smarte Alarmanlage: Erkennt der PIR-Sensor eine Bewegung, ertönt der Summer, die LED leuchtet und der Besitzer bekommt sofort eine Telegram-Nachricht. Eine Sperrzeit von 30 Sekunden begrenzt, wie oft der Alarm wiederholt wird; Fehlauslösungen des PIR-Sensors verhindert sie nicht. Geeignet für Haus, Garage, Lager oder Arbeitszimmer.

9