Erste Schritte mit dem Mikrocontroller: Entwicklungsumgebung, Board, Blink und Taster

Erste Schritte mit dem Mikrocontroller: Entwicklungsumgebung, Board, Blink und Taster

https://bildung.social/@oerinformatik/

https://oer-informatik.de/mcu-erste-schritte

Mikrocontroller, Arduino-IDE, ESP32-C6, ESP32, ESP8266, Arduino Uno, Boardverwalter, USB-Treiber, Blink, Taster, INPUT_PULLUP

tl/dr; (ca. 23 min Lesezeit): Kein Mikrocontroller-Projekt ohne blinkende LED. Hier richtest Du die Arduino-IDE mit Board-Paket, Treiber und Port ein, lernst den Aufbau eines Programms mit setup() und loop() kennen, lässt eine LED blinken und liest einen Taster ein – für ESP32-C6, ESP32, ESP8266 (NodeMCU) und Arduino Uno. Zum Schluss geht es um die typischen Fehler beim Hochladen [AI-Assisted]. (Zuletzt geändert am 10.11.2026)

Dieser Artikel ist Teil einer Artikelreihe über Mikrocontroller-Grundlagen: Erste Schritte / Digitale Ausgänge / Digitale Eingänge / Variablen und Datentypen / Pinbelegung der Boards

Schon fit in diesem Thema? Nutze die Kann-Liste und die Leitfragen unter dem Artikel als Checkliste, ob Du die relevanten Kompetenzen bereits hast. Hier klicken, um Kann-Liste ein- oder auszublenden

Keine neue Programmiersprache ohne ein „Hello World“, kein Mikrocontroller ohne blinkende LED. In diesem Artikel gehst Du die ersten Schritte mit einem Mikrocontroller-Board: Du richtest die Arduino-IDE ein, bringst den Rechner dazu, das Board zu erkennen, und lädst zwei kleine Programme hoch. Die Schritte ähneln sich bei allen Boards. Wo sie sich unterscheiden, gibt es Registerkarten (Tabs) für das ESP32-C6 DevKit (voreingestellt), das klassische ESP32 DevKit V4, den NodeMCU mit ESP8266 und den Arduino Uno. Ein Klick auf einen Tab schaltet alle Tabs des Artikels um.

Am Ende steht diese kleine Schaltung auf dem Steckbrett: eine LED mit Vorwiderstand und ein Taster.

Zum Üben gibt es eigene Übungsaufgaben zu den ersten Schritten mit dem Mikrocontroller.

Schritt 1: Arduino-IDE installieren und Board-Pakete einrichten

Wir programmieren mit der Arduino-IDE (Version 2.x), die es für Windows, macOS und Linux unter arduino.cc/en/software gibt. Die IDE selbst ist nur der Editor. Was ein Programm für einen bestimmten Mikrocontroller übersetzt und hochlädt, steckt im Board-Paket (board package, auch Core genannt). Ein Board-Paket bringt die ganze Toolchain mit:

• den Compiler für die Prozessorarchitektur (AVR beim Uno, Xtensa beim ESP32 und ESP8266, RISC-V beim ESP32-C6),

• den Arduino-Core, also die Umsetzung von Befehlen wie pinMode(), digitalWrite() und delay() für diesen Chip,

• das Hochladewerkzeug (avrdude beim Uno, esptool bei den ESP-Boards) und die Board-Definitionen mit Pinnamen.

Für den Arduino Uno ist das Paket „Arduino AVR Boards“ schon installiert. Für die ESP-Boards trägst Du unter Datei/Einstellungen (File/Preferences) bei „Zusätzliche Boardverwalter-URLs“ (Additional boards manager URLs) die Adresse des Herstellers ein. Mehrere URLs werden durch Komma getrennt:

ESP32-C6 ESP32 (DevKit V4) ESP8266 (NodeMCU) Arduino Uno all none

https://espressif.github.io/arduino-esp32/package_esp32_index.json

https://espressif.github.io/arduino-esp32/package_esp32_index.json

https://arduino.esp8266.com/stable/package_esp8266com_index.json

