Pinbelegung der Mikrocontroller-Boards: ESP32-C6, ESP32, NodeMCU und Arduino Uno
https://bildung.social/deck/@oerinformatik/114099714293639592
https://oer-informatik.de/mcu-pinout
Mikrocontroller, Pinout, Pinbelegung, Anschlussbelegung, GPIO, Strapping-Pin, ESP32, ESP32-C6, ESP8266, NodeMCU, Arduino Uno, Liste der Ein- und Ausgabeelemente
tl/dr; (ca. 44 min Lesezeit): Nicht alle Pins eines Mikrocontroller-Boards kann man frei nutzen: Einige steuern den Startvorgang (Strapping-Pins), andere sind mit Speicher, USB, LED oder Tastern verbunden. Hier stehen die Pinouts der Boards ESP32-C6 DevKit N8-M, ESP32 Dev Kit V1, V2 und C V4, WeMos-Board mit OLED, NodeMCU (ESP8266) und Arduino Uno mit den empfohlenen Pins, dazu für jedes Board die Liste der Ein- und Ausgabeelemente, mit der alle Beispiele der Reihe arbeiten, und ein Testprogramm für die Standardbelegung [AI-Assisted]. (Zuletzt geändert am 11.11.2026)
Dieser Artikel gehört zu den Peripherie-Artikeln der Reihe über Mikrocontroller-Grundlagen: Pinbelegung der Boards / Sensoren für das Raumklima / Anzeigen: OLED und LED-Matrix / Schaltungen zeichnen mit Fritzing. Die Grundlagen beginnen mit Erste Schritte.
Dieser Artikel baut auf der Kann-Liste des Artikels Erste Schritte mit dem Mikrocontroller auf.
Schon fit in diesem Thema? Nutze die Kann-Liste und die Leitfragen unter dem Artikel als Checkliste, ob Du die relevanten Kompetenzen bereits hast.
Als Grundlagen zur Pinbelegung von Mikrocontroller-Boards kann ich nach Durchlesen des Artikels…
… in einem Pinout ablesen, welche Anschlüsse frei nutzbar, eingeschränkt nutzbar oder reserviert sind.
… erklären, was Strapping-Pins sind und wie ich sie beschalten darf, damit das Board startet.
… die Pins benennen, die für USB-Seriell, Flash-Speicher und native USB reserviert sind, und begründen, warum ich sie frei lasse.
… zwischen GPIO-Nummer und Board-Beschriftung umrechnen (z. B. NodeMCU
D4=GPIO2, UnoA1= digital 15).… die Liste der Ein- und Ausgabeelemente eines Programms an ein anderes Board anpassen, ohne den übrigen Code zu ändern.
… die Standardpins für I²C und SPI je Board nennen und entscheiden, ob ich andere Pins wählen kann.
… Unterschiede der Boards bei Logikpegel, ADC, PWM, Interrupts und Arbeitsspeicher berücksichtigen.
… mit einem Testprogramm prüfen, ob Taster, LEDs und Poti richtig angeschlossen sind.
Es ist generell eine gute Idee, das Pinout (also die Anschlussbelegung) des vorliegenden Mikrocontroller-Boards zur Hand zu haben. Das Internet ist voll davon – manchmal muss man ein bisschen suchen, bis man überhaupt weiß, welche Version das eigene Board ist. Auf dieser Seite folgen:
die Pinouts der Boards, die in der Reihe genutzt werden, mit Hinweisen, welche Pins sich wofür eignen: ESP32-C6 DevKit N8-M, ESP32 Dev Kit V1, V2 und C V4, WeMos-Board mit 0,96-Zoll-OLED, NodeMCU (ESP8266) und Arduino Uno,
für jedes Board die Liste der Ein- und Ausgabeelemente, mit der alle Beispielprogramme der Reihe beginnen,
ein Testprogramm, das die Standardbelegung auf jedem Board prüft,
ausführliche Tabellen zu den Anschlusspins, um auch für andere Boards mit denselben Chips Rückschlüsse ziehen zu können.
Die Beispiele der Reihe nutzen auf allen Boards dieselben Namen (BUTTON1_PIN, LED1_PIN, MCU_SDA …); nur die Pinnummern dahinter unterscheiden sich:
Legende für die Pinouts
GPIOsteht für general purpose input output. Die Zahl dahinter ist diejenige, die man im Programm nutzt (also z. B. für GPIO13:pinMode(13, OUTPUT);). Auf dem NodeMCU sind die Pins mitD0…D8beschriftet; die Arduino-Umgebung kennt diese Namen ebenfalls, im Code der Reihe steht aber die GPIO-Nummer mit demD-Namen als Kommentar.ADCist der Analog-Digital-Umsetzer. Der klassische ESP32 hat zwei davon; ADC2 kann nicht gleichzeitig mit WLAN genutzt werden. Der ESP32-C6 hat nur ADC1 (GPIO0 bis GPIO6), der ESP8266 nur einen EingangA0, der Uno sechs (A0bisA5).- PWM (Pulsweitenmodulation) geht bei den ESP-Chips auf fast allen Ausgängen (ESP32: 16 LEDC-Kanäle, ESP32-C6: 6 Kanäle, ESP8266: per Software). Der Uno kann PWM nur an den mit
~markierten Pins 3, 5, 6, 9, 10 und 11. - RTC bzw. LP-GPIO: Über diese Pins kann der ESP aus dem Deep-Sleep geweckt werden.
- SP: Strapping-Pins müssen beim Start (Reset) einen bestimmten Zustand haben, weil sie Betriebsarten auswählen (z. B. Programm starten oder neues Programm laden). Auf dem Board sind sie oft über Pull-up- oder Pull-down-Widerstände vorbelegt.
IundOgroß und grün hinterlegt heißt: bedenkenlos als Eingang bzw. Ausgang nutzbar.iundoklein und gelb hinterlegt heißt: Es gibt Einschränkungen. Erst den Text lesen, dann überlegen, ob der Pin als Eingang bzw. Ausgang sinnvoll nutzbar ist.x: in dieser Richtung nicht nutzbar.pubzw.pd: An Strapping-Pins gibt es häufig Pull-up- oder Pull-down-Widerstände, damit beim Start der richtige Zustand anliegt. Die Beschaltung muss das berücksichtigen.- hellrot, orange, hellblau hinterlegt: Spannungsversorgung (3,3 V, 5 V, GND).
- rot hinterlegt: Finger weg! Diese Pins sind mit dem Flash-Speicher oder der USB-Verbindung verbunden.
Die Standardbelegung der Beispiele
Alle Programme der Reihe beginnen mit einer Liste der Ein- und Ausgabeelemente. Sie legt für jedes Bauteil eine Konstante an: Datentyp, Name, Pin und ein Kommentar zum Verhalten (z. B. „active LOW, INPUT_PULLUP“). Der Rest des Programms nutzt nur noch die Namen. Für ein anderes Board tauscht man deshalb nur die Liste aus; der übrige Code bleibt Zeichen für Zeichen gleich. Ein Programm übernimmt aus der Liste seines Boards nur die Zeilen, die es braucht, in der Reihenfolge der Liste.
Für die Beschaltung gilt auf allen Boards dasselbe:
- Taster liegen gegen GND und werden mit
pinMode(BUTTONx_PIN, INPUT_PULLUP)eingelesen; gedrückt heißtLOW. - LEDs liegen über einen Vorwiderstand von etwa 220 Ω gegen GND und leuchten bei
HIGH. Ausnahme istLED_PWM1_PINauf dem NodeMCU: Dort sitzt die eingebaute LED, die beiLOWleuchtet. Deshalb gibt es für die PWM-LEDs die KonstantenLED_PWM1_ONundLED_PWM2_ON, mit denen der Code schaltet:digitalWrite(LED_PWM1_PIN, LED_PWM1_ON);. - Poti: zwischen 3V3 und GND (Uno: 5V und GND), Schleifer an
POTI_PIN. Rohwerte rechnet der Code mitADC_MAX(größter Wert vonanalogRead()) undADC_VREF(Spannung beiADC_MAX) um. - Interrupts nur an
BUTTON1_PINundBUTTON2_PIN, weil der Uno externe Interrupts nur an Pin 2 und 3 hat. PWM undtone()nur anLED_PWM1_PIN,LED_PWM2_PINundBUZZER_PIN(der Summer teilt sich den Pin mit der zweiten PWM-LED). - USB-Seriell bleibt frei: Die Pins, über die
Serial.print()läuft, belegt keine Liste. - Zeilen, die in einer Liste auskommentiert sind, gibt es auf diesem Board nicht; ein Programm darf sie nicht nutzen.
I²C und SPI starten: Die Bus-Pins der Listen (MCU_SDA, MCU_SCL, MCU_SCK, MCU_MISO, MCU_MOSI, MCU_CS) sind die Standardpins der Arduino-Umgebung des jeweiligen Boards. Deshalb starten alle Programme die Busse ohne Parameter. Die Variante mit Pinangabe steht als Kommentar daneben:
Wire.begin(); // I2C an den Standardpins; andere Pins (ESP32, ESP32-C6, ESP8266): Wire.begin(MCU_SDA, MCU_SCL);
SPI.begin(); // SPI an den Standardpins; andere Pins (nur ESP32, ESP32-C6): SPI.begin(MCU_SCK, MCU_MISO, MCU_MOSI, MCU_CS);Beim Uno sind die Bus-Pins fest; Wire.begin(sda, scl) und SPI.begin(sck, miso, mosi, ss) lassen sich dort nicht übersetzen. Beim ESP8266 ist Hardware-SPI fest auf D5 bis D8, I²C lässt sich auf andere Pins legen. Einzige Ausnahme in den Listen ist das WeMos-Board: Dort liegen SDA und SCL nicht auf den Standardpins, also muss es dort Wire.begin(MCU_SDA, MCU_SCL); und SPI.begin(MCU_SCK, MCU_MISO, MCU_MOSI, MCU_CS); heißen.
In den Artikeln stehen die Programme in Tabs für vier Boards: ESP32-C6 (voreingestellt), ESP32 (DevKit V4) (die Liste gilt auch für V1 und V2), ESP8266 (NodeMCU) und Arduino Uno. Die Listen für das WeMos-Board stehen nur hier.
ESP32-C6 DevKit N8-M
Ein schmales Board mit dem Modul ESP32-C6-WROOM-1: Auf einem normalen Steckbrett bleiben beide Pinleisten erreichbar. Der ESP32-C6 hat einen RISC-V-Kern mit 160 MHz, 512 KB SRAM, WLAN 6, Bluetooth LE und Zigbee/Thread. Klassisches Bluetooth, Touch-Pins und einen DAC hat er nicht.
Board-Treiber: „ESP32C6 Dev Module“
Besonderheiten:
- Zwei USB-C-Buchsen. Die Buchse „UART“ geht über einen USB-Seriell-Wandler an GPIO16/17. Die zweite Buchse („USB“) ist direkt am Chip (GPIO12/13): Sie bietet USB-Seriell und einen eingebauten Debugger (USB-JTAG). Über sie erscheint der serielle Monitor nur, wenn in der Arduino-IDE „USB CDC On Boot: Enabled“ eingestellt ist. Unter Windows meldet sich das Board je nach Buchse mit unterschiedlichen COM-Ports; der Port mit der Bezeichnung „ESP32 Family …“ gehört zur nativen USB-Buchse.
- RGB-LED an GPIO8. Die eingebaute LED ist eine WS2812, die man nicht mit
digitalWrite(), sondern mitrgbLedWrite(8, rot, gruen, blau)steuert. GPIO8 ist zugleich Strapping-Pin. - Strapping-Pins sind GPIO4, 5, 8, 9 und 15. GPIO9 ist der BOOT-Taster: Ist er beim Reset gedrückt (LOW), startet der Chip im Download-Modus. GPIO4, 5 und 15 sind als Ausgang für LEDs unkritisch, als Eingang für Taster aber ungeeignet.
- ADC nur an GPIO0 bis GPIO6 (ADC1), dafür auch bei aktivem WLAN nutzbar.
Das Board hat 14 frei nutzbare GPIO (davon sechs Standardpins für I²C und SPI), fünf mit Einschränkungen (die Strapping-Pins) und vier, die für USB reserviert sind.
Das Pinout entspricht nahezu dem des Espressif-Boards ESP32-C6-DevKitC-1. Das Datenblatt des Moduls gibt es bei Espressif. Das passende Fritzing-Bauteil steht im Artikel Schaltungen zeichnen mit Fritzing.
Liste der Ein- und Ausgabeelemente (Standardbelegung):
//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: ESP32-C6 Dev Kit N8-M
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable | Anschlusspin | Name, Verhalten
const int POTI_PIN = 0; // Potentiometer, ADC1_CH0, 0..4095
const int BUTTON1_PIN = 1; // Button 1, active LOW, INPUT_PULLUP
const int BUTTON2_PIN = 2; // Button 2, active LOW, INPUT_PULLUP
const int BUTTON3_PIN = 3; // Button 3, active LOW, INPUT_PULLUP
const int BUTTON4_PIN = 10; // Button 4, active LOW, INPUT_PULLUP
const int LED1_PIN = 4; // LED 1, active HIGH (strapping pin, ok as output)
const int LED2_PIN = 5; // LED 2, active HIGH (strapping pin, ok as output)
const int LED3_PIN = 6; // LED 3, active HIGH
const int LED4_PIN = 7; // LED 4, active HIGH
const int LED_PWM1_PIN = 11; // LED with PWM (analogWrite), active HIGH
const int LED_PWM2_PIN = 15; // LED with PWM (analogWrite), active HIGH (strapping pin, ok as output)
const int BUZZER_PIN = 15; // passive buzzer (tone), shares pin with LED_PWM2_PIN
const int MCU_SDA = 23; // GPIO of MCU connected to SDA-Pin of I2C device
const int MCU_SCL = 22; // GPIO of MCU connected to SCL-Pin of I2C device
const int MCU_SCK = 21; // GPIO of MCU connected to SCK-Pin of SPI device
const int MCU_MISO = 20; // GPIO of MCU connected to MISO/SDO-Pin of SPI device
const int MCU_MOSI = 19; // GPIO of MCU connected to MOSI/SDI-Pin of SPI device
const int MCU_CS = 18; // GPIO of MCU connected to CS-Pin of SPI device
const int BOOT_BUTTON_PIN = 9; // onboard BOOT button, active LOW
// const int ONBOARD_LED_PIN = 8; // onboard RGB LED WS2812: only with rgbLedWrite(), not with digitalWrite()
const int LED_PWM1_ON = HIGH; // level that switches LED_PWM1 on
const int LED_PWM2_ON = HIGH; // level that switches LED_PWM2 on
const int ADC_MAX = 4095; // maximum value of analogRead()
const float ADC_VREF = 3.3; // voltage at ADC_MAX (approx.; exact: analogReadMilliVolts())
// reserved: GPIO12/13 (native USB), GPIO16/17 (USB-UART), GPIO8 (onboard RGB LED WS2812), GPIO9 (BOOT button)
// GPIO4-7 are also JTAG pins (external JTAG not usable; built-in USB-JTAG on GPIO12/13 still works)
// Serial.print(): USB-UART socket, or native USB socket with "USB CDC On Boot: Enabled"ESP32 Dev Kit V1, V2 und C V4
Die drei Boards tragen das Modul ESP32-WROOM-32 (zwei Kerne mit 240 MHz, 520 KB SRAM, WLAN, Bluetooth Classic und LE). Sie sind so breit, dass auf einem normalen Steckbrett nur eine der beiden Pinleisten leicht erreichbar ist. Board-Treiber für alle drei: „ESP32 Dev Module“. Die Liste der Ein- und Ausgabeelemente ist für alle drei Boards gleich.
ESP32 Dev Kit V1: gutmütiges Board mit elf frei verfügbaren und vierzehn eingeschränkt nutzbaren Pins und einer LED an GPIO2 – leider häufig mit Micro-USB-Anschluss.
ESP32 Dev Kit V2: im Wesentlichen wie das V1-Board. Zusätzlich herausgeführt sind GPIO0 (BOOT-Taster, nur bedingt nutzbar) und die Pins GPIO6 bis GPIO11, die man ohnehin nicht nutzt, weil an ihnen der Flash-Speicher hängt. Die eingebaute LED hängt an TX und ist damit nicht frei programmierbar. In der Pinbelegung ist das Board identisch zum Dev Kit C V4.
ESP32 Dev Kit C V4: etwas kompakter als das V2-Board, ebenfalls elf frei verfügbare und fünfzehn eingeschränkt nutzbare Pins. Neben der Bauform einziger Unterschied: Die LED an TX fehlt. Dieses Board ist der zweite Tab in den Artikeln der Reihe.
Wichtig bei allen drei Boards:
- Strapping-Pins sind GPIO0, 2, 5, 12 und 15. GPIO12 darf beim Start nicht HIGH sein (sonst stellt der Chip die Flash-Spannung auf 1,8 V und startet nicht), GPIO0 nicht LOW (sonst Download-Modus).
- GPIO34 bis GPIO39 sind nur Eingänge ohne internen Pull-up. Für Taster braucht man dort einen externen Widerstand.
- ADC2 (u. a. GPIO25 bis 27, 12 bis 15) ist bei aktivem WLAN gesperrt. Das Poti liegt deshalb an GPIO36 (ADC1).
- GPIO16/17 sind beim Modul ESP32-WROVER mit dem zusätzlichen PSRAM verbunden. Mit einem WROVER-Modul nimmt man für die PWM-LEDs GPIO2 und GPIO15 (siehe Kommentar in der Liste).
- DAC an GPIO25 und GPIO26 (8 Bit), Touch-Sensoren an zehn Pins.
Die Fritzing-Bauteile für die drei Boards stehen im Artikel Schaltungen zeichnen mit Fritzing.
Liste der Ein- und Ausgabeelemente (Standardbelegung):
//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: ESP32 Dev Kit V1 / V2 / C V4 (ESP32-WROOM-32)
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable | Anschlusspin | Name, Verhalten
const int POTI_PIN = 36; // Potentiometer, ADC1_CH0 (VP), input only, 0..4095
const int BUTTON1_PIN = 32; // Button 1, active LOW, INPUT_PULLUP
const int BUTTON2_PIN = 33; // Button 2, active LOW, INPUT_PULLUP
const int BUTTON3_PIN = 25; // Button 3, active LOW, INPUT_PULLUP
const int BUTTON4_PIN = 26; // Button 4, active LOW, INPUT_PULLUP
const int LED1_PIN = 27; // LED 1, active HIGH
const int LED2_PIN = 14; // LED 2, active HIGH (flickers briefly while booting)
const int LED3_PIN = 13; // LED 3, active HIGH
const int LED4_PIN = 4; // LED 4, active HIGH
const int LED_PWM1_PIN = 16; // LED with PWM (analogWrite), active HIGH (WROVER module: use 2)
const int LED_PWM2_PIN = 17; // LED with PWM (analogWrite), active HIGH (WROVER module: use 15)
const int BUZZER_PIN = 17; // passive buzzer (tone), shares pin with LED_PWM2_PIN
const int MCU_SDA = 21; // GPIO of MCU connected to SDA-Pin of I2C device
const int MCU_SCL = 22; // GPIO of MCU connected to SCL-Pin of I2C device
const int MCU_SCK = 18; // GPIO of MCU connected to SCK-Pin of SPI device (VSPI)
const int MCU_MISO = 19; // GPIO of MCU connected to MISO/SDO-Pin of SPI device
const int MCU_MOSI = 23; // GPIO of MCU connected to MOSI/SDI-Pin of SPI device
const int MCU_CS = 5; // GPIO of MCU connected to CS-Pin of SPI device
const int BOOT_BUTTON_PIN = 0; // onboard BOOT button, active LOW (do not hold during reset)
// const int ONBOARD_LED_PIN = 2; // only Dev Kit V1 (active HIGH); V2 = on TX (not usable), C V4 = none
const int LED_PWM1_ON = HIGH; // level that switches LED_PWM1 on
const int LED_PWM2_ON = HIGH; // level that switches LED_PWM2 on
const int ADC_MAX = 4095; // maximum value of analogRead()
const float ADC_VREF = 3.3; // voltage at ADC_MAX (approx.; exact: analogReadMilliVolts())
// reserved: GPIO1/3 (USB-Serial), GPIO6-11 (Flash), GPIO0 (BOOT), GPIO12 (Strapping)
// free input-only pins for extra analog inputs: 34, 35, 39 (no internal pull-up)WeMos-Board mit 0,96-Zoll-OLED
Das Board hat spezielle Anwendungsfälle; deshalb ist es nicht weiter schlimm, dass es lediglich drei frei verfügbare und zwölf eingeschränkt nutzbare Pins hat. Das eingebaute OLED-Display (SSD1306, I²C-Adresse 0x3C) macht da einiges wieder gut. Bei manchen Exemplaren muss man zum Hochladen den BOOT-Taster von Hand drücken. Wie viele ESP32-Boards ist es so breit, dass auf einem normalen Steckbrett nur eine der beiden Pinleisten leicht erreichbar ist.
Board-Treiber: „ESP32 Dev Module“
Die OLED hängt an GPIO5 (SDA) und GPIO4 (SCL), also nicht an den Standardpins des ESP32. Deshalb startet man hier I²C immer mit Wire.begin(MCU_SDA, MCU_SCL);. Wie man die Anzeige programmiert, steht im Artikel Anzeigen: OLED und LED-Matrix.
Liste der Ein- und Ausgabeelemente mit I²C und SPI:
//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: WeMos ESP32 DevBoard with 0.96" OLED (with I2C/SPI, OLED uses I2C)
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable | Anschlusspin | Name, Verhalten
const int POTI_PIN = 36; // Potentiometer, ADC1_CH0 (VP), input only, 0..4095
const int BUTTON1_PIN = 25; // Button 1, active LOW, INPUT_PULLUP
const int BUTTON2_PIN = 26; // Button 2, active LOW, INPUT_PULLUP
// const int BUTTON3_PIN = 39; // not available (option: GPIO39 with external 10k pull-up)
// const int BUTTON4_PIN = -1; // not available
const int LED1_PIN = 2; // LED 1, active HIGH (strapping pin, ok with LED to GND)
// const int LED2_PIN = -1; // not available (without SPI: use 13)
// const int LED3_PIN = -1; // not available (without SPI: use 14)
// const int LED4_PIN = -1; // not available
const int LED_PWM1_PIN = 16; // LED with PWM (analogWrite), active HIGH
// const int LED_PWM2_PIN = -1; // not available
// const int BUZZER_PIN = -1; // not available
const int MCU_SDA = 5; // GPIO of MCU connected to SDA-Pin (shared with onboard OLED SSD1306, 0x3C)
const int MCU_SCL = 4; // GPIO of MCU connected to SCL-Pin (shared with onboard OLED)
const int MCU_SCK = 14; // GPIO of MCU connected to SCK-Pin of SPI device (HSPI)
const int MCU_MISO = 12; // GPIO of MCU connected to MISO-Pin (Strapping pin: device must not drive HIGH at boot)
const int MCU_MOSI = 13; // GPIO of MCU connected to MOSI-Pin of SPI device
const int MCU_CS = 15; // GPIO of MCU connected to CS-Pin of SPI device (strapping pin)
const int BOOT_BUTTON_PIN = 0; // onboard BOOT button, active LOW
const int LED_PWM1_ON = HIGH; // level that switches LED_PWM1 on
const int ADC_MAX = 4095; // maximum value of analogRead()
const float ADC_VREF = 3.3; // voltage at ADC_MAX (approx.)
// I2C/SPI NOT on default pins: Wire.begin(MCU_SDA, MCU_SCL); SPI.begin(MCU_SCK, MCU_MISO, MCU_MOSI, MCU_CS);
// reserved: GPIO1/3 (USB-Serial), GPIO6-11 (Flash), GPIO0 (BOOT)Variante ohne SPI (die OLED bleibt an I²C):
// wie oben, aber ohne MCU_SCK/MCU_MISO/MCU_MOSI/MCU_CS und zusätzlich:
const int LED2_PIN = 13; // LED 2, active HIGH (only without SPI)
const int LED3_PIN = 14; // LED 3, active HIGH (only without SPI, flickers while booting)NodeMCU (ESP8266)
Das NodeMCU-Board mit dem ESP8266 (ein Kern mit 80 MHz, etwa 80 KB RAM, WLAN) gibt es in unterschiedlichen Versionen. Größter Unterschied ist die Breite: Die „Amica“-Variante (NodeMCU 1.0) passt so auf ein Steckbrett, dass man an beide Pinleisten kommt, die breitere „LoLin“-Variante nicht – hier lohnt also etwas Recherche vor dem Kauf.
Board-Treiber: „NodeMCU 1.0 (ESP-12E Module)“
Die kleinen Schaltpläne im Bild gibt es auch als Simulation im Falstad-Simulator.
Wichtig beim NodeMCU:
- Strapping-Pins sind GPIO0 (D3, FLASH-Taster: beim Start nicht LOW), GPIO2 (D4, eingebaute LED: beim Start HIGH) und GPIO15 (D8: beim Start LOW, Pull-down auf dem Board). D8 eignet sich deshalb für eine LED gegen GND, nicht für einen Taster.
- D0 (GPIO16) hat keinen Interrupt und keinen internen Pull-up. Er weckt aus dem Deep-Sleep, wenn er mit RST verbunden ist.
- A0 ist der einzige Analogeingang; der Spannungsteiler auf dem Board erlaubt 0 bis 3,3 V (der Chip selbst misst nur 0 bis 1 V).
- Nur wenige freie Pins: Mit I²C und SPI bleiben neben D0, D3 und D4 keine weiteren übrig. Deshalb gibt es zwei Listen. Ein Programm nimmt die Variante „mit I²C/SPI“ nur, wenn es einen Bus nutzt. Eine zweite PWM-LED und einen Summer gibt es in keiner Variante; Beispiele, die beides brauchen, erklären im NodeMCU-Tab, was dort geht.
Liste der Ein- und Ausgabeelemente ohne Bus (für alle Beispiele ohne I²C und SPI):
//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: NodeMCU ESP8266 (without I2C/SPI)
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable | Anschlusspin | Name, Verhalten
const int POTI_PIN = A0; // Potentiometer, only analog input, 0..1023 (0..3.3V on NodeMCU)
const int BUTTON1_PIN = 0; // D3, Button 1 = onboard FLASH button, active LOW, INPUT_PULLUP
const int BUTTON2_PIN = 14; // D5, Button 2, active LOW, INPUT_PULLUP
const int BUTTON3_PIN = 12; // D6, Button 3, active LOW, INPUT_PULLUP
const int BUTTON4_PIN = 13; // D7, Button 4, active LOW, INPUT_PULLUP
const int LED1_PIN = 16; // D0, LED 1, active HIGH (onboard LED on D0 of many boards lights inversely)
const int LED2_PIN = 5; // D1, LED 2, active HIGH
const int LED3_PIN = 4; // D2, LED 3, active HIGH
const int LED4_PIN = 15; // D8, LED 4, active HIGH (LED to GND keeps D8 LOW at boot)
const int LED_PWM1_PIN = 2; // D4, onboard LED, PWM, active LOW (external LED to 3V3)
// const int LED_PWM2_PIN = -1; // not available
// const int BUZZER_PIN = -1; // not available
const int BOOT_BUTTON_PIN = 0; // D3, onboard FLASH button (= BUTTON1_PIN), active LOW
const int ONBOARD_LED_PIN = 2; // D4, onboard LED of ESP-12 module (= LED_PWM1_PIN), active LOW
const int LED_PWM1_ON = LOW; // level that switches LED_PWM1 on (active LOW!)
const int ADC_MAX = 1023; // maximum value of analogRead()
const float ADC_VREF = 3.3; // voltage at ADC_MAX (voltage divider on NodeMCU board)
// reserved: GPIO1/3 (USB-Serial), GPIO6-11 (Flash)Liste mit I²C und SPI:
//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: NodeMCU ESP8266 (with I2C/SPI, only few free pins)
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable | Anschlusspin | Name, Verhalten
const int POTI_PIN = A0; // Potentiometer, only analog input, 0..1023 (0..3.3V on NodeMCU)
const int BUTTON1_PIN = 0; // D3, Button 1 = onboard FLASH button, active LOW, INPUT_PULLUP
// const int BUTTON2_PIN = -1; // not available (without bus: 14 = D5)
// const int BUTTON3_PIN = -1; // not available (without bus: 12 = D6)
// const int BUTTON4_PIN = -1; // not available (without bus: 13 = D7)
const int LED1_PIN = 16; // D0, LED 1, active HIGH (no interrupt, no internal pull-up; onboard LED on D0 of many boards is active LOW and lights inversely)
// const int LED2_PIN = -1; // not available (without bus: 5 = D1)
// const int LED3_PIN = -1; // not available (without bus: 4 = D2)
// const int LED4_PIN = -1; // not available (without bus: 15 = D8)
const int LED_PWM1_PIN = 2; // D4, onboard LED, PWM, active LOW (external LED to 3V3)
// const int LED_PWM2_PIN = -1; // not available
// const int BUZZER_PIN = -1; // not available
const int MCU_SDA = 4; // D2, GPIO of MCU connected to SDA-Pin of I2C device
const int MCU_SCL = 5; // D1, GPIO of MCU connected to SCL-Pin of I2C device
const int MCU_SCK = 14; // D5, GPIO of MCU connected to SCK-Pin of SPI device (HSPI)
const int MCU_MISO = 12; // D6, GPIO of MCU connected to MISO/SDO-Pin of SPI device
const int MCU_MOSI = 13; // D7, GPIO of MCU connected to MOSI/SDI-Pin of SPI device
const int MCU_CS = 15; // D8, GPIO of MCU connected to CS-Pin (must be LOW at boot)
const int BOOT_BUTTON_PIN = 0; // D3, onboard FLASH button (= BUTTON1_PIN), active LOW
const int ONBOARD_LED_PIN = 2; // D4, onboard LED of ESP-12 module (= LED_PWM1_PIN), active LOW
const int LED_PWM1_ON = LOW; // level that switches LED_PWM1 on (active LOW!)
const int ADC_MAX = 1023; // maximum value of analogRead()
const float ADC_VREF = 3.3; // voltage at ADC_MAX (voltage divider on NodeMCU board)
// reserved: GPIO1/3 (USB-Serial), GPIO6-11 (Flash)Arduino Uno
Der Arduino Uno Rev3 trägt den 8-Bit-Mikrocontroller ATmega328P mit 16 MHz, 32 KB Flash, 2 KB SRAM und 1 KB EEPROM. Anders als die ESP-Boards arbeitet er mit 5-V-Logik: Module, die nur 3,3 V vertragen, brauchen am Uno einen Pegelwandler. Dafür vertragen seine Pins mehr Strom (20 mA empfohlen, 40 mA absolut höchstens, alle Pins zusammen höchstens 200 mA).
Board-Treiber: „Arduino Uno“ (im Paket „Arduino AVR Boards“, schon in der Arduino-IDE enthalten)
Wichtig beim Uno:
- D0 und D1 sind die serielle Schnittstelle zum USB-Wandler. Wer sie belegt, stört das Hochladen und den seriellen Monitor.
- PWM nur an D3, D5, D6, D9, D10 und D11 (
~), mit etwa 490 Hz bzw. 980 Hz (D5, D6).tone()belegt den Timer 2 und schaltet damit PWM an D3 und D11 ab. - Externe Interrupts (
attachInterrupt) nur an D2 (INT0) und D3 (INT1). Deshalb liegenBUTTON1_PINundBUTTON2_PINdort. - Analoge Pins als digitale Pins: A0 bis A5 lassen sich auch mit
pinMode()unddigitalWrite()nutzen (Nummern 14 bis 19). Die LEDs 2 bis 4 liegen deshalb an A1 bis A3: So bleiben die PWM-Pins und die SPI-Pins frei. - Busse fest: I²C an A4 (SDA) und A5 (SCL), die beiden Pins sind zusätzlich neben AREF herausgeführt. SPI an D10 (SS) bis D13 (SCK) und am sechspoligen ICSP-Stecker. Die eingebaute LED „L“ hängt an D13 und flackert deshalb bei SPI-Übertragungen.
- ADC mit 10 Bit (0 bis 1023) bezogen auf 5 V; AREF bleibt unbeschaltet, solange man keine externe Referenz einstellt.
- Es gibt keinen BOOT-Taster, nur einen RESET-Taster; das Hochladen startet der Bootloader automatisch.
Das Fritzing-Bauteil des Uno gehört zum Lieferumfang von Fritzing (siehe Schaltungen zeichnen mit Fritzing).
Liste der Ein- und Ausgabeelemente (Standardbelegung):
//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: Arduino Uno (5V logic)
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable | Anschlusspin | Name, Verhalten
const int POTI_PIN = A0; // Potentiometer between 5V and GND, 0..1023
const int BUTTON1_PIN = 2; // Button 1, active LOW, INPUT_PULLUP (interrupt INT0)
const int BUTTON2_PIN = 3; // Button 2, active LOW, INPUT_PULLUP (interrupt INT1)
const int BUTTON3_PIN = 4; // Button 3, active LOW, INPUT_PULLUP
const int BUTTON4_PIN = 7; // Button 4, active LOW, INPUT_PULLUP
const int LED1_PIN = 8; // LED 1, active HIGH
const int LED2_PIN = A1; // LED 2, active HIGH (analog pin used as digital output)
const int LED3_PIN = A2; // LED 3, active HIGH
const int LED4_PIN = A3; // LED 4, active HIGH
const int LED_PWM1_PIN = 5; // LED with PWM (analogWrite), active HIGH
const int LED_PWM2_PIN = 6; // LED with PWM (analogWrite), active HIGH
const int BUZZER_PIN = 6; // passive buzzer (tone), shares pin with LED_PWM2_PIN
const int MCU_SDA = A4; // SDA-Pin of I2C device (fixed)
const int MCU_SCL = A5; // SCL-Pin of I2C device (fixed)
const int MCU_SCK = 13; // SCK-Pin of SPI device (fixed)
const int MCU_MISO = 12; // MISO-Pin of SPI device (fixed)
const int MCU_MOSI = 11; // MOSI-Pin of SPI device (fixed)
const int MCU_CS = 10; // CS-Pin of SPI device
// const int BOOT_BUTTON_PIN = -1; // not available (RESET button only)
const int ONBOARD_LED_PIN = 13; // onboard LED "L" (= MCU_SCK, flickers with SPI), active HIGH
const int LED_PWM1_ON = HIGH; // level that switches LED_PWM1 on
const int LED_PWM2_ON = HIGH; // level that switches LED_PWM2 on
const int ADC_MAX = 1023; // maximum value of analogRead()
const float ADC_VREF = 5.0; // voltage at ADC_MAX (default reference = 5V supply)
// reserved: D0/D1 (USB-Serial)
// I2C/SPI pins are fixed: only Wire.begin(); and SPI.begin(); without parametersPins testen: ein Programm für alle Boards
Ist alles richtig angeschlossen? Das folgende Programm prüft die Standardbelegung: Beim Start leuchten LED 1 bis 4 und die PWM-LED nacheinander auf. Danach schaltet jeder Taster seine LED, das Poti dimmt die PWM-LED, und alle 500 ms gibt der serielle Monitor (115 200 Baud) den Poti-Wert als Rohwert und als Spannung sowie den Zustand der vier Taster aus. Bleibt eine LED dunkel oder zeigt ein Taster nichts, stimmt die Verdrahtung oder die Polung nicht.
Liste für das ESP32-C6 DevKit N8-M. Der serielle Monitor läuft über die Buchse „UART“ (bzw. über die native USB-Buchse mit „USB CDC On Boot: Enabled“).
//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: ESP32-C6 Dev Kit N8-M
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable | Anschlusspin | Name, Verhalten
const int POTI_PIN = 0; // Potentiometer, ADC1_CH0, 0..4095
const int BUTTON1_PIN = 1; // Button 1, active LOW, INPUT_PULLUP
const int BUTTON2_PIN = 2; // Button 2, active LOW, INPUT_PULLUP
const int BUTTON3_PIN = 3; // Button 3, active LOW, INPUT_PULLUP
const int BUTTON4_PIN = 10; // Button 4, active LOW, INPUT_PULLUP
const int LED1_PIN = 4; // LED 1, active HIGH (strapping pin, ok as output)
const int LED2_PIN = 5; // LED 2, active HIGH (strapping pin, ok as output)
const int LED3_PIN = 6; // LED 3, active HIGH
const int LED4_PIN = 7; // LED 4, active HIGH
const int LED_PWM1_PIN = 11; // LED with PWM (analogWrite), active HIGH
const int LED_PWM1_ON = HIGH; // level that switches LED_PWM1 on
const int ADC_MAX = 4095; // maximum value of analogRead()
const float ADC_VREF = 3.3; // voltage at ADC_MAX (approx.; exact: analogReadMilliVolts())
//-------------------------------------------------------------------------------------
// Pintest: prueft die Standardbelegung (Taster 1-4, LED 1-4, PWM-LED 1, Poti)
//-------------------------------------------------------------------------------------
const int ANZAHL = 4; // je vier Taster und LEDs
const int BUTTON_PINS[ANZAHL] = {BUTTON1_PIN, BUTTON2_PIN, BUTTON3_PIN, BUTTON4_PIN};
const int LED_PINS[ANZAHL] = {LED1_PIN, LED2_PIN, LED3_PIN, LED4_PIN};
const unsigned long AUSGABE_MS = 500; // Abstand der Ausgaben im seriellen Monitor
unsigned long letzteAusgabe = 0;
void setup() {
Serial.begin(115200);
for (int i = 0; i < ANZAHL; i++) {
pinMode(BUTTON_PINS[i], INPUT_PULLUP);
pinMode(LED_PINS[i], OUTPUT);
}
pinMode(LED_PWM1_PIN, OUTPUT);
// Lauflicht beim Start: jede LED leuchtet einmal kurz auf
for (int i = 0; i < ANZAHL; i++) {
digitalWrite(LED_PINS[i], HIGH);
delay(300);
digitalWrite(LED_PINS[i], LOW);
}
digitalWrite(LED_PWM1_PIN, LED_PWM1_ON);
delay(300);
digitalWrite(LED_PWM1_PIN, !LED_PWM1_ON);
}
void loop() {
// Taster i gedrueckt (LOW) -> LED i leuchtet
for (int i = 0; i < ANZAHL; i++) {
if (digitalRead(BUTTON_PINS[i]) == LOW) {
digitalWrite(LED_PINS[i], HIGH);
} else {
digitalWrite(LED_PINS[i], LOW);
}
}
// Poti steuert die Helligkeit der PWM-LED
int rohwert = analogRead(POTI_PIN);
int helligkeit = map(rohwert, 0, ADC_MAX, 0, 255);
analogWrite(LED_PWM1_PIN, LED_PWM1_ON == HIGH ? helligkeit : 255 - helligkeit);
// alle 500 ms: Poti-Wert und Tasterzustand ausgeben
if (millis() - letzteAusgabe >= AUSGABE_MS) {
letzteAusgabe = millis();
float spannung = rohwert * ADC_VREF / ADC_MAX;
Serial.print(F("Poti: "));
Serial.print(rohwert);
Serial.print(F(" von "));
Serial.print(ADC_MAX);
Serial.print(F(" = "));
Serial.print(spannung, 2);
Serial.print(F(" V Taster 1-4: "));
for (int i = 0; i < ANZAHL; i++) {
Serial.print(digitalRead(BUTTON_PINS[i]) == LOW ? '1' : '0');
}
Serial.println();
}
}Die Listen für weitere Boards (ESP32 Dev Kit V1/V2, WeMos-Board mit OLED) stehen oben in diesem Artikel. Für das Dev Kit V1/V2 gilt der Tab „ESP32 (DevKit V4)“ unverändert; für das WeMos-Board fehlen Taster 3 und 4 sowie LED 4, dort lässt sich der Pintest nur gekürzt nutzen.
Die Programme der vier Tabs unterscheiden sich nur in der Liste. Der Pintest nutzt weder die zweite PWM-LED noch den Summer, weil es beide auf dem NodeMCU nicht gibt; sonst wäre der Code dort nicht gleich. Wie die Bauteile verdrahtet werden, zeigen die Steckbrettbilder in den Artikeln Digitale Eingänge, Digitale Ausgänge und Analoge Eingänge.
Funktion und Einschränkungen der Anschlusspins im Detail
Die Tabellen fassen zusammen, was die Datenblätter und die Arduino-Umgebung über die einzelnen Pins sagen. Sie helfen auch bei anderen Boards mit denselben Chips. Spalte „In“/„Out“ wie in der Legende oben.
ESP32 (ESP32-WROOM-32)
| Pin | In | Out | Beschreibung |
|---|---|---|---|
| GND | 0 V (GND, LOW) | ||
| 5V / VIN | 5 V direkt vom USB, Vorsicht! | ||
| 3V3 | 3,3 V (HIGH) | ||
| EN / RST | Pull-up, RST-Taster, startet den ESP neu | ||
| GPIO0 | pu | o | SP: HIGH = Programm starten, LOW = Download-Modus; BOOT-Taster; RTC, Touch, ADC2 |
| GPIO1 / TX | x | o | UART0-TX (USB, Serial.print()), Bootlog; Dev Kit V2: LED |
| GPIO2 | pd | o | SP: beim Download LOW oder offen; RTC, Touch, ADC2; Dev Kit V1: LED |
| GPIO3 / RX | i | x | UART0-RX (USB, Serial.read()), beim Start HIGH |
| GPIO4 | I | O | RTC, Touch, ADC2 (kein Strapping-Pin) |
| GPIO5 | pu | o | SP (Timing der SDIO-Schnittstelle), gibt beim Start ein PWM-Signal aus; SPI CS (VSPI) |
| GPIO6 bis GPIO11 | mit dem Flash-Speicher verbunden: nicht benutzen | ||
| GPIO12 | pd | O | SP: beim Start LOW (sonst Flash-Spannung 1,8 V); JTAG-MTDI, RTC, Touch, ADC2 |
| GPIO13 | I | O | JTAG-MTCK, RTC, Touch, ADC2 |
| GPIO14 | I | o | gibt beim Start ein PWM-Signal aus; JTAG-MTMS, RTC, Touch, ADC2 |
| GPIO15 | pu | o | SP: LOW beim Start schaltet das Bootlog ab; JTAG-MTDO, RTC, Touch, ADC2 |
| GPIO16 | I | O | UART2-RX (beim ESP32-WROVER mit dem PSRAM verbunden) |
| GPIO17 | I | O | UART2-TX (beim ESP32-WROVER mit dem PSRAM verbunden) |
| GPIO18 | I | O | SPI SCK (VSPI) |
| GPIO19 | I | O | SPI MISO (VSPI) |
| GPIO21 | I | O | I²C SDA (Standard) |
| GPIO22 | I | O | I²C SCL (Standard) |
| GPIO23 | I | O | SPI MOSI (VSPI) |
| GPIO25 | I | O | RTC, DAC1 (8 Bit), ADC2 |
| GPIO26 | I | O | RTC, DAC2 (8 Bit), ADC2 |
| GPIO27 | I | O | RTC, Touch, ADC2 |
| GPIO32 | I | O | RTC, Touch, ADC1 |
| GPIO33 | I | O | RTC, Touch, ADC1 |
| GPIO34, GPIO35 | i | x | ADC1, nur Eingang, kein interner Pull-up/Pull-down |
| GPIO36 (VP) | i | x | ADC1_CH0, nur Eingang, kein interner Pull-up/Pull-down |
| GPIO39 (VN) | i | x | ADC1_CH3, nur Eingang, kein interner Pull-up/Pull-down |
ESP32-C6 (ESP32-C6-WROOM-1)
| Pin | In | Out | Beschreibung |
|---|---|---|---|
| GND, 5V, 3V3, RST | wie beim ESP32 | ||
| GPIO0, GPIO1 | I | O | ADC1_CH0/CH1, LP-GPIO (weckt aus Deep-Sleep); Anschluss für einen 32-kHz-Quarz |
| GPIO2, GPIO3 | I | O | ADC1_CH2/CH3, LP-GPIO |
| GPIO4 | i | o | SP (MTMS), ADC1_CH4, LP-GPIO, JTAG-MTMS – als Ausgang unkritisch, nicht für Taster |
| GPIO5 | i | o | SP (MTDI), ADC1_CH5, LP-GPIO, JTAG-MTDI – als Ausgang unkritisch, nicht für Taster |
| GPIO6 | I | O | ADC1_CH6, LP-GPIO, JTAG-MTCK |
| GPIO7 | I | O | LP-GPIO, JTAG-MTDO |
| GPIO8 | i | o | SP: Bootmodus (mit GPIO9); eingebaute RGB-LED (WS2812) |
| GPIO9 | pu | o | SP: BOOT-Taster, LOW beim Reset = Download-Modus |
| GPIO10, GPIO11 | I | O | frei |
| GPIO12, GPIO13 | native USB (D−, D+): USB-Seriell und USB-JTAG – frei lassen | ||
| GPIO15 | i | o | SP: Auswahl der JTAG-Quelle (nur bei gesetzter eFuse) – als Ausgang unkritisch |
| GPIO16 | x | o | UART0-TX (Buchse „UART“, Serial.print()), Bootlog |
| GPIO17 | i | x | UART0-RX (Buchse „UART“, Serial.read()) |
| GPIO18 | I | O | SPI SS/CS (Standard) |
| GPIO19 | I | O | SPI MOSI (Standard) |
| GPIO20 | I | O | SPI MISO (Standard) |
| GPIO21 | I | O | SPI SCK (Standard) |
| GPIO22 | I | O | I²C SCL (Standard) |
| GPIO23 | I | O | I²C SDA (Standard) |
ESP8266 (NodeMCU)
| Pin | In | Out | Beschreibung |
|---|---|---|---|
| GND, 3V3, RST, EN | 0 V, 3,3 V, Reset (Pull-up), Chip Enable (Pull-up) | ||
| VIN | 5 V direkt vom USB, Vorsicht! | ||
| A0 | i | x | einziger Analogeingang (10 Bit); auf dem NodeMCU 0 bis 3,3 V über Spannungsteiler |
| D0 = GPIO16 | i | o | kein Interrupt, kein interner Pull-up (nur Pull-down); weckt aus Deep-Sleep (mit RST verbinden) |
| D1 = GPIO5 | I | O | I²C SCL (Standard) |
| D2 = GPIO4 | I | O | I²C SDA (Standard) |
| D3 = GPIO0 | pu | o | SP: beim Start HIGH, LOW = Flash-Modus; FLASH-Taster |
| D4 = GPIO2 | pu | o | SP: beim Start HIGH; eingebaute LED (aktiv LOW); Bootlog (TXD1) |
| D5 = GPIO14 | I | O | SPI SCK (HSPI) |
| D6 = GPIO12 | I | O | SPI MISO (HSPI) |
| D7 = GPIO13 | I | O | SPI MOSI (HSPI) |
| D8 = GPIO15 | pd | o | SP: beim Start LOW (Pull-down auf dem Board); SPI CS – nicht für Taster |
| RX = GPIO3 | i | x | UART0-RX (USB, Serial.read()) |
| TX = GPIO1 | x | o | UART0-TX (USB, Serial.print()), Bootlog |
| SD2, SD3 (GPIO9, 10), CMD, SD0, SD1, CLK | mit dem Flash-Speicher verbunden: nicht benutzen |
Arduino Uno (ATmega328P)
| Pin | In | Out | Beschreibung |
|---|---|---|---|
| GND | 0 V (GND, LOW) | ||
| 5V | 5 V (HIGH), vom USB oder vom Spannungsregler | ||
| 3V3 | 3,3 V, höchstens 50 mA | ||
| VIN | Eingang 7 bis 12 V (wie am Hohlstecker) | ||
| IOREF | zeigt Aufsteckplatinen die Logikspannung (5 V) | ||
| RESET | LOW = Neustart | ||
| AREF | Referenzspannung des ADC; frei lassen, solange keine externe Referenz eingestellt ist | ||
| D0 / RX | i | x | serielle Schnittstelle zum USB-Wandler, frei lassen |
| D1 / TX | x | o | serielle Schnittstelle zum USB-Wandler, frei lassen |
| D2 | I | O | externer Interrupt INT0 |
| D3 | I | O | PWM (490 Hz), externer Interrupt INT1 |
| D4, D7, D8 | I | O | frei |
| D5, D6 | I | O | PWM (980 Hz) |
| D9 | I | O | PWM (490 Hz) |
| D10 | I | O | PWM, SPI SS |
| D11 | I | O | PWM, SPI MOSI |
| D12 | I | O | SPI MISO |
| D13 | I | O | SPI SCK, eingebaute LED „L“ (über einen Verstärker angeschlossen) |
| A0 bis A3 | I | O | Analogeingänge (10 Bit), auch digital nutzbar (14 bis 17) |
| A4 / SDA | I | O | Analogeingang, I²C SDA |
| A5 / SCL | I | O | Analogeingang, I²C SCL |
Unterschiede der Boards
Was die Programme der Reihe auf den vier Boards unterschiedlich macht, steht in dieser Übersicht. Die Artikel gehen jeweils an der passenden Stelle darauf ein.
| Thema | ESP32-C6 | ESP32 (DevKit V4) | ESP8266 (NodeMCU) | Arduino Uno |
|---|---|---|---|---|
| Logikpegel | 3,3 V, nicht 5-V-tolerant | 3,3 V, nicht 5-V-tolerant | 3,3 V, nicht 5-V-tolerant | 5 V |
| Strom je Pin (Richtwert) | ca. 20–40 mA, Treiberstärke einstellbar | ca. 20–40 mA | ca. 12 mA | 20 mA empfohlen, 40 mA höchstens, Summe 200 mA |
int-Breite |
32 Bit | 32 Bit | 32 Bit | 16 Bit (−32 768 bis 32 767) |
| ADC | 12 Bit (0–4095), ADC1, auch mit WLAN | 12 Bit, ADC2 nicht mit WLAN | 10 Bit, nur A0 | 10 Bit, A0–A5, Referenz 5 V |
| DAC | keiner | GPIO25/26 | keiner | keiner |
| PWM | analogWrite() (LEDC, 6 Kanäle) |
analogWrite() (LEDC, 16 Kanäle) |
analogWrite() per Software |
nur 3, 5, 6, 9, 10, 11 |
| Interrupt-Pins | alle GPIO | alle GPIO | alle außer GPIO16 (D0) | nur 2 und 3 |
| Arbeitsspeicher | 512 KB SRAM | 520 KB SRAM | ca. 80 KB | 2 KB SRAM |
| Serieller Monitor | zwei USB-Buchsen; nativ nur mit „USB CDC On Boot“ | USB-Seriell-Wandler | USB-Seriell-Wandler | USB-Seriell-Wandler (D0/D1) |
| Eingebaute LED | RGB-LED WS2812 an GPIO8 | keine (V1: GPIO2) | D4 (GPIO2), aktiv LOW | D13 „L“ |
| Debugger | eingebauter USB-JTAG | externer JTAG-Adapter | keiner | keiner |
| Busse | Pins frei wählbar | Pins frei wählbar | I²C frei wählbar, SPI fest D5–D8 | fest (A4/A5, 10–13) |
| Strapping-Pins | GPIO4, 5, 8, 9, 15 | GPIO0, 2, 5, 12, 15 | GPIO0, 2, 15 (D3, D4, D8) | keine |
Table: Unterschiede der vier Boards, die in den Programmen der Reihe eine Rolle spielen
Leitfragen
- Woran erkenne ich im Pinout, ob ich einen Pin bedenkenlos nutzen kann?
Grün hinterlegte Pins mit großem I/O sind frei nutzbar. Gelbe Pins mit kleinem i/o haben Einschränkungen (Strapping-Pin, nur Eingang, eingebaute LED), rote sind für Flash-Speicher oder USB reserviert. siehe Abschnitt „Legende für die Pinouts“
- Was ist ein Strapping-Pin, und warum eignet sich D8 (GPIO15) am NodeMCU für eine LED, aber nicht für einen Taster?
Strapping-Pins wählen beim Start die Betriebsart. GPIO15 muss beim Start LOW sein. Eine LED gegen GND hält den Pin LOW, ein Taster gegen 3,3 V (sobald er beim Start gedrückt ist) oder ein Pull-up würde ihn auf HIGH ziehen, dann startet das Board nicht. siehe Abschnitt „NodeMCU (ESP8266)“
- Warum belegt keine Liste die Pins GPIO1/GPIO3 (ESP32), GPIO16/17 (ESP32-C6) oder D0/D1 (Uno)?
Über diese Pins laufen das Hochladen und der serielle Monitor (Serial.print()). Ein angeschlossenes Bauteil würde beides stören. siehe Abschnitt „Die Standardbelegung der Beispiele“
- Was muss ich ändern, wenn ich ein Programm aus dem ESP32-C6-Tab auf einem Arduino Uno laufen lassen will?
Nur die Liste der Ein- und Ausgabeelemente: die Zeilen mit denselben Namen aus der Uno-Liste übernehmen. Der übrige Code nutzt nur die Namen und Konstanten wie ADC_MAX und ADC_VREF und bleibt gleich. siehe Abschnitt „Pins testen: ein Programm für alle Boards“
- Warum liegt das Poti beim ESP32 Dev Kit an GPIO36 und nicht an GPIO25?
GPIO25 gehört zu ADC2, der bei aktivem WLAN nicht nutzbar ist. GPIO36 gehört zu ADC1 und funktioniert immer; dass er nur Eingang ist, stört beim Poti nicht. siehe Abschnitt „ESP32 Dev Kit V1, V2 und C V4“
- Warum heißt es beim Uno
Wire.begin();und nichtWire.begin(MCU_SDA, MCU_SCL);, und wann braucht man die zweite Form?
Beim Uno sind die I²C-Pins A4/A5 fest, die Form mit Pins lässt sich dort nicht übersetzen. Die ESP-Boards können I²C auf andere Pins legen; nötig ist das, wenn die Bauteile nicht an den Standardpins hängen, z. B. beim WeMos-Board mit OLED an GPIO5/4. siehe Abschnitt „Die Standardbelegung der Beispiele“
- Welche Pins nutze ich beim Uno für Interrupts und für PWM, und welche Folge hat
tone()?
Externe Interrupts gibt es nur an D2 und D3, PWM nur an D3, D5, D6, D9, D10 und D11. tone() belegt den Timer 2; PWM an D3 und D11 funktioniert dann nicht mehr. siehe Abschnitt „Arduino Uno“
- Wie schalte ich die eingebaute LED des ESP32-C6 ein?
Die LED ist eine RGB-LED vom Typ WS2812 an GPIO8 und lässt sich nicht mit digitalWrite() schalten, sondern z. B. mit rgbLedWrite(8, 0, 0, 255); (blau). siehe Abschnitt „ESP32-C6 DevKit N8-M“
Links und weitere Informationen
Datenblätter ESP32: ESP32 Technical Reference Manual, ESP32 Datasheet, ESP-IDF: GPIO-Übersicht ESP32
Datenblätter ESP32-C6: ESP32-C6 Datasheet, ESP-IDF: GPIO-Übersicht ESP32-C6, ESP32-C6-DevKitC-1 User Guide
ESP8266: ESP8266EX Datasheet, ESP8266 Arduino Core: Digital IO, Analog, PWM, Boot-Modi und Strapping-Pins
Arduino Uno: Arduino Uno Rev3 (Hersteller-Dokumentation), ATmega328P Datasheet bei Microchip
Standardpins der Arduino-Umgebung: arduino-esp32
variants/esp32c6/pins_arduino.h,variants/esp32/pins_arduino.h, ESP8266variants/nodemcu/pins_arduino.hTabellen zum Selbstanpassen: Fehlt etwas Wesentliches in einem Pinout? Ich bin für jeden Hinweis dankbar. Wer selbst anpassen oder ein weiteres Board ergänzen will, findet die Tabellen für ESP32, ESP32-C6 und ESP8266 und für das NodeMCU im Repository.
Fritzing-Bauteile der Boards: Schaltungen zeichnen mit Fritzing
Programm: Der Pintest liegt für alle vier Boards im Repository unter
src/mcu-pinout/pintest/.
Hinweis zur Nachnutzung als Open Educational Resource (OER)
Dieser Artikel und seine Texte, Bilder, Grafiken, Code und sonstiger Inhalt sind - sofern nicht anders angegeben - lizenziert unter CC BY 4.0. Nennung gemäß TULLU-Regel bitte wie folgt: “Pinbelegung der Mikrocontroller-Boards: ESP32-C6, ESP32, NodeMCU und Arduino Uno” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/mcu-pinout veröffentlicht, die Quelltexte sind in weiterverarbeitbarer Form verfügbar im Repository unter https://gitlab.com/oer-informatik/mcu/arduino-esp. Erstellt mit KI-Assistenz; von mir umfassend redaktionell überarbeitet, geprüft und freigegeben. Stand: 11.11.2026.
[Kommentare zum Artikel lesen, schreiben] / [Artikel teilen] / [gitlab-Issue zum Artikel schreiben]
