Bauteile · 7 Min. Lesezeit

ESPDuino-32: Pinbelegung, Uno-Shields und erstes WLAN-Projekt

ESPDuino-32 erklärt: Pinbelegung mit Uno-Zuordnung, die 3,3-V-Falle, welche Shields nicht laufen, Boardauswahl in der Arduino IDE und erster WLAN-Sketch.

Der ESPDuino-32 ist ein Entwicklungsboard, das einen ESP32 in die Maße und die Pinanordnung eines Arduino Uno bringt: Von außen sieht er aus wie ein Uno, trägt aber einen Dual-Core-Prozessor mit 240 MHz, WLAN und Bluetooth. Das Design stammt von DOIT, ein fast identisches Board wird als WEMOS D1 R32 verkauft. In diesem Beitrag ordnen wir die Pinbelegung des ESPDuino-32 Pin für Pin den Uno-Pins zu, zeigen, welche Uno-Shields laufen und welche nicht, und erklären die Boardauswahl in der Arduino IDE.

Der große Reiz: Du steckst deine vorhandenen Uno-Shields auf und gibst deinem Projekt WLAN. Dabei lauert aber eine wichtige Falle: Der Uno arbeitet mit 5 V, alle Signalpins des ESPDuino-32 dagegen mit 3,3 V, und sie sind nicht 5-V-tolerant. Shields und Sensoren kennen diesen Unterschied nicht; mit der falschen Verbindung kannst du einen Pin oder sogar das ganze Board zerstören. Lernen wir das Board zuerst kennen.

ESPDuino-32 Entwicklungsboard
ESPDuino-32: ein ESP32-WROOM-32-Modul auf einem Board im Uno-Format, mit USB-Seriell-Chip, Hohlstecker-Buchse und Stiftleisten an derselben Stelle wie beim Uno.

Was ist der ESPDuino-32? Vergleich mit Uno und ESP32 DevKit

Im Herzen des ESPDuino-32 sitzt das Modul ESP32-WROOM-32, dasselbe wie auf klassischen ESP32-Boards. Softwareseitig ist er also ein ganz normaler ESP32: Alle Sketche und Bibliotheken für den ESP32 laufen darauf. Der Unterschied liegt im Board-Design: Die Pins sind auf Uno-Stiftleisten geführt, dazu kommen eine Hohlstecker-Buchse, ein 3,3-V-Spannungsregler und ein USB-Seriell-Wandler (meist ein CH340). Wenn du noch nie mit einem ESP32 gearbeitet hast, findest du die Grundlagen in Was ist der ESP32?

MerkmalArduino Uno R3ESPDuino-32ESP32 DevKit
ProzessorATmega328P, 8 Bit, 16 MHzESP32, Dual-Core, 240 MHzESP32, Dual-Core, 240 MHz
RAM2 KB520 KB520 KB
Flash32 KB4 MB4 MB
Logikpegel5 V3,3 V3,3 V
FunkKeinerWLAN + BluetoothWLAN + Bluetooth
Analoge Eingänge6 Kanäle, 10 Bit6 Kanäle an der Uno-Leiste, 12 BitBis zu 18 Kanäle, 12 Bit
Maße und Shields68,6 × 53,4 mm, Uno-ShieldsGleiche Maße wie der Uno, Shields passenPasst aufs Steckbrett, keine Shields
USB-ChipATmega16U2Meist CH340CP2102 oder CH340

Welches solltest du also kaufen? Wenn du Uno-Shields hast, das Board über die Uno-Befestigungslöcher in ein Gehäuse schrauben willst oder einem Buch oder Kurs für den Uno folgst, macht dir der ESPDuino-32 das Leben leichter. Arbeitest du auf dem Steckbrett, brauchst du ESP32-Pins, die nicht an der Uno-Leiste liegen, etwa GPIO 32 und 33, oder soll das Gerät klein sein, ist das klassische ESP32 DevKit die bessere Wahl. Der Code ist auf beiden gleich; nur die Pinnummern ändern sich.

ESPDuino-32 Pinbelegung: Welcher GPIO steckt hinter welchem Uno-Pin?

Auch wenn das Board wie ein Uno mit D2, D3 und A0 beschriftet ist, brauchst du im Code meist die GPIO-Nummer. Die Tabelle zeigt für jeden Uno-Pin den passenden ESP32-GPIO und worauf du achten musst. Die vollständige Pinliste des ESP32 findest du auch im Pinout-Tool.