Nach einem Klick auf „OK“ lädt die IDE die Paketliste. Öffne dann den Boardverwalter (Werkzeuge/Board/Boardverwalter, Strg+Umschalt+B, oder das Board-Symbol links), suche nach „esp32“ (Espressif Systems) bzw. „esp8266“ (ESP8266 Community) und klicke auf „Installieren“:

Bibliotheken werden ähnlich installiert: über den Bibliotheksverwalter (Werkzeuge/Bibliotheken verwalten, Strg+Umschalt+I). Für die Programme dieses Artikels brauchst Du keine; Sensoren und Anzeigen in späteren Artikeln dagegen schon. Wer ein Test- oder Prüfsystem für andere einrichtet, notiert sich die Versionen von IDE, Board-Paket und Bibliotheken. Dann lässt sich die Umgebung später genau so wieder aufbauen.

Schritt 2: USB-Treiber installieren und den Port finden

Der Rechner spricht mit dem Board über eine serielle Schnittstelle, die per USB „getunnelt“ wird. Auf den meisten Boards sitzt dafür ein USB-Seriell-Wandler (USB-to-UART bridge). Unter Windows bekommt das Board einen COM-Port (COM3, COM4, …), unter Linux heißt er z. B. /dev/ttyUSB0, unter macOS /dev/cu.usbserial-…. Die Nummer hängt davon ab, welche Geräte schon angeschlossen waren. Am einfachsten findest Du sie, indem Du das Board ab- und wieder ansteckst und beobachtest, welcher Port verschwindet und wieder auftaucht.

In der IDE wählst Du den Port unter Werkzeuge/Port:

Erscheint kein neuer Port, fehlt meist der Treiber für den USB-Seriell-Wandler. Welcher Chip verbaut ist, verrät der Geräte-Manager oder diese PowerShell-Abfrage:

Get-PnpDevice -PresentOnly | Where-Object {($_.PNPDeviceID -like "USB*")} | Format-Table -Property Class, Name, Description, PNPDeviceID

Ein paar typische Antworten (gekürzt):

Class Name                                          PNPDeviceID
----- ----                                          -----------
Ports Silicon Labs CP210x USB to UART Bridge (COM7) USB\VID_10C4&PID_EA60\0001
Ports USB-SERIAL CH340 (COM6)                       USB\VID_1A86&PID_7523\6&24E558FB&0&4
Ports USB-Enhanced-SERIAL CH343 (COM3)              USB\VID_1A86&PID_55D3\5735020188
Ports USB Serial Device (COM4)                      USB\VID_303A&PID_1001&MI_00\7&84C9D3C&0&0000

• CP210x von Silicon Labs (VID_10C4) ist am häufigsten; der Treiber ist meist schon im System. Sonst gibt es ihn auf der Treiberseite von Silicon Labs.

• CH340/CH343 von WCH (VID_1A86) braucht oft einen eigenen Treiber. Ihn gibt es auf der Seite des Herstellers WCH (Datei CH341SER.EXE).

• USB Serial Device mit VID_303A ist die eingebaute USB-Schnittstelle neuerer ESP32-Chips (C3, C6, S3). Sie braucht keinen zusätzlichen Treiber.

Steht das Gerät ohne Eintrag in der Spalte „Class“ in der Liste, ist der Chip erkannt, aber der Treiber fehlt. Nach dem Herunterladen und Entpacken wählst Du im Geräte-Manager das unbekannte Gerät, dann „Treiber aktualisieren“ und „Auf meinem Computer nach Treibern suchen“ mit dem Pfad zum entpackten Treiber:

Taucht gar nichts auf, ist oft das USB-Kabel schuld: Manche Kabel sind reine Ladekabel ohne Datenleitungen.

ESP32-C6 ESP32 (DevKit V4) ESP8266 (NodeMCU) Arduino Uno all none

Schritt 3: Das richtige Board wählen

Der häufigste Fehler beim Hochladen ist ein falsch gewähltes Board oder ein falscher Port. Tauchen Fehler auf, prüfst Du immer zuerst diese beiden Einstellungen. Das Board wählst Du unter Werkzeuge/Board. Dort sind die Boards nach Paketen gruppiert:

ESP32-C6 ESP32 (DevKit V4) ESP8266 (NodeMCU) Arduino Uno all none

Wähle Werkzeuge/Board/esp32/ESP32 Dev Module. Auf dem Modul steht „ESP32-WROOM-32“ (bei manchen Boards „ESP32-WROVER“; dann ebenfalls ESP32 Dev Module oder ESP32 Wrover Module). Steht auf dem Modul eine andere Chipbezeichnung (C3, S2, S3, C6 …), wählst Du das Board mit dieser Bezeichnung.

Das DevKit V4 hat keine LED, die sich per Programm schalten lässt; nur das ältere DevKit V1 hat eine blaue LED an GPIO2.

Wähle Werkzeuge/Board/esp8266/NodeMCU 1.0 (ESP-12E Module).

Der NodeMCU hat zwei eingebaute LEDs (an D4 und D0) und den Taster „FLASH“ an D3. Die Lage zeigt das Foto:

Damit ist alles startbereit für das erste Programm – in der Arduino-Welt heißt es Sketch.

Schritt 4: So ist ein Arduino-Programm aufgebaut

Ein Sketch besteht im Kern aus drei Teilen, die Du selbst schreibst:

• Ganz oben steht die Liste der Ein- und Ausgabeelemente: Konstanten, die festhalten, an welchem Pin welches Bauteil hängt. Ändert sich die Verdrahtung oder das Board, änderst Du nur diese Liste.

• Die Funktion setup() wird nach dem Einschalten oder einem Reset genau einmal ausgeführt. Hier legst Du z. B. fest, welcher Pin Eingang und welcher Ausgang ist.

• Die Funktion loop() wird danach immer wieder aufgerufen, solange das Board läuft. Hier steht die eigentliche Programmlogik.

Was Du nicht siehst: Vor setup() richtet eine verborgene Funktion init() den Mikrocontroller ein (Takt, Timer für delay() und millis()), und die Dauerschleife, die loop() aufruft, steckt in einer verborgenen main()-Funktion. Das Aktivitätsdiagramm zeigt den Ablauf:

Ein Mikrocontroller-Programm endet also nicht von selbst: Es läuft, bis die Spannung weg ist oder jemand Reset drückt. Danach beginnt alles wieder von vorn.

Schritt 5: Die LED blinken lassen

Als erstes Programm lassen wir eine LED blinken. Wir nutzen dafür bei allen Boards eine externe LED (LED 1) mit einem Vorwiderstand von etwa 220 Ω gegen GND. Die eingebauten LEDs sind von Board zu Board zu verschieden: Das DevKit V4 hat keine, beim ESP32-C6 ist es eine RGB-LED mit eigenem Protokoll. Die Anode (langes Bein) zeigt zum Mikrocontroller-Pin, die Kathode (kurzes Bein, abgeflachte Seite) über den Widerstand bzw. direkt zu GND. Wie man den Vorwiderstand berechnet, steht im Artikel Digitale Ausgänge. Den Taster stecken wir schon mit, er kommt in Schritt 7 dran.

ESP32-C6 ESP32 (DevKit V4) ESP8266 (NodeMCU) Arduino Uno all none

Die Fritzing-Datei zum Nachbauen: mcu-erste-schritte-steckbrett-esp32c6.fzz

Das DevKit V4 ist so breit, dass auf einem normalen Steckbrett kaum Löcher frei bleiben. Wir legen es daneben und verbinden es mit Kabeln:

Die Fritzing-Datei zum Nachbauen: mcu-erste-schritte-steckbrett-esp32.fzz

Verdrahtung am NodeMCU: Pin D0 → 220-Ω-Widerstand → Anode der LED, Kathode → GND. Taster 1 ist der eingebaute FLASH-Taster an D3. Ein externer Taster zwischen D3 und GND ist nur nötig, wenn Du einen größeren Taster auf dem Steckbrett nutzen willst; er liegt parallel zum FLASH-Taster und wirkt genauso. Das Board ist so breit, dass wir es neben das Steckbrett legen:

Die Fritzing-Datei zum Nachbauen: mcu-erste-schritte-steckbrett-esp8266.fzz

Verdrahtung am Uno: Pin 8 → 220-Ω-Widerstand → Anode der LED, Kathode → GND; Taster 1 zwischen Pin 2 und GND. Bei 5 V fließen durch die LED etwa 13 mA, mit 330 Ω etwa 9 mA – beides ist unkritisch.

Die Fritzing-Datei zum Nachbauen: mcu-erste-schritte-steckbrett-uno.fzz

Das Programm legt in setup() den LED-Pin als Ausgang fest. In loop() schaltet es die LED mit digitalWrite() ein (HIGH: der Pin liefert 3,3 V bzw. beim Uno 5 V) und wieder aus (LOW: der Pin liegt auf 0 V). Dazwischen hält delay() das Programm für die angegebene Zahl von Millisekunden an:

ESP32-C6 ESP32 (DevKit V4) ESP8266 (NodeMCU) Arduino Uno all none

//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: ESP32-C6 Dev Kit N8-M
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable   | Anschlusspin      | Name, Verhalten
const int     LED1_PIN            = 4;                // LED 1, active HIGH (strapping pin, ok as output)

void setup() {
  pinMode(LED1_PIN, OUTPUT);          // Pin der LED als Ausgang festlegen
}

void loop() {
  digitalWrite(LED1_PIN, HIGH);       // LED an: Pin liegt auf 3,3 V (Uno: 5 V)
  delay(200);                         // 200 ms warten
  digitalWrite(LED1_PIN, LOW);        // LED aus: Pin liegt auf 0 V
  delay(800);                         // 800 ms warten
}

//-------------------------------------------------------------------------------------
// 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     LED1_PIN            = 27;               // LED 1, active HIGH

void setup() {
  pinMode(LED1_PIN, OUTPUT);          // Pin der LED als Ausgang festlegen
}

void loop() {
  digitalWrite(LED1_PIN, HIGH);       // LED an: Pin liegt auf 3,3 V (Uno: 5 V)
  delay(200);                         // 200 ms warten
  digitalWrite(LED1_PIN, LOW);        // LED aus: Pin liegt auf 0 V
  delay(800);                         // 800 ms warten
}

//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: NodeMCU ESP8266 (without I2C/SPI)
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable   | Anschlusspin      | Name, Verhalten
const int     LED1_PIN            = 16;               // D0, LED 1, active HIGH (onboard LED on D0 of many boards lights inversely)

void setup() {
  pinMode(LED1_PIN, OUTPUT);          // Pin der LED als Ausgang festlegen
}

void loop() {
  digitalWrite(LED1_PIN, HIGH);       // LED an: Pin liegt auf 3,3 V (Uno: 5 V)
  delay(200);                         // 200 ms warten
  digitalWrite(LED1_PIN, LOW);        // LED aus: Pin liegt auf 0 V
  delay(800);                         // 800 ms warten
}

//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: Arduino Uno (5V logic)
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable   | Anschlusspin      | Name, Verhalten
const int     LED1_PIN            = 8;                // LED 1, active HIGH

void setup() {
  pinMode(LED1_PIN, OUTPUT);          // Pin der LED als Ausgang festlegen
}

void loop() {
  digitalWrite(LED1_PIN, HIGH);       // LED an: Pin liegt auf 3,3 V (Uno: 5 V)
  delay(200);                         // 200 ms warten
  digitalWrite(LED1_PIN, LOW);        // LED aus: Pin liegt auf 0 V
  delay(800);                         // 800 ms warten
}

Die Listen der Ein- und Ausgabeelemente für weitere Boards (ESP32 Dev Kit V1/V2, WeMos-Board mit OLED) stehen im Artikel Pinbelegung der Mikrocontroller-Boards.

