Mikrocontroller-Grundlagen: Lernpfad durch die Artikelreihe mit ESP32-C6, ESP32, NodeMCU und Arduino Uno

Mikrocontroller-Grundlagen: Lernpfad durch die Artikelreihe mit ESP32-C6, ESP32, NodeMCU und Arduino Uno

https://bildung.social/@oerinformatik/

https://oer-informatik.de/mcu-grundlagen

Mikrocontroller, Arduino, ESP32-C6, ESP32, ESP8266, NodeMCU, Arduino Uno, Lernpfad, Artikelreihe, Übungsaufgaben

tl/dr; (ca. 10 min Lesezeit): Dieser Überblick zeigt den Weg durch die Artikelreihe über Mikrocontroller-Grundlagen: zuerst die Grundlagenartikel mit der Arduino-API und Board-Tabs für ESP32-C6, ESP32, NodeMCU und Arduino Uno, danach die Vertiefung mit Registern und Datenblatt und zuletzt die Peripherie- und Vernetzungsartikel. Tabellen nennen zu jedem Artikel Lesezeit und Übungsaufgaben [AI-Assisted]. (Zuletzt geändert am 10.11.2026)

Dieser Artikel ist der Einstieg in die Artikelreihe über Mikrocontroller-Grundlagen: Überblick / Erste Schritte / Aufbau eines Mikrocontrollers / 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

Worum es in der Reihe geht

Ein Mikrocontroller steuert fast jedes elektronische Gerät: die Waschmaschine, den Rauchmelder, das Steuergerät im E-Bike oder den Sensor im Gewächshaus. Die Reihe zeigt, wie Du solche Controller mit der Arduino-Entwicklungsumgebung programmierst, vom ersten Blinken einer LED bis zum vernetzten Sensor, der seine Messwerte per WLAN verschickt.

Die Artikel sind in drei Ebenen aufgebaut:

• Grundlagenartikel erklären ein Thema mit den Arduino-Funktionen (pinMode(), digitalRead(), analogRead(), millis(), attachInterrupt() …). Jeder Grundlagenartikel hat einen eigenen Artikel mit Übungsaufgaben.
• Vertiefungsartikel schauen hinter die Arduino-Funktionen: Register, Bitmasken, Timer und Datenblatt, mit dem ATmega328P des Arduino Uno als Leitbeispiel und dem ESP32-C6 zum Vergleich. Die Grundlagenartikel verweisen im Abschnitt „Unter der Haube“ dorthin.
• Peripherie- und Praxisartikel zeigen einzelne Bausteine und Anwendungen: Pinbelegung, Klimasensoren, Anzeigen, WLAN und MQTT. Sie kommen ohne eigene Übungsdatei aus.

Die Grafik zeigt den Lernpfad: Die gelben Blöcke 1 bis 4 bauen aufeinander auf, die grauen Blöcke kannst Du nach Bedarf dazunehmen, sobald die Grundlagen sitzen.

Ein Programm, vier Boards

Alle Programme der Reihe laufen auf vier Boards. In den Artikeln stehen sie in Tabs nebeneinander; voreingestellt ist der ESP32-C6:

Damit Du ein Programm schnell auf ein anderes Board bringst, beginnt jedes Programm mit der Liste der Ein- und Ausgabeelemente. Sie hält fest, welches Bauteil an welchem Pin hängt und wie es sich verhält. Die Programme der vier Tabs unterscheiden sich nur in dieser Liste:

//-------------------------------------------------------------------------------------
// 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)

Welche Pins die Reihe auf den einzelnen Boards nutzt und welche Pins Du meiden solltest, steht im Artikel Pinbelegung der Boards. Dort findest Du auch weitere Boards wie das WeMos-Board mit OLED-Anzeige und ältere ESP32-DevKits.

Die Artikel im Überblick

Die Lesezeit gilt für den Lehrartikel, die Spalte „Übungen“ nennt die Aufgaben der zugehörigen Übungsdatei nach Kompetenzstufe (S1 Grundlagen bis S4 Expertise).

Grundlagen 1: Einstieg und Pins

Grundlagen 2: Kontrollstrukturen und Daten

Grundlagen 3: Programme strukturieren

Grundlagen 4: Analog, PWM, Interrupts und Projekt

Vertiefung: Register und Datenblatt