Uno-PinESP32-GPIOStatusHinweis
D0 (RX)GPIO 3Nicht nutzenUSB-Seriell-Leitung
D1 (TX)GPIO 1Nicht nutzenUSB-Seriell-Leitung
D2GPIO 26SicherAuch als DAC2-Ausgang nutzbar
D3GPIO 25SicherAuch als DAC1-Ausgang nutzbar
D4GPIO 17SicherWird auch als Serial2 TX genutzt
D5GPIO 16SicherWird auch als Serial2 RX genutzt
D6GPIO 27SicherTouch-Eingang (T7)
D7GPIO 14Mit VorsichtGibt beim Booten kurz ein PWM-Signal aus
D8GPIO 12Mit VorsichtStrapping-Pin: Ist er beim Einschalten HIGH, startet das Board nicht
D9GPIO 13SicherAllgemeiner Ein- und Ausgang
D10GPIO 5Mit VorsichtSPI SS; gibt beim Booten kurz ein PWM-Signal aus
D11GPIO 23SicherSPI MOSI
D12GPIO 19SicherSPI MISO
D13GPIO 18SicherSPI SCK; anders als beim Uno keine LED
A0GPIO 2Mit VorsichtADC2 (misst nicht bei aktivem WLAN), eingebaute LED, Strapping-Pin
A1GPIO 4Mit VorsichtADC2 (misst nicht bei aktivem WLAN)
A2GPIO 35Nur EingangADC1, funktioniert zusammen mit WLAN
A3GPIO 34Nur EingangADC1, funktioniert zusammen mit WLAN
A4GPIO 36 (VP)Nur EingangADC1; nicht SDA wie beim Uno
A5GPIO 39 (VN)Nur EingangADC1; nicht SCL wie beim Uno
SDAGPIO 21SicherI2C-Datenleitung
SCLGPIO 22SicherI2C-Taktleitung
A4 und A5 sind hier kein I2C. Beim Uno sind A4 und A5 gleichzeitig SDA und SCL; beim ESPDuino-32 hängen sie an GPIO 36 und 39 und arbeiten nur als Eingänge. Für I2C-Displays und -Sensoren nimmst du die separaten Pins SDA (GPIO 21) und SCL (GPIO 22) neben AREF.

Auf der analogen Seite warten zwei weitere Fallen. Erstens gehören A0 (GPIO 2) und A1 (GPIO 4) zur ADC2-Einheit des ESP32, die bei aktivem WLAN nicht messen kann; in WLAN-Projekten schließt du analoge Sensoren an A2–A5 (ADC1) an. Zweitens hat der ADC des ESP32 12 Bit: analogRead() liefert 0–4095 statt 0–1023, und der Vollausschlag liegt bei etwa 3,3 V statt 5 V. Rechnungen wie "Wert × 5,0 / 1023" aus Uno-Sketchen musst du entsprechend ändern; noch besser nutzt du analogReadMilliVolts(), das ein kalibriertes Ergebnis in Millivolt liefert.

Die 3,3-V-Falle: Laufen Uno-Shields auf dem ESPDuino-32?

Dass ein Shield mechanisch passt, heißt noch nicht, dass es funktioniert. Ein Shield macht auf dem ESPDuino-32 auf drei Arten Ärger: Es schickt ein 5-V-Signal in den ESP32 und beschädigt den Pin, es erwartet 5-V-Logik und erkennt 3,3 V nicht immer als HIGH, oder es legt eine Aufgabe, die einen Ausgang braucht, auf die reinen Eingänge A2–A5. Weil der 5V-Pin wie beim Uno 5 V liefert, wird das Shield selbst versorgt; die Probleme zeigen sich immer an den Signalpins. So schlagen sich die verbreiteten Shields:

