ESP32 30 Pin vs 38 Pin: Unterschied, Pinout und Steckbrett
ESP32 30 Pin vs 38 Pin: Pinbelegung im Vergleich, warum er nicht aufs Steckbrett passt, WROOM oder WROVER, CP2102 oder CH340 und die Arduino-IDE-Einstellung.
Der Unterschied beim ESP32 30 Pin vs 38 Pin ist kleiner, als er aussieht: Auf beiden Boards sitzt meist dasselbe Modul ESP32-WROOM-32, derselbe Code läuft und in der Arduino IDE wählst du für beide "ESP32 Dev Module". Das 38-Pin-Board führt acht Pins mehr heraus: GPIO 0, die mit dem Flash-Speicher verbundenen GPIO 6–11 und eine weitere GND. Da die Flash-Pins ohnehin tabu sind, bleibt als echter Unterschied meist nur GPIO 0, die Reihenfolge der Pins auf dem Board und die Frage, wie es auf dem Steckbrett sitzt.

In diesem Beitrag stellen wir die Pinbelegung beider Boards nebeneinander, erklären, warum sie schlecht aufs Steckbrett passen und wie du das löst, was die Aufschriften WROOM und WROVER auf der Abschirmung bedeuten, wie du erkennst, ob dein USB-Chip ein CP2102 oder ein CH340 ist, und welche Einstellungen du in der Arduino IDE wählst. Am Ende gibt es einen Test-Sketch, der Chipmodell, Flash-Größe und PSRAM deines Boards ausgibt.
Was ist der Unterschied zwischen ESP32 mit 30 und 38 Pins?
Das Modul ESP32-WROOM-32 selbst hat 38 Lötpads. Der Hersteller des Entwicklungsboards entscheidet, welche davon auf die Stiftleisten an den Rändern geführt werden. Espressifs eigenes ESP32-DevKitC und seine Klone bieten 2×19 Pins, also einen für jedes Pad. Das DOIT ESP32 DevKit V1 und ähnliche Boards lassen die riskanten Flash-Pins und GPIO 0 (am BOOT-Taster) weg und kommen mit 2×15 = 30 Pins aus. Das 38-Pin-Board ist also nicht leistungsfähiger, es führt nur mehr Pads nach außen.
| Merkmal | 30-Pin-Board (DevKit V1) | 38-Pin-Board (DevKitC und Klone) |
|---|---|---|
| Modul | Meist ESP32-WROOM-32 / 32D / 32E | ESP32-WROOM-32 / 32E, manche mit WROVER |
| Leisten | 2 × 15 | 2 × 19 |
| Herausgeführte GPIOs | 25 | 32 (davon 6 Flash-Pins) |
| Wirklich nutzbare GPIOs | 25 | 26 |
| GPIO 0 | Kein Pin, nur am BOOT-Taster | Als Pin vorhanden |
| Flash-Pins (GPIO 6–11) | Nein | Ja (CLK, SD0–SD3, CMD), nicht nutzbar |
| GND-Pins | 2 | 3 |
| Versorgungspins | VIN und 3V3 | 5V und 3V3 |
| Benutzer-LED | Meist blaue LED an GPIO 2 | Beim Espressif-Board keine, bei manchen Klonen an GPIO 2 |
| Board in der Arduino IDE | ESP32 Dev Module oder DOIT ESP32 DEVKIT V1 | ESP32 Dev Module |
Das Fazit der Tabelle: Sechs der zusätzlichen Pins des 38-Pin-Boards nutzt du in keinem Projekt, der einzige echte Gewinn ist GPIO 0. Deshalb gilt "mehr Pins, besseres Board" beim ESP32 nicht. Entscheidend sind nicht die Pins, sondern dein Steckbrett-Aufbau, die Schaltpläne, denen du folgst, und das Erweiterungsboard, das du nutzen willst.
Pinbelegung: Wo liegt welcher Pin auf den beiden Boards?
Die Tabelle zeigt die Pins von oben nach unten, wenn die Antenne oben, der USB-Anschluss unten und die Bauteile zu dir zeigen. Auf dem DevKit V1 heißen die Pins etwa "D23" oder "TX2"; im Code schreibst du aber nicht die Beschriftung, sondern die GPIO-Nummer (23, 17). Die vollständige Belegung deines Boards findest du auch im Werkzeug Pinout.
| Position | 30 Pins links | 30 Pins rechts | 38 Pins links | 38 Pins rechts |
|---|---|---|---|---|
| 1 | EN | D23 | 3V3 | GND |
| 2 | VP (GPIO 36) | D22 | EN | GPIO 23 |
| 3 | VN (GPIO 39) | TX0 (GPIO 1) | SVP (GPIO 36) | GPIO 22 |
| 4 | D34 | RX0 (GPIO 3) | SVN (GPIO 39) | TX (GPIO 1) |
| 5 | D35 | D21 | GPIO 34 | RX (GPIO 3) |
| 6 | D32 | D19 | GPIO 35 | GPIO 21 |
| 7 | D33 | D18 | GPIO 32 | GND |
| 8 | D25 | D5 | GPIO 33 | GPIO 19 |
| 9 | D26 | TX2 (GPIO 17) | GPIO 25 | GPIO 18 |
| 10 | D27 | RX2 (GPIO 16) | GPIO 26 | GPIO 5 |
| 11 | D14 | D4 | GPIO 27 | GPIO 17 |
| 12 | D12 | D2 | GPIO 14 | GPIO 16 |
| 13 | D13 | D15 | GPIO 12 | GPIO 4 |
| 14 | GND | GND | GND | GPIO 0 |
| 15 | VIN | 3V3 | GPIO 13 | GPIO 2 |
| 16 | - | - | SD2 (GPIO 9) | GPIO 15 |
| 17 | - | - | SD3 (GPIO 10) | SD1 (GPIO 8) |
| 18 | - | - | CMD (GPIO 11) | SD0 (GPIO 7) |
| 19 | - | - | 5V | CLK (GPIO 6) |
Die linken Seiten ähneln sich stark, die rechten nicht: Das 30-Pin-Board hat unten rechts GND und 3V3, das 38-Pin-Board an derselben Stelle GPIO 0, 2, 15 und die Flash-Pins. Baust du einen Schaltplan für das eine Board auf dem anderen "an derselben Position" nach, landest du an falschen Pins. Bei Klonen kann die Reihenfolge leicht abweichen; maßgeblich ist immer die Beschriftung auf deinem Board.
Das Steckbrett-Problem und wie du es löst
Ein normales Steckbrett hat auf jeder Seite einer Reihe fünf verbundene Löcher (a–e und f–j) und in der Mitte eine Trennrinne. Das ESP32-Board sitzt über der Rinne und verdeckt alles zwischen seinen beiden Stiftleisten. Boards mit 22,86 mm (0,9 Zoll) Abstand zwischen den Pinreihen lassen auf jeder Seite ein Loch frei. Bei 25,4 mm (1 Zoll) bleibt nur auf einer Seite ein einziges Loch, und an die Pins der anderen Seite kommst du mit keinem Kabel. Die Breite hängt vom Hersteller ab; es gibt 30- und 38-Pin-Boards in beiden Breiten, am häufigsten ist aber das breite Board. Hast du dein Board schon, miss den Abstand der beiden Pinreihen mit dem Lineal; vor dem Kauf schau in die Produktmaße.
- Zwei Steckbretter nebeneinander: Entferne bei einem die seitliche Stromschiene, steck beide Steckbretter zusammen und setz je eine Pinreihe des Boards auf ein Steckbrett. Neben jedem Pin bleiben fünf Löcher frei; das ist die bequemste und günstigste Lösung.
- Jumperkabel Buchse-Stecker: Steck das Board nicht aufs Steckbrett, sondern verbinde die Pins direkt mit Kabeln mit Buchse. Für kleine Tests geht das schnell, aber die Kabel rutschen leicht ab.
- Erweiterungsboard (Breakout-Board): Diese Platinen mit Schraubklemmen oder mit GND und 3V3 neben jedem Pin machen das Steckbrett überflüssig. Es gibt sie getrennt für 30- und 38-Pin-Boards; kauf das, dessen Pinzahl und Breite zu deinem Board passen.
- Ein schmales Board wählen: Arbeitest du viel mit dem Steckbrett, nimm ein Board mit 22,86 mm zwischen den Pinreihen. Steht das Maß nicht auf der Produktseite, frag den Händler.
WROOM und WROVER: Was verrät die Metallabschirmung?
Auf der Metallabschirmung des Moduls steht der Modellname. WROOM-Module enthalten nur den Prozessor und den Flash-Speicher. WROVER-Module sind etwas länger und haben zusätzlich externen Arbeitsspeicher, den PSRAM. Modelle mit "U" (etwa WROOM-32U oder WROVER-IE) haben keine Leiterplattenantenne, sondern einen kleinen U.FL-Stecker für eine externe Antenne. Das D oder E am Ende des Namens zeigt die Version des Chips im Inneren.
| Modul | Chip | Flash | PSRAM | Hinweis |
|---|---|---|---|---|
| ESP32-WROOM-32 | ESP32-D0WDQ6 | 4 MB | Keiner | Erste Version; verbreitet auf älteren, günstigen Boards |
| ESP32-WROOM-32D | ESP32-D0WD | 4 MB (auch 8 und 16 MB erhältlich) | Keiner | Jahrelang das häufigste Modell |
| ESP32-WROOM-32E | ESP32-D0WD-V3 | 4, 8 oder 16 MB | Keiner | Neuere Boards; V3-Silizium behebt Fehler des älteren Chips |
| ESP32-WROOM-32U / 32UE | Wie WROOM-32D / 32E | 4 MB und mehr | Keiner | U.FL-Stecker für externe Antenne |
| ESP32-WROVER-E / IE | ESP32-D0WD-V3 | 4, 8 oder 16 MB | 2 oder 8 MB | Längeres Modul; GPIO 16 und 17 für den PSRAM reserviert |
Für fast jedes Projekt, ob Sensoren auslesen, ein Relais schalten, einen Webserver betreiben oder Telegram-Nachrichten senden, reicht ein WROOM; die 520 KB interner RAM des ESP32 sind dafür mehr als genug. PSRAM macht den Unterschied bei speicherhungrigen Aufgaben wie Kamerabildern, grafischen Oberflächen auf großen Farbdisplays oder Audioaufnahmen. Um den PSRAM eines WROVER-Boards zu nutzen, musst du in der Arduino IDE PSRAM: Enabled einschalten; sonst taucht der Speicher gar nicht auf.
USB-Seriell-Chip: CP2102 oder CH340?
Der ESP32 spricht selbst kein USB; die Übersetzung zum Computer übernimmt der kleine Chip direkt neben der USB-Buchse. Von ihm hängt ab, unter welchem Namen das Board am Rechner erscheint und welchen Treiber es braucht. Ist die Aufschrift zu klein zum Lesen, achte auf die Bauform:
| Chip | Aussehen | Name unter Windows | USB-ID (VID:PID) | Treiber |
|---|---|---|---|---|
| CP2102 / CP2104 (Silicon Labs) | Quadratisch, ohne Beinchen (QFN) | Silicon Labs CP210x USB to UART Bridge | 10C4:EA60 | Meist automatisch; sonst CP210x-VCP-Treiber |
| CH340C / CH340G (WCH) | Rechteckig, Beinchen an zwei Seiten (SOP-16) | USB-SERIAL CH340 | 1A86:7523 | Meist automatisch; sonst CH341SER-Treiber |
| CH9102F (WCH) | Kleines Quadrat, ohne Beinchen (QFN) | USB-Enhanced-SERIAL CH9102 | 1A86:55D4 | Auf älteren Systemen CH343SER-Treiber |
Öffne unter Windows den Geräte-Manager und schau unter Anschlüsse (COM & LPT); der Eintrag, der beim Einstecken erscheint, verrät den Chip. Steht dort "Unbekanntes Gerät", klick mit rechts darauf, geh auf Eigenschaften > Details > Hardware-IDs und vergleiche VID und PID mit der Tabelle. Aktuelle Versionen von macOS und Linux erkennen die meisten dieser Chips ohne zusätzlichen Treiber; der Port heißt unter macOS /dev/cu.usbserial-... und unter Linux zum Beispiel /dev/ttyUSB0. Auf Boards mit CH340G siehst du neben dem Chip einen kleinen 12-MHz-Quarz; der CH340C braucht keinen. Mehr zu Treibern und Ports steht im Beitrag USB-TTL-Adapter.
Das richtige Board und die Einstellungen in der Arduino IDE
- Suche im Boardverwalter nach esp32 und installiere das Paket von Espressif Systems. Für die Erstinstallation folge den Schritten in Was ist der ESP32?.
- Wähle unter Werkzeuge > Board > esp32 das ESP32 Dev Module. Diese Auswahl funktioniert mit allen WROOM-Boards mit 30 und 38 Pins.
- Für das 30-Pin-Board kannst du auch DOIT ESP32 DEVKIT V1 wählen; der einzige Unterschied ist, dass die Konstante LED_BUILTIN als GPIO 2 definiert ist.
- Hat dein Board ein WROVER-Modul, wähle ESP32 Wrover Module oder stelle im ESP32 Dev Module die Option PSRAM auf Enabled.
- Wähle unter Werkzeuge > Port den Port deines Boards und lade hoch. Hängt der Upload bei "Connecting...", halte den BOOT-Taster gedrückt und lass ihn los, sobald der Upload beginnt.
| Einstellung im Menü Werkzeuge | Empfohlener Wert | Wann ändern? |
|---|---|---|
| Upload Speed | 921600 | 115200, wenn der Upload mittendrin abbricht |
| CPU Frequency | 240MHz (WiFi/BT) | 80 oder 160 MHz, wenn du Akku sparen musst |
| Flash Mode | QIO | DIO, wenn ein Klon nicht startet |
| Flash Size | 4MB (32Mb) | Die echte Größe bei Modulen mit 8 oder 16 MB |
| Partition Scheme | Default 4MB with spiffs | Huge APP (3MB No OTA), wenn dein Sketch nicht passt |
| PSRAM | Disabled | Enabled bei Boards mit WROVER-Modul |
Sketch zum Erkennen deines Boards: Modell, Flash und PSRAM
Statt zu raten, welchen Chip, wie viel Flash und wie viel PSRAM dein Board hat, kannst du das Board selbst fragen. Lade diesen Sketch hoch und öffne den seriellen Monitor mit 115200 Baud:
1// Kartını tanı: yonga modeli, flaş, PSRAM ve MAC / Identify your board: chip model, flash, PSRAM and MAC
2void setup() {
3 Serial.begin(115200);
4 delay(1000); // Seri Monitör'ün açılmasını bekle / wait for the Serial Monitor
5
6 Serial.printf("Yonga / Chip: %s, rev %d, %d cekirdek / cores\n",
7 ESP.getChipModel(), ESP.getChipRevision(), ESP.getChipCores());
8 Serial.printf("CPU: %lu MHz\n", (unsigned long)ESP.getCpuFreqMHz());
9 Serial.printf("Flas / Flash: %lu MB\n", (unsigned long)(ESP.getFlashChipSize() / (1024 * 1024)));
10 Serial.printf("PSRAM: %lu KB\n", (unsigned long)(ESP.getPsramSize() / 1024)); // WROOM: 0, WROVER: > 0 (PSRAM: Enabled)
11
12 uint64_t mac = ESP.getEfuseMac(); // fabrikada yazılan MAC / factory MAC
13 Serial.print("MAC: ");
14 for (int i = 0; i < 6; i++) {
15 Serial.printf("%02X", (unsigned int)((mac >> (8 * i)) & 0xFF));
16 if (i < 5) Serial.print(':');
17 }
18 Serial.println();
19}
20
21void loop() {
22}Steht in der Ausgabe ESP32-D0WDQ6, ist das Modul sehr wahrscheinlich das ursprüngliche WROOM-32; ESP32-D0WD deutet meist auf ein WROOM-32D hin, ESP32-D0WD-V3 (rev 3) auf ein WROOM-32E oder WROVER-E. Ist die PSRAM-Zeile größer als null, hast du ein WROVER-Board; dieser Wert erscheint aber nur mit eingeschalteter PSRAM-Option. Hat der Flash mehr als 4 MB, kannst du Flash Size auf die echte Größe stellen und Platz für größere Programme schaffen. Mit der MAC-Adresse findest du dein Board in der Geräteliste deines Routers.
Eingebaute LED und Pintest
Die meisten 30-Pin-DevKit-V1-Boards haben eine blaue LED an GPIO 2, getrennt von der roten Power-LED, die leuchtet, solange das Board Strom hat. Espressifs 38-Pin-DevKitC hat keine Benutzer-LED, bei manchen Klonen sitzt sie ebenfalls an GPIO 2. Der Sketch unten setzt die sicheren Ausgangspins, die es auf beiden Boards gibt, nacheinander für eine Sekunde auf HIGH und schreibt in den seriellen Monitor, welcher gerade aktiv ist. Verbinde eine LED über einen 220-Ω-Widerstand mit GND und tippe mit ihrem anderen Bein die Pins an, um die Beschriftung deines Boards zu prüfen.
1// 30 ve 38 pinli kartta ortak, güvenli çıkış pinleri / safe output pins found on both 30- and 38-pin boards
2const int LED_PIN = 2; // DevKit V1 mavi LED; "ESP32 Dev Module" seçiliyken LED_BUILTIN tanımlı değildir
3 // DevKit V1 blue LED; LED_BUILTIN is not defined when "ESP32 Dev Module" is selected
4const int pins[] = {4, 5, 13, 14, 16, 17, 18, 19, 21, 22, 23, 25, 26, 27, 32, 33}; // WROVER'da 16 ve 17'yi sil / remove 16 and 17 on WROVER
5const int count = sizeof(pins) / sizeof(pins[0]);
6
7void setup() {
8 Serial.begin(115200);
9 pinMode(LED_PIN, OUTPUT);
10 for (int i = 0; i < count; i++) pinMode(pins[i], OUTPUT);
11}
12
13void loop() {
14 for (int i = 0; i < count; i++) {
15 Serial.printf("GPIO %d -> HIGH\n", pins[i]); // LED + 220 Ω ile bu pini yokla / probe this pin with an LED + 220 Ω
16 digitalWrite(LED_PIN, HIGH); // dahili LED test sırasında yanar / onboard LED lights during the test
17 digitalWrite(pins[i], HIGH);
18 delay(1000);
19 digitalWrite(pins[i], LOW);
20 digitalWrite(LED_PIN, LOW);
21 delay(200);
22 }
23}Welche Pins sind sicher? Auf beiden Boards gelten dieselben Regeln
| Pin | Status | Warum? |
|---|---|---|
| GPIO 6–11 | Nicht nutzen | Mit dem Flash verbunden; nur beim 38-Pin-Board herausgeführt |
| GPIO 0 | Mit Vorsicht | Am BOOT-Taster; ist er beim Start LOW, geht das Board in den Upload-Modus |
| GPIO 2 | Mit Vorsicht | Muss beim Upload LOW oder offen sein; treibt beim DevKit V1 die eingebaute LED |
| GPIO 12 | Mit Vorsicht | Ist er beim Start HIGH, werden 1,8 V für den Flash gewählt und das Board startet nicht |
| GPIO 15 | Mit Vorsicht | Ist er beim Start LOW, verstummen die Startmeldungen |
| GPIO 1 und 3 | Mit Vorsicht | TX0 und RX0 der seriellen USB-Verbindung |
| GPIO 34, 35, 36, 39 | Nur Eingang | Keine Ausgänge, kein interner Pull-up |
| GPIO 16 und 17 | Beim WROVER nicht nutzen | Beim WROVER am PSRAM; beim WROOM frei (TX2 und RX2) |
| GPIO 4, 5, 13, 14, 18, 19, 21–23, 25–27, 32, 33 | Sicher | Allgemeine Ein- und Ausgänge |
Versorgungspins: VIN, 5V und 3V3
VIN am 30-Pin-Board und 5V am 38-Pin-Board erfüllen dieselbe Aufgabe: Sie hängen an der 5-V-Leitung des USB und versorgen den 3,3-V-Regler des Boards (meist ein AMS1117). Willst du das Board ohne USB betreiben, speist du hier 5 V ein; der Regler braucht mindestens etwa 4,5 V und wird bei höherer Spannung sehr heiß, deshalb sind 5–6 V am sichersten. Der Pin 3V3 ist der Ausgang des Reglers, darüber kannst du deine Sensoren versorgen. Weil der ESP32 beim Einschalten des WLANs kurzzeitig bis zu 250 mA zieht, entnimm am 3V3 nicht mehr als ein paar hundert mA. VIN zu speisen, während das USB-Kabel steckt, kann außerdem zwei Quellen miteinander verbinden; entscheide dich für eine.
Wenn du MicroPython nutzt
Die 30- und 38-Pin-Boards nutzen dieselbe MicroPython-Firmware: Flashe einfach die allgemeine ESP32-Version von Espressif, für WROVER-Boards die Version mit PSRAM-Unterstützung (SPIRAM). In der Thonny-Shell zeigen diese Zeilen Flash-Größe und Prozessortakt und schalten die LED des DevKit V1 ein:
1import esp, machine
2
3print("Flas / Flash:", esp.flash_size() // (1024 * 1024), "MB")
4print("CPU:", machine.freq() // 1000000, "MHz")
5
6led = machine.Pin(2, machine.Pin.OUT) # DevKit V1 dahili LED / onboard LED
7led.on()Welches Board kaufen? Kurze Entscheidungshilfe
- Für Steckbrett-Übungen oder den Unterricht: Nimm ein DevKit V1 mit 30 Pins, am besten ein schmales mit 22,86 mm zwischen den Pinreihen; seine eingebaute LED hilft bei den ersten Tests.
- Wenn dein Schaltplan oder Buch ein bestimmtes Board nutzt: Kauf genau dieses; da die Pinpositionen abweichen, musst du nichts umrechnen.
- Wenn du GPIO 0 brauchst oder dein Erweiterungsboard 38 Pins hat: Wähl das 38-Pin-Board.
- Für Kamera-, Großdisplay- oder Audioprojekte: Denk an ein Board mit WROVER-Modul oder gleich an eine ESP32-CAM.
- Wenn du keinen Treiberärger willst: Nimm ein neueres Board mit CP2102 oder CH340C und USB-C-Buchse.
- ESP32-S3-, C3- oder C6-Boards: Das sind andere Chips; ihre Pinnummern und Belegungen passen nicht zu den Boards in diesem Beitrag.
Häufige Fehler und ihre Lösungen
- Fehler "LED_BUILTIN was not declared": Mit ESP32 Dev Module ist diese Konstante nicht definiert. Schreib 2 statt LED_BUILTIN oder wähl DOIT ESP32 DEVKIT V1 als Board.
- Am Pin aus dem Schaltplan angeschlossen, aber nichts passiert: Der Plan wurde vielleicht für die andere Belegung gezeichnet. Schließ nach Beschriftung und GPIO-Nummer an, nicht nach Position.
- Das Board startet nicht oder startet ständig neu: An GPIO 6–11 hängt etwas oder GPIO 12 wird beim Start auf HIGH gezogen. Entferne die Verbindungen an diesen Pins und probier es erneut.
- Kein Port sichtbar: Das Kabel ist vielleicht ein reines Ladekabel oder der Treiber des USB-Chips fehlt. Nimm ein Datenkabel und vergleiche den Namen im Geräte-Manager mit der Tabelle.
- Fehler "Failed to connect": Halte beim Start des Uploads BOOT gedrückt; hilft das nicht, senke die Upload Speed auf 115200. Weitere Lösungen findest du in ESP32 Failed to Connect.
- PSRAM zeigt beim WROVER-Board 0: Die Option PSRAM steht im Menü Werkzeuge noch auf Disabled; stell sie auf Enabled und lade neu hoch.
Kurz gesagt: ESP32-Boards mit 30 und 38 Pins haben dasselbe Gehirn; was sie unterscheidet, sind die Lage der Pins, GPIO 0 und wie das Board auf deinen Arbeitsplatz passt. Hast du die Beschriftung gelesen und mit dem Test-Sketch geprüft, findest du die richtigen Pins, egal welchem Schaltplan du folgst. Für die ersten Versuche schau dir in der BlueGrays-App die ESP32-Projekte zu eingebauter LED, externer LED, LED mit Taster, Ampel, Lichtmessung mit LDR, I2C-LCD und WLAN-Verbindung an; jedes erklärt Schaltplan und Code Schritt für Schritt.
Häufige Fragen
ESP32 mit 30 oder 38 Pins kaufen?
Arbeitest du auf dem Steckbrett und hast keinen besonderen Bedarf, ist das 30-Pin-DevKit-V1 meist bequemer und hat fast immer eine eingebaute LED. Nimm das 38-Pin-Board, wenn du GPIO 0 nutzen willst, ein 38-Pin-Erweiterungsboard hast oder dein Schaltplan dafür gezeichnet ist. Prozessor und Code sind bei beiden gleich.
Muss ich den Code für einen ESP32 mit 30 Pins ändern?
Nein. Solange der Code GPIO-Nummern verwendet, läuft er auf 30- und 38-Pin-Boards gleich. Prüfe nur, dass Code für ein 38-Pin-Board nicht GPIO 0 oder die Flash-Pins nutzt, denn diese Pins sind beim 30-Pin-Board nicht herausgeführt.
An welchem Pin ist die eingebaute LED beim ESP32 DevKit V1?
Beim DevKit V1 hängt die blaue Benutzer-LED an GPIO 2. Mit ESP32 Dev Module in der Arduino IDE ist LED_BUILTIN nicht definiert, also schreib direkt 2 in den Code oder wähl das Board DOIT ESP32 DEVKIT V1. Die rote LED zeigt nur die Versorgung an und lässt sich nicht steuern.
Welches Board wähle ich in der Arduino IDE für den ESP32 mit 38 Pins?
Für alle Boards mit WROOM-Modul, egal ob 30 oder 38 Pins, reicht ESP32 Dev Module. Hat dein 38-Pin-Board ein WROVER-Modul, wähl ESP32 Wrover Module oder schalte im ESP32 Dev Module die Option PSRAM ein.
Was ist der Unterschied zwischen ESP32 WROOM und WROVER?
Beide enthalten denselben ESP32-Chip. Das WROVER bringt zusätzlich 2 bis 8 MB PSRAM mit und ist etwas länger, dafür sind GPIO 16 und 17 für diesen Speicher reserviert. Außer bei Kamera-, Großdisplay- oder Audioprojekten reicht das WROOM.
Wie erkenne ich, ob mein ESP32 einen CP2102 oder CH340 hat?
Sieh dir den kleinen Chip neben der USB-Buchse an: Ein quadratischer ohne Beinchen ist meist ein CP2102, ein rechteckiger mit Beinchen an zwei Seiten ein CH340. Im Windows-Geräte-Manager erscheint das Board als "Silicon Labs CP210x" oder "USB-SERIAL CH340"; in der Hardware-ID steht 10C4 für Silicon Labs und 1A86 für WCH.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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.

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.

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.

ESP32 LED Steuerung mit Taster (Toggle)
Jedes Mal, wenn die Taste gedrückt wird, ändert sich der Zustand der LED: ist sie an, schaltet sie aus, ist sie aus, schaltet sie ein. Klassisches Toggle-Muster. Mit der Entprellung wird das mechanische Geräusch des Tasters beseitigt, um ein einmaliges Umschalten mit einem einzigen Druck zu gewährleisten.

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.

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.

ESP32 I2C-LCD-Display (16×2)
In diesem Projekt schließen wir ein 16x2-Zeichen-LCD über I2C an den ESP32 an und zeigen Text an. Dank I2C reichen 2 Datenpins (SDA und SCL) statt der 6+ Pins einer klassischen Parallelverbindung. Der Code schreibt eine feste Nachricht in die erste Zeile und einen sekündlich steigenden Zähler in die zweite. Beim Start gibt ein I2C-Scanner die Adresse des Displays im Serial Monitor aus (meist 0x27 oder 0x3F).

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.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