Kopiere das Programm für Dein Board in die IDE und klicke auf „Hochladen“ (Pfeil nach rechts, Strg+U). Die IDE übersetzt erst (das allein geht auch mit dem Haken „Überprüfen“, Strg+R) und lädt dann hoch. Erscheint unten „Hochladen abgeschlossen“ (bzw. „Hard resetting via RTS pin…“ bei den ESP-Boards), leuchtet die LED einmal pro Sekunde kurz auf: 200 ms an, 800 ms aus.

Schritt 6: HIGH-aktiv oder LOW-aktiv?

Unsere LED hängt zwischen Pin und GND. Sie leuchtet, wenn der Pin HIGH ist, weil dann eine Spannung über LED und Widerstand anliegt. Man nennt sie HIGH-aktiv. Hängt eine LED dagegen zwischen der Versorgungsspannung (3,3 V bzw. 5 V) und dem Pin, leuchtet sie gerade bei LOW: Dann liegt auf der einen Seite die Versorgungsspannung, auf der anderen 0 V. Bei HIGH haben beide Seiten dasselbe Potenzial, es fließt kein Strom. Diese LED ist LOW-aktiv. Dasselbe Programm erzeugt an einer LOW-aktiven LED also das umgekehrte Muster: 200 ms aus, 800 ms an.

Damit Programme auf allen Boards gleich funktionieren, steht in unseren Listen für LEDs, deren Pegel vom Board abhängt, eine Konstante …_ON mit dem Pegel, der die LED einschaltet. Der Code schaltet dann nicht mit HIGH/LOW, sondern so:

digitalWrite(LED_PWM1_PIN, LED_PWM1_ON);    // LED an – egal ob HIGH- oder LOW-aktiv
digitalWrite(LED_PWM1_PIN, !LED_PWM1_ON);   // LED aus

ESP32-C6 ESP32 (DevKit V4) ESP8266 (NodeMCU) Arduino Uno all none

Beim NodeMCU sind beide eingebauten LEDs LOW-aktiv. Die LED auf dem ESP-12-Modul hängt über einen Widerstand zwischen 3,3 V und D4 (GPIO2):

Liegt an D4 LOW, fließt Strom und die LED leuchtet. In unserer Standardbelegung ist D4 deshalb LED_PWM1_PIN mit LED_PWM1_ON = LOW. Die zweite eingebaute LED hängt genauso an D0 – also an dem Pin, an dem unsere externe LED 1 hängt:

Lässt Du das Blink-Programm laufen, blinken deshalb zwei LEDs genau gegeneinander: die externe LED 1 (HIGH-aktiv, 200 ms an) und die Onboard-LED an D0 (LOW-aktiv, 800 ms an).

Mehr zu LEDs an Ausgängen, Vorwiderständen und Strömen steht im Artikel Digitale Ausgänge.

Schritt 7: Einen Taster einlesen

Jetzt soll das Programm auf einen Taster reagieren. Ein digitaler Eingang unterscheidet nur zwei Zustände: HIGH und LOW. Ein offener Taster liefert aber gar kein Signal – der Eingang würde „in der Luft hängen“ (floating) und zufällig mal HIGH, mal LOW lesen. Deshalb schaltet pinMode(BUTTON1_PIN, INPUT_PULLUP); im Mikrocontroller einen Pull-up-Widerstand (einige 10 kΩ) zwischen Eingang und Versorgungsspannung zu:

• Taster offen: Der Pull-up-Widerstand zieht den Eingang auf HIGH.

• Taster gedrückt: Der Taster verbindet den Eingang mit GND, digitalRead() liefert LOW.

Der Taster ist also LOW-aktiv: gedrückt heißt LOW. Weil der Widerstand eingebaut ist, brauchst Du außer dem Taster kein weiteres Bauteil. Das Programm blinkt langsam, solange der Taster offen ist, und schnell, solange er gedrückt ist. Zusätzlich gibt es über den seriellen Monitor aus, was es gerade tut:

ESP32-C6 ESP32 (DevKit V4) ESP8266 (NodeMCU) Arduino Uno all none

//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: ESP32-C6 Dev Kit N8-M
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable   | Anschlusspin      | Name, Verhalten
const int     BUTTON1_PIN         = 1;                // Button 1, active LOW, INPUT_PULLUP
const int     LED1_PIN            = 4;                // LED 1, active HIGH (strapping pin, ok as output)