L293D-Motortreiber-Shield
L293D-Motorshield: Sein Schieberegister 74HC595 läuft mit 5 V und erkennt die 3,3-V-Signale des ESPDuino-32 nur knapp.
ShieldStatusGrund
CNC Shield V3 (A4988 / DRV8825)Läuft meistensSTEP und DIR liegen auf ausgangsfähigen GPIOs; GRBL-Versionen für den ESP32 bringen eine fertige Pinbelegung für dieses Board mit
Relais-ShieldLäuft meistensDie Relais hängen am 5V-Pin, und der Treibertransistor schaltet auch mit einem 3,3-V-Signal durch
Datenlogger-Shield (SD-Karte + RTC)TeilweiseEine SD-Karte an D10–D13 läuft, weil das die SPI-Pins des ESP32 sind; die RTC versagt, wenn ihr I2C nur an A4/A5 hängt
L293D-MotorshieldUnzuverlässigDer 74HC595 liest bei 5 V die 3,3-V-Eingänge nur knapp, und seine Datenleitung an D8 (GPIO 12) kann zusätzlich den Start verhindern
LCD-Keypad-ShieldRiskantDie Tasten kommen über eine Widerstandsleiter mit 5-V-Pull-up an A0, sodass an GPIO 2 ohne Tastendruck 5 V anliegen
Paralleles 2,4-Zoll-TFT-ShieldLäuft nichtDie Steuerleitungen liegen auf A0–A4; A2, A3 und A4 sind reine Eingänge und können das Display nicht ansteuern
Ältere Shields, die I2C nur über A4/A5 nutzenLäuft nichtBeim ESPDuino-32 liegt I2C auf den separaten SDA/SCL-Pins (GPIO 21/22)
Um ein Shield einzuschätzen, schau in seinen Schaltplan und stell zwei Fragen: Schickt es an irgendeinen Pin ein 5-V-Signal? Nutzt es einen der Pins A2–A5 als Ausgang? Lautet beide Male die Antwort nein, läuft es sehr wahrscheinlich. Liefert eine Leitung 5 V, setz einen Spannungsteiler oder einen Pegelwandler dazwischen.

Strapping-Pins: Vorsicht bei D8 und A0

Beim Einschalten prüft der ESP32 den Pegel einiger Pins, um zu entscheiden, wie er startet. Zwei davon liegen beim ESPDuino-32 an der Uno-Leiste. Ist D8 (GPIO 12) beim Booten HIGH, versucht der ESP32, seinen Flash mit der falschen Spannung zu starten, und das Board bootet nicht. A0 (GPIO 2) muss beim Hochladen offen oder LOW sein. Hast du an D8 ein Modul oder Shield mit Pull-up angeschlossen und das Board startet nicht, ist das dein erster Verdächtiger. D7 (GPIO 14) und D10 (GPIO 5) geben beim Booten außerdem kurz ein PWM-Signal aus; ein Relais an diesen Pins kann beim Einschalten kurz klacken.

ESPDuino-32 in der Arduino IDE einrichten und Board auswählen

  1. Installiere in der Arduino IDE das Boardpaket esp32 von Espressif; die Schritte stehen in Was ist der ESP32?
  2. Verbinde das Board per USB. Erscheint kein Port, installiere den Treiber für den USB-Chip (meist CH340) und prüfe, ob dein Kabel Daten überträgt.
  3. Wähle unter Werkzeuge > Board > esp32 den Eintrag WEMOS D1 R32: In dieser Definition passen die Namen D2–D13 und A0–A5 genau zur Beschriftung auf dem Board. DOIT ESPduino32 oder ESP32 Dev Module funktionieren auch, dann musst du aber ausschließlich GPIO-Nummern verwenden.
  4. Wähle den Port des Boards; schlägt das Hochladen mit einer Upload Speed von 921600 fehl, stell 115200 ein.
  5. Klicke auf Hochladen und öffne den Seriellen Monitor mit 115200 Baud. Geht das Board nicht in den Upload-Modus, helfen die Lösungen in ESP32 Failed to Connect.
Die Boardauswahl ändert die Bedeutung von A0. Ist ESP32 Dev Module gewählt, zeigt A0 in deinem Code auf GPIO 36, also auf den Pin, der auf dem ESPDuino-32 mit A4 beschriftet ist; bei DOIT ESPduino32 ist A0 je nach Core-Version gar nicht definiert, und der Compiler bricht mit einem Fehler ab. Am einfachsten umgehst du das Durcheinander, indem du im Code immer GPIO-Nummern schreibst.

Erster Test: eingebaute LED, D13 und ein Analogwert