Peripherie und Vernetzung

Welcher Einstieg passt zu Dir?

• Noch nie einen Mikrocontroller programmiert: Beginne mit Erste Schritte und arbeite die Blöcke 1 bis 4 der Reihe nach durch. Am Ende führt das Projekt Simon Says alles zusammen.
• Programmieren in C oder Java schon bekannt: Die Kontrollstrukturen in Block 2 kannst Du überfliegen. Lies dort vor allem die Abschnitte zu den Board-Unterschieden (z. B. 16-Bit-int beim Uno) und steige bei Zeit ohne delay() richtig ein.
• Elektroniker*in mit Blick auf Hardware und Datenblatt: Nach Block 1 lohnt der Seitenblick auf Aufbau eines Mikrocontrollers. Die übrigen Vertiefungsartikel passen jeweils nach dem Grundlagenartikel, der im Abschnitt „Unter der Haube“ darauf verweist.
• Ein Gerät vernetzen: Mit den Grundlagen bis Block 3 im Rücken geht es über Pinbelegung und Sensoren zu WLAN und MQTT. Vorher lohnt Sichere und vernetzte Embedded-Systeme.

Was Du brauchst

• ein Board aus der Tabelle oben mit passendem USB-Kabel (ein Datenkabel, kein reines Ladekabel),
• die Arduino-IDE 2 mit den Board-Paketen für ESP32 und ESP8266 (Einrichtung in Erste Schritte),
• ein Steckbrett, einige LEDs mit Vorwiderständen, vier Taster, ein Potentiometer und einen Piezo-Summer; welche Teile jedes Beispiel braucht, steht in seiner Liste der Ein- und Ausgabeelemente.

Die Steckbrettbilder der Reihe sind mit Fritzing gezeichnet; wie Du eigene Schaltungen damit dokumentierst, zeigt Schaltungen zeichnen mit Fritzing.

Leitfragen

1. In welcher Reihenfolge arbeitest Du die Reihe durch, wenn Du noch nie einen Mikrocontroller programmiert hast? Antwort

Mit den Grundlagenartikeln: Block 1 (Erste Schritte bis Variablen und Datentypen), dann Block 2, 3 und 4 bis zum Projekt Simon Says. Vertiefung sowie Peripherie und Vernetzung kommen danach nach Bedarf dazu. siehe Abschnitt „Die Artikel im Überblick“

2. Wozu dienen die Board-Tabs in den Artikeln, und welcher Tab ist voreingestellt? Antwort

Jeder Tab enthält das vollständige Programm für ein Board (ESP32-C6, ESP32 DevKit V4, NodeMCU, Arduino Uno) und erklärt, was auf diesem Board anders ist. Voreingestellt ist der ESP32-C6. siehe Abschnitt „Ein Programm, vier Boards“

3. Was steht in der Liste der Ein- und Ausgabeelemente, und was änderst Du, wenn Du ein Programm auf ein anderes Board überträgst? Antwort

Die Liste nennt für jedes Bauteil den Namen der Konstanten, den Anschlusspin und das Verhalten (z. B. „active LOW, INPUT_PULLUP“). Für ein anderes Board tauschst Du nur diese Liste aus; der übrige Code bleibt gleich. siehe Abschnitt „Ein Programm, vier Boards“

4. Wie unterscheiden sich Grundlagen-, Vertiefungs- und Peripherieartikel? Antwort

Grundlagenartikel arbeiten mit den Arduino-Funktionen und haben eigene Übungsaufgaben. Vertiefungsartikel zeigen, was dahinter im Register und im Datenblatt passiert (Leitbeispiel ATmega328P). Peripherie- und Praxisartikel behandeln einzelne Bausteine und die Vernetzung ohne eigene Übungsdatei. siehe Abschnitt „Worum es in der Reihe geht“

Links und weitere Informationen

• zu Bussen und Schnittstellen: I²C-Bus, SPI-Bus und UART und RS-232

• zu Sensoren und Aktoren: Sensoren und Aktoren

• als Nachschlagewerk: Arduino-Sprachreferenz

• für ESP32 und ESP32-C6: Dokumentation des Arduino-Cores von Espressif

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

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: “Mikrocontroller-Grundlagen: Lernpfad durch die Artikelreihe mit 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-grundlagen 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]