void setup() {
  Serial.begin(115200);                 // serieller Monitor mit 115200 Baud
  pinMode(BUTTON1_PIN, INPUT_PULLUP);   // interner Pull-up: nicht gedrückt = HIGH
  pinMode(LED1_PIN, OUTPUT);
}

void loop() {
  int pauseMs;                          // Länge der Pause in Millisekunden

  if (digitalRead(BUTTON1_PIN) == LOW) {  // Taster gedrückt: Eingang mit GND verbunden
    pauseMs = 200;                      // schnell blinken
    Serial.println("Taster gedrückt: schnelles Blinken");
  } else {
    pauseMs = 1200;                     // langsam blinken
    Serial.println("Taster nicht gedrückt: langsames Blinken");
  }

  digitalWrite(LED1_PIN, HIGH);         // kurz aufleuchten
  delay(200);
  digitalWrite(LED1_PIN, LOW);
  delay(pauseMs);                       // Pause je nach Taster
}

//-------------------------------------------------------------------------------------
// 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     BUTTON1_PIN         = 32;               // Button 1, active LOW, INPUT_PULLUP
const int     LED1_PIN            = 27;               // LED 1, active HIGH

void setup() {
  Serial.begin(115200);                 // serieller Monitor mit 115200 Baud
  pinMode(BUTTON1_PIN, INPUT_PULLUP);   // interner Pull-up: nicht gedrückt = HIGH
  pinMode(LED1_PIN, OUTPUT);
}

void loop() {
  int pauseMs;                          // Länge der Pause in Millisekunden

  if (digitalRead(BUTTON1_PIN) == LOW) {  // Taster gedrückt: Eingang mit GND verbunden
    pauseMs = 200;                      // schnell blinken
    Serial.println("Taster gedrückt: schnelles Blinken");
  } else {
    pauseMs = 1200;                     // langsam blinken
    Serial.println("Taster nicht gedrückt: langsames Blinken");
  }

  digitalWrite(LED1_PIN, HIGH);         // kurz aufleuchten
  delay(200);
  digitalWrite(LED1_PIN, LOW);
  delay(pauseMs);                       // Pause je nach Taster
}

//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: NodeMCU ESP8266 (without I2C/SPI)
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable   | Anschlusspin      | Name, Verhalten
const int     BUTTON1_PIN         = 0;                // D3, Button 1 = onboard FLASH button, active LOW, INPUT_PULLUP
const int     LED1_PIN            = 16;               // D0, LED 1, active HIGH (onboard LED on D0 of many boards lights inversely)

void setup() {
  Serial.begin(115200);                 // serieller Monitor mit 115200 Baud
  pinMode(BUTTON1_PIN, INPUT_PULLUP);   // interner Pull-up: nicht gedrückt = HIGH
  pinMode(LED1_PIN, OUTPUT);
}

void loop() {
  int pauseMs;                          // Länge der Pause in Millisekunden

  if (digitalRead(BUTTON1_PIN) == LOW) {  // Taster gedrückt: Eingang mit GND verbunden
    pauseMs = 200;                      // schnell blinken
    Serial.println("Taster gedrückt: schnelles Blinken");
  } else {
    pauseMs = 1200;                     // langsam blinken
    Serial.println("Taster nicht gedrückt: langsames Blinken");
  }

  digitalWrite(LED1_PIN, HIGH);         // kurz aufleuchten
  delay(200);
  digitalWrite(LED1_PIN, LOW);
  delay(pauseMs);                       // Pause je nach Taster
}

//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: Arduino Uno (5V logic)
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable   | Anschlusspin      | Name, Verhalten
const int     BUTTON1_PIN         = 2;                // Button 1, active LOW, INPUT_PULLUP (interrupt INT0)
const int     LED1_PIN            = 8;                // LED 1, active HIGH