Die blaue eingebaute LED des Boards hängt an GPIO 2, nicht wie beim Uno an D13. Der Sketch unten lässt die eingebaute LED und eine LED an D13 (GPIO 18) mit 220-Ω-Vorwiderstand abwechselnd leuchten und schreibt den Wert eines Potentiometers an A2 (GPIO 35) in den Seriellen Monitor. Schließ die äußeren Anschlüsse des Potentiometers an 3V3 und GND an, nicht an 5V; der Schleifer kommt an A2.

C++ (Arduino IDE)
1// ESPDuino-32: Uno adları yerine GPIO numaraları / GPIO numbers instead of Uno pin names
2const int ONBOARD_LED = 2;    // kart üstü mavi LED (A0 ile aynı pin) / onboard blue LED (same pin as A0)
3const int LED_D13 = 18;       // Uno D13 = GPIO 18
4const int POT_A2 = 35;        // Uno A2 = GPIO 35 (ADC1, yalnız giriş / input only)
5
6void setup() {
7  Serial.begin(115200);
8  pinMode(ONBOARD_LED, OUTPUT);
9  pinMode(LED_D13, OUTPUT);
10  analogReadResolution(12);                      // 0–4095 (varsayılan / default)
11}
12
13void loop() {
14  int raw = analogRead(POT_A2);                  // 0–4095, Uno'daki gibi 0–1023 değil / not 0–1023 like the Uno
15  int mv = analogReadMilliVolts(POT_A2);         // kalibre edilmiş mV / calibrated millivolts
16  Serial.printf("A2 ham / raw: %d  gerilim / voltage: %d mV\n", raw, mv);
17
18  digitalWrite(ONBOARD_LED, HIGH);               // LED'ler sırayla / LEDs take turns
19  digitalWrite(LED_D13, LOW);
20  delay(500);
21  digitalWrite(ONBOARD_LED, LOW);
22  digitalWrite(LED_D13, HIGH);
23  delay(500);
24}

Erstes WLAN-Projekt: LED vom Handy aus schalten

Jetzt zeigt das Board, was es wirklich vom Uno unterscheidet. Der Sketch unten verbindet den ESPDuino-32 mit deinem Heimnetz und startet einen kleinen Webserver. Tippst du die im Seriellen Monitor angezeigte IP-Adresse in den Browser eines Handys im selben Netz, siehst du einen Knopf, der die LED an D13 schaltet, und den Wert des Potentiometers an A2 in Millivolt. Das Potentiometer haben wir absichtlich an A2 gehängt: Bei aktivem WLAN können A0 und A1 keine Analogwerte messen.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* WIFI_SSID = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
5const char* WIFI_PASS = "Sifre123";       // Wi-Fi şifren / your Wi-Fi password
6
7const int LED_PIN = 18;                   // Uno D13 = GPIO 18
8const int POT_PIN = 35;                   // Uno A2 = GPIO 35 (ADC1: Wi-Fi ile çalışır / works with Wi-Fi)
9
10WebServer server(80);
11bool ledOn = false;
12
13String page() {
14  String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>";
15  html += "<meta name='viewport' content='width=device-width,initial-scale=1'>";
16  html += "<title>ESPDuino-32</title></head>";
17  html += "<body style='font-family:sans-serif;text-align:center'><h1>ESPDuino-32</h1>";
18  html += "<p>LED (D13): <b>" + String(ledOn ? "ON" : "OFF") + "</b></p>";
19  html += "<p><a href='/toggle'><button style='font-size:24px;padding:12px 32px'>LED</button></a></p>";
20  html += "<p>A2: " + String(analogReadMilliVolts(POT_PIN)) + " mV</p>";
21  html += "</body></html>";
22  return html;
23}
24
25void handleRoot() {
26  server.send(200, "text/html", page());
27}
28
29void handleToggle() {
30  ledOn = !ledOn;
31  digitalWrite(LED_PIN, ledOn ? HIGH : LOW);
32  server.sendHeader("Location", "/");      // ana sayfaya dön / back to the main page
33  server.send(303);
34}
35
36void setup() {
37  Serial.begin(115200);
38  pinMode(LED_PIN, OUTPUT);
39
40  WiFi.mode(WIFI_STA);
41  WiFi.begin(WIFI_SSID, WIFI_PASS);
42  Serial.print("Baglaniyor / Connecting");
43  while (WiFi.status() != WL_CONNECTED) {  // bağlanana kadar bekle / wait until connected
44    delay(500);
45    Serial.print(".");
46  }
47  Serial.println();
48  Serial.print("IP: ");
49  Serial.println(WiFi.localIP());          // bu adresi telefonda aç / open this address on your phone
50
51  server.on("/", handleRoot);
52  server.on("/toggle", handleToggle);
53  server.begin();
54}
55
56void loop() {
57  server.handleClient();                   // gelen istekleri işle / handle incoming requests
58}

Der Sketch legt zwei Adressen an: / liefert die Hauptseite, /toggle schaltet die LED um und leitet den Browser zurück zur Hauptseite. Bei jedem Neuladen wird das Potentiometer neu gelesen. Für eine Oberfläche, die sich ohne Neuladen live aktualisiert, nutzt du den Ansatz aus ESP32 Async Webserver und WebSocket. Verbindet sich das Board nicht, prüfe, ob dein Netz im 2,4-GHz-Band funkt; 5-GHz-Netze sieht der ESP32 nicht.

Stromversorgung: USB, Hohlstecker und 3V3-Pin

QuelleSpannungHinweis
USB5 VReicht für Entwicklung und kleine Schaltungen
Hohlstecker-BuchseMeist 7–12 V (Aufdruck auf deinem Board prüfen)Der Regler wird warm; 9 V bleiben kühler als 12 V
VIN-PinDie Spannung an der Hohlstecker-BuchseZum Versorgen des Boards aus einem externen Netzteil
5V-Pin5-V-AusgangVersorgt Shields und 5-V-Module; deren Signale auf 3,3 V absenken
3V3-Pin3,3-V-AusgangFür Sensoren; keine Motoren und keine langen LED-Streifen anschließen

Beim Senden über WLAN zieht der ESP32 kurzzeitig fast 250 mA. Ein schwaches USB-Kabel oder ein schwacher Port lässt die Spannung in diesen Momenten einbrechen, und das Board startet mit "Brownout detector was triggered" neu. Nimm dann ein kurzes, gutes Kabel oder versorge das Board über die Hohlstecker-Buchse; Details stehen in ESP32 Brownout und Guru Meditation.

Häufige Fehler und ihre Lösung

  • Ein Uno-Sketch funktioniert nicht: Die Pinnummern sind für den Uno geschrieben. pinMode(13, OUTPUT) steuert auf dem ESPDuino-32 GPIO 13 an, also D9 und nicht D13; schlag die GPIO-Nummer in der Tabelle nach.
  • analogRead liefert immer 4095 oder immer 0: Der Sensor hängt an 5 V und sein Ausgang überschreitet 3,3 V, oder er sitzt an einem ADC2-Pin (A0, A1), während WLAN läuft.
  • Das I2C-Display wird nicht erkannt: Es ist an A4/A5 angeschlossen; leg die Kabel an die SDA/SCL-Pins (GPIO 21/22) um.
  • Das Board startet nicht oder bootet ständig neu: Ein Bauteil an D8 (GPIO 12) zieht den Pin beim Einschalten auf HIGH; leg es an einen anderen Pin.
  • Mit aufgestecktem Shield wird das Board oder ein Bauteil warm: Das Shield schickt 5 V an einen Pin; zieh das Board sofort ab und senke die Leitung mit Spannungsteiler oder Pegelwandler ab.
  • SoftwareSerial oder die Servo-Bibliothek lassen sich nicht kompilieren: Nimm statt der AVR-Bibliotheken die ESP32-Varianten: die Hardware-Schnittstelle Serial2 und ESP32Servo.

Der ESPDuino-32 ist der vertrauteste Weg vom Uno zum ESP32: gleiche Maße, gleiche Stiftleisten, aber ein 15-mal höherer Takt und Funk. Halte Arduino Uno Pinbelegung griffbereit, um die Unterschiede im Blick zu behalten. Alle ESP32-Projekte der BlueGrays App laufen auch auf diesem Board; LED, Ampel, WLAN-Verbindung und Webserver kannst du Schritt für Schritt mit Schaltplan und Code nachbauen, du musst nur die Pins nach der Tabelle oben zuordnen.

Häufige Fragen

Ist der ESPDuino-32 dasselbe wie der WEMOS D1 R32?

Praktisch ja. Beide setzen ein ESP32-WROOM-32-Modul auf ein Board im Uno-Format, mit identischer Pinzuordnung an den Uno-Leisten. Die Arduino IDE hat für beide eigene Definitionen; die von WEMOS D1 R32 ist praktischer, weil sie die D- und A-Beschriftungen den richtigen GPIOs zuordnet.