void setup() {
  Serial.begin(115200);                 // serieller Monitor mit 115200 Baud
  pinMode(BUTTON1_PIN, INPUT_PULLUP);   // interner Pull-up: nicht gedrückt = HIGH
  pinMode(LED1_PIN, OUTPUT);
}

void loop() {
  int pauseMs;                          // Länge der Pause in Millisekunden

  if (digitalRead(BUTTON1_PIN) == LOW) {  // Taster gedrückt: Eingang mit GND verbunden
    pauseMs = 200;                      // schnell blinken
    Serial.println("Taster gedrückt: schnelles Blinken");
  } else {
    pauseMs = 1200;                     // langsam blinken
    Serial.println("Taster nicht gedrückt: langsames Blinken");
  }

  digitalWrite(LED1_PIN, HIGH);         // kurz aufleuchten
  delay(200);
  digitalWrite(LED1_PIN, LOW);
  delay(pauseMs);                       // Pause je nach Taster
}

Die Listen der Ein- und Ausgabeelemente für weitere Boards (ESP32 Dev Kit V1/V2, WeMos-Board mit OLED) stehen im Artikel Pinbelegung der Mikrocontroller-Boards.

Öffne nach dem Hochladen den seriellen Monitor (Werkzeuge/Serieller Monitor, Strg+Umschalt+M) und stelle unten rechts 115200 Baud ein – denselben Wert wie in Serial.begin(115200). Bei einem anderen Wert erscheinen nur wirre Zeichen.

ESP32-C6 ESP32 (DevKit V4) ESP8266 (NodeMCU) Arduino Uno all none

Der FLASH-Taster ist auf dem NodeMCU fest verdrahtet: Zwischen D3 (GPIO0) und 3,3 V liegt ein Pull-up von 12 kΩ, zwischen Taster und GND ein Schutzwiderstand von 470 Ω. Gedrückt liegen an D3 deshalb nicht genau 0 V, sondern

U_{D3} = 3{,}3\ \mathrm{V} \cdot \frac{470\ \Omega}{12\,000\ \Omega + 470\ \Omega} \approx 0{,}12\ \mathrm{V}

Der ESP8266 erkennt laut Datenblatt Spannungen bis 0{,}25 \cdot 3{,}3\ \mathrm{V} \approx 0{,}8\ \mathrm{V} sicher als LOW. Das passt also.

Wie man Taster mit externen Pull-up- und Pull-down-Widerständen anschließt und warum Taster „prellen“, steht im Artikel Digitale Eingänge.

Schritt 8: Wenn das Hochladen nicht klappt

Die meisten Probleme in den ersten Stunden haben mit dem Hochladen zu tun. Die Meldungen im Ausgabefenster unten in der IDE helfen bei der Suche:

Hilft das alles nicht, schaltest Du unter Datei/Einstellungen die „Ausführliche Ausgabe während Kompilierung und Hochladen“ ein. Dann zeigt die IDE jeden Schritt mit allen Befehlen an.

Unter der Haube: Wo steckt die versteckte main()-Funktion?

Für alle, die es genau wissen wollen: Wer C oder C++ kennt, vermisst in einem Sketch die Funktion main(), mit der jedes C-Programm beginnt. Es gibt sie – sie steckt im Arduino-Core des Board-Pakets. Bei der Arduino-IDE 2.x liegen die Board-Pakete unter Windows im Benutzerordner, für den Uno z. B. hier:

C:\Users\<Name>\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.8.6\cores\arduino\main.cpp

In dieser Datei steht die main()-Funktion. Sie ruft init(), setup() und in einer Endlosschleife (for (;;)) immer wieder loop() auf – genau den Ablauf aus dem Aktivitätsdiagramm in Schritt 4:

int main(void)
{
    init();

    initVariant();

#if defined(USBCON)
    USBDevice.attach();
#endif

    setup();

    for (;;) {
        loop();
        if (serialEventRun) serialEventRun();
    }

    return 0;
}