Kann ich Arduino-Uno-Shields auf dem ESPDuino-32 verwenden?

Mechanisch passen sie, ob sie funktionieren, hängt vom Shield ab. Shields, die keine 5-V-Signale an den ESP32 schicken, A2–A5 nicht als Ausgänge nutzen und I2C nicht nur über A4/A5 beziehen, laufen meistens; LCD-Keypad- und parallele TFT-Shields funktionieren ohne Umbau nicht.

Läuft der ESPDuino-32 mit 5 V?

Das Board wird über USB oder den 5V-Pin mit 5 V versorgt und verträgt über die Hohlstecker-Buchse auch eine höhere Spannung. Die Signalpins arbeiten aber mit 3,3 V und sind nicht 5-V-tolerant; Sensoren mit 5-V-Ausgang brauchen einen Spannungsteiler oder Pegelwandler.

An welchem Pin hängt die eingebaute LED des ESPDuino-32?

Die blaue eingebaute LED hängt an GPIO 2, der auf dem Board zugleich als A0 herausgeführt ist. An D13 gibt es anders als beim Uno keine LED, und die Konstante LED_BUILTIN liefert den Wert 2.

Welches Board wähle ich in der Arduino IDE für den ESPDuino-32?

Wähle WEMOS D1 R32, wenn du im Code die Uno-Bezeichnungen wie D2 oder A0 nutzen willst. DOIT ESPduino32 oder ESP32 Dev Module laden den Code genauso hoch, dort musst du die Pins aber als GPIO-Nummern angeben.

Warum funktioniert analogRead auf meinem ESPDuino-32 nicht?

Meist hängt der Sensor an A0 oder A1, während WLAN aktiv ist; diese Pins gehören zum ADC2, der zusammen mit WLAN nicht messen kann. Leg den Sensor an A2–A5 (ADC1) und denk daran, dass das Ergebnis von 0 bis 4095 reicht und der Vollausschlag bei etwa 3,3 V liegt.

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 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: LED-Helligkeit mit Potentiometer (Analog → PWM)
ES-13Mittel
Premium

ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)

In diesem Projekt steuern wir die Helligkeit einer LED analog über ein Potentiometer. Der ADC-Pin des ESP32 liest die vom Potentiometer kommende Spannung von 0-3,3 V aus, woraufhin dieser Wert in ein PWM-Signal (Pulsweitenmodulation) umgewandelt und an die LED gesendet wird. So leuchtet die LED beim Drehen des Potentiometers stufenweise auf und erlischt wieder. Mit Arduino Core 3.0+ kann analogWrite() direkt verwendet werden; bei ESP32-S2/S3 ist die ADC-Auflösung auf 12 Bit festgelegt.

4.5(19)
32
ESP32-WLAN-STA-Verbindung (mit LCD-Display)
ES-25Fortgeschritten

ESP32-WLAN-STA-Verbindung (mit LCD-Display)

In diesem Projekt verbinden wir den ESP32 im Station-Modus (STA) sicher und fehlertolerant mit dem heimischen WLAN. Wir lagern SSID und Passwort in eine separate secrets.h-Datei aus, um Leaks zu Git zu verhindern, richten einen Auto-Reconnect-Mechanismus ein und zeigen RSSI-Signalpegel und IP-Adresse auf einem I2C-LCD-Display an. Die interne LED dient als Statusanzeige. Ein Verbindungsmanager auf Produktionsniveau.

4.4(21)
38
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 mDNS: Zugriff auf das Gerät über „bluegrays-esp.local“ (mit LCD-Display)
ES-29Fortgeschritten
Premium

ESP32 mDNS: Zugriff auf das Gerät über „bluegrays-esp.local“ (mit LCD-Display)

Wir ergänzen den ESP32 um einen mDNS-Dienst (Multicast DNS), damit du ihn statt über eine IP-Adresse unter einem lesbaren Hostnamen wie bluegrays-esp.local erreichst. Auch wenn sich die per DHCP vergebene IP ändert, bleibt der Name gleich. Ein kleiner Webserver auf dem Board lässt dich die LED im Browser unter http://bluegrays-esp.local/ steuern.

4.8(14)
23