Bei den ESP32-Boards ist das Gerüst etwas aufwendiger, weil dort ein kleines Echtzeitbetriebssystem (FreeRTOS) läuft. In …\packages\esp32\hardware\esp32\<Version>\cores\esp32\main.cpp startet app_main() eine Aufgabe (Task) loopTask, die einmal setup() und dann in einer Endlosschleife loop() aufruft. Der Grundaufbau ist also derselbe. Was beim Übersetzen aus dem Sketch, dem Core und main.cpp wird, zeigt der Artikel Vom Sketch zur Firmware.

Wie geht es weiter?

Im nächsten Artikel geht es um digitale Ausgänge: mehrere LEDs, Vorwiderstände und Ströme. Danach folgen digitale Eingänge mit externen Pull-up- und Pull-down-Widerständen. Welche Pins der Boards Du gefahrlos verwenden kannst, steht in der Pinbelegung der Boards. Zum Üben gibt es die Übungsaufgaben zu den ersten Schritten mit dem Mikrocontroller.

Leitfragen

1. Was bringt ein Board-Paket mit, und wie installierst Du es für ein ESP32-Board? Antwort

Ein Board-Paket enthält die Toolchain für den Chip: Compiler, Arduino-Core und Hochladewerkzeug. Für ESP32-Boards trägst Du die Boardverwalter-URL von Espressif in den Einstellungen ein und installierst dann im Boardverwalter das Paket „esp32“. siehe Abschnitt „Schritt 1“

2. Woran erkennst Du, dass der Treiber für den USB-Seriell-Wandler fehlt, und wie findest Du den richtigen? Antwort

Beim Anstecken erscheint unter Werkzeuge/Port kein neuer Port, im Geräte-Manager steht ein Gerät ohne Klasse. Die Kennung (z. B. VID_10C4 für CP210x, VID_1A86 für CH340) verrät den Chip, dessen Treiber Du beim Hersteller lädst. siehe Abschnitt „Schritt 2“

3. Was unterscheidet setup() und loop()? Antwort

setup() läuft nach dem Einschalten oder einem Reset genau einmal und richtet z. B. die Pins ein. loop() wird danach von der verborgenen main()-Funktion immer wieder aufgerufen und enthält die Programmlogik. siehe Abschnitt „Schritt 4“

4. Wann ist eine LED LOW-aktiv, und was bedeutet das für das Programm? Antwort

Eine LED zwischen Versorgungsspannung und Pin leuchtet, wenn der Pin LOW ist. Das Programm muss sie also mit LOW einschalten – oder mit einer Konstanten wie LED_PWM1_ON, die den Einschaltpegel je Board festhält. siehe Abschnitt „Schritt 6“

5. Warum liefert ein mit INPUT_PULLUP eingelesener Taster beim Drücken LOW? Antwort

Der interne Pull-up-Widerstand zieht den offenen Eingang auf HIGH. Der gedrückte Taster verbindet den Eingang mit GND, deshalb liest digitalRead() dann LOW. siehe Abschnitt „Schritt 7“

6. Das Hochladen auf ein ESP32-Board bricht mit „Failed to connect“ ab. Was kannst Du tun? Antwort

Prüfe zuerst Board und Port. Springt das Board nicht von selbst in den Programmiermodus, hältst Du den BOOT-Taster gedrückt, bis „Connecting…“ erscheint. Hilft das nicht, Kabel und Treiber prüfen. siehe Abschnitt „Schritt 8“

Links und weitere Informationen

• als Nachschlagewerk: Arduino-Sprachreferenz mit allen Befehlen wie pinMode(), digitalWrite() und delay()

• für den Einstieg in die IDE: Dokumentation der Arduino-IDE 2

• für ESP32 und ESP32-C6: Dokumentation des Arduino-Cores von Espressif mit Installationsanleitung und Board-Übersicht

• für den ESP8266: Dokumentation des ESP8266-Arduino-Cores

• als Primärquelle: Datenblätter und technische Referenzen der Chips bei Espressif

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: “Erste Schritte mit dem Mikrocontroller: Entwicklungsumgebung, Board, Blink und Taster” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/mcu-erste-schritte 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: 10.11.2026.

[Kommentare zum Artikel lesen, schreiben] / [Artikel teilen] / [gitlab-Issue zum Artikel schreiben]