Übungsaufgaben zu den ersten Schritten mit dem Mikrocontroller: Programmablauf, Blinkmuster und Taster

https://bildung.social/@oerinformatik/

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

Mikrocontroller, Arduino, setup, loop, Blink, digitalWrite, INPUT_PULLUP, HIGH-aktiv, LOW-aktiv, Hochladen, Übungsaufgaben, Prüfungsvorbereitung

tl/dr; (ca. 27 min Lese- und Bearbeitungszeit): Zwei Übungsaufgaben zu den ersten Schritten mit dem Mikrocontroller: Programmablauf und Blinkmuster vorhersagen, eine LOW-aktive LED erkennen, die Liste der Ein- und Ausgabeelemente ergänzen, ein Blinkmuster ändern, mit einem Taster umschalten und Fehler beim Hochladen beheben. Zu jeder Teilaufgabe lässt sich eine Beispiellösung einblenden [AI-Assisted]. (Zuletzt geändert am 10.11.2026)

Diese Übungsaufgaben gehören zum Artikel Erste Schritte mit dem Mikrocontroller: Entwicklungsumgebung, Board, Blink und Taster. Die Programme gibt es für vier Boards; wähle oben im Tab Dein Board (ESP32-C6 ist voreingestellt).

Wortwolke mit den Fachbegriffen der Übungsaufgaben zu den ersten Schritten mit dem Mikrocontroller (mit KI erstellt)

Hinweise zur Bearbeitung: Bis zur Teil-1- bzw. Zwischenprüfung der Elektroberufe solltest Du die Basiskompetenz beherrschen, also Aufgabe 1.1. Als FIA, FISY, FIDP, FIDV, ISE, EGS oder IEGS musst Du zur Teil-2- bzw. Abschlussprüfung Aufgaben auf Kernkompetenz-Ebene lösen können, das ist Aufgabe 2.1. Schreib Deine Lösung zuerst vollständig auf und blende erst dann die Beispiellösung ein. Programme kannst Du auf dem Board testen; die Verdrahtung von LED 1 und Taster 1 zeigt der Artikel zu den ersten Schritten.

Du möchtest eigene Aufgaben zum Üben von einem KI-Sprachmodell generieren lassen?

Kopiere den Text in ein KI-Sprachmodell Deiner Wahl und passe Kompetenzstufe, Anzahl, Bearbeitungszeit und Szenario bei Bedarf an. Wie die Aufgaben aufgebaut sind, beschreibt der Artikel Wie sind die Aufgaben aufgebaut?. Prüfe die Ergebnisse mit dem Lehrartikel: KI-Sprachmodelle machen Fehler.

Erstelle neue Übungsaufgaben zum Thema „Erste Schritte mit dem
Mikrocontroller: Programmablauf, Blinkmuster und Taster“.

Bauplan: Halte Dich an Aufbau, Kompetenzstufen, Operatoren,
Anforderungsbereiche, Punkte und Zeitschätzung, die im Artikel
https://oer-informatik.de/aufgaben-aufbau beschrieben sind.

Fachliche Grundlage:
- https://oer-informatik.de/mcu-erste-schritte
- https://oer-informatik.de/mcu-pinout
- Stilbeispiel: https://oer-informatik.de/mcu-erste-schritte-uebungsaufgaben

Die Aufgaben sollen Inhalte zu diesen Schlagwörtern abdecken:
- Mikrocontroller
- Arduino
- setup
- loop
- Blink
- digitalWrite
- INPUT_PULLUP
- HIGH-aktiv
- LOW-aktiv
- Hochladen

Kompetenzstufe: Basiskompetenz (alternativ: Kernkompetenz, Profilkompetenz, Expertise)
Anzahl: 1 Aufgabe mit Teilaufgaben
Bearbeitungszeit in Minuten ca.: <5 bis 30 min>
Szenario: eines der Szenarien aus dem Bauplan

Vorgehen:
1. Lies zuerst die verlinkten Artikel. Kannst Du keine Webseiten
   abrufen, sag mir das, statt zu raten.
2. Steht bei einer Angabe noch ein Platzhalter in <…>, frag mich
   zuerst danach. Richte Punkte und Zahl der Teilaufgaben nach der
   Bearbeitungszeit (ca. 0,9 min je Punkt).
3. Gib je Aufgabe Titel mit Kompetenzstufe, Ausgangssituation und
   Teilaufgaben mit Operator und Punktzahl aus, dazu die geschätzte
   Bearbeitungszeit.
4. Gib die Beispiellösungen mit Punkteverteilung erst aus, wenn ich
   danach frage.

Aufgabe 1.1: Testprogramm für eine Status-LED (Basiskompetenz)

Bei der Blattwerk Steuerungen GmbH bekommt der Klimaregler KR-3 eine neue Status-LED. Bevor die Platine fertig ist, testet Kwame Asante das Blinkmuster auf einem Entwicklungsboard. Er gibt Dir dieses Programm, LED 1 ist wie im Artikel HIGH-aktiv gegen GND angeschlossen:

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

void loop() {
  digitalWrite(LED1_PIN, HIGH);
  delay(100);
  digitalWrite(LED1_PIN, LOW);
  delay(300);
  digitalWrite(LED1_PIN, HIGH);
  delay(100);
  digitalWrite(LED1_PIN, LOW);
  delay(1500);
}

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.

a) Beschreibe, welche Teile des Programms nach dem Einschalten des Boards wie oft ausgeführt werden. (2 Punkte)

Die Liste der Ein- und Ausgabeelemente legt einmal beim Start die Konstante LED1_PIN an, danach läuft setup() genau einmal und stellt den LED-Pin als Ausgang ein. (1 Punkt)
loop() wird danach immer wieder aufgerufen, solange das Board versorgt ist und kein Reset erfolgt. Jeder Durchlauf erzeugt ein Blinkmuster. (1 Punkt)

b) Gib in der Tabelle an, wann die LED während eines Durchlaufs von loop() an und aus ist, und berechne, wie oft das Muster pro Minute erscheint. (4 Punkte)

Zeitlicher Ablauf eines Durchlaufs von loop()
Zeit ab Beginn von `loop()`	Zustand der LED

Zeitlicher Ablauf eines Durchlaufs von loop() (Beispiellösung)
Zeit ab Beginn von `loop()`	Zustand der LED
0 ms bis 100 ms	an
100 ms bis 400 ms	aus
400 ms bis 500 ms	an
500 ms bis 2000 ms	aus

Die LED blitzt zweimal kurz hintereinander auf, dann folgt eine lange Pause. (je Zeile 0,5 Punkte, zusammen 2 Punkte)

Geg.: Wartezeiten 100 ms, 300 ms, 100 ms, 1500 ms

Ges.: Periodendauer T, Anzahl n der Muster pro Minute

T = 100\ \mathrm{ms} + 300\ \mathrm{ms} + 100\ \mathrm{ms} + 1500\ \mathrm{ms} = 2000\ \mathrm{ms} = 2\ \mathrm{s}

n = \frac{60\ \mathrm{s}}{T} = \frac{60\ \mathrm{s}}{2\ \mathrm{s}} = \underline{\underline{30}}

Das Muster erscheint 30-mal pro Minute. Die Laufzeit der Befehle selbst liegt im Mikrosekundenbereich und spielt keine Rolle. (Periodendauer 1 Punkt, Anzahl 1 Punkt)

c) Jakob Terhorst baut das Muster nach, schließt die LED aber versehentlich zwischen 3,3 V und den LED-Pin an (Anode an 3,3 V, Kathode über den Vorwiderstand an den Pin). Beschreibe, welches Muster er nun sieht, und begründe Deine Antwort. (3 Punkte)

Die LED ist jetzt LOW-aktiv: Sie leuchtet, wenn der Pin LOW (0 V) ist, weil dann 3,3 V über LED und Vorwiderstand anliegen. Bei HIGH liegen beide Seiten auf 3,3 V, es fließt kein Strom (am Uno liegt der Pin dann auf 5 V, die LED ist in Sperrrichtung gepolt und leuchtet ebenfalls nicht). (1 Punkt)
Das Muster kehrt sich um: Die LED ist fast immer an und geht zweimal kurz (je 100 ms) aus, dazwischen 300 ms an, danach 1500 ms an. (2 Punkte)

d) Für die nächste Version soll an Taster 1 ein Quittiertaster angeschlossen werden (gegen GND, ohne externen Widerstand). Ergänze die Liste der Ein- und Ausgabeelemente für Dein Board um die passende Zeile und notiere die Anweisung, die dafür in setup() hinzukommt. (2 Punkte)

Neu in setup(): pinMode(BUTTON1_PIN, INPUT_PULLUP); (1 Punkt). Die Zeile für die Liste steht nach der Vorlage vor der LED-Zeile (1 Punkt):

const int     BUTTON1_PIN         = 1;                // Button 1, active LOW, INPUT_PULLUP

Aufgabe 2.1: Blinkmuster für Normalbetrieb und Störung (Kernkompetenz)

Kwame Asante legt die Blinkmuster des KR-3 fest: Im Normalbetrieb soll die Status-LED alle 2 Sekunden einmal kurz (100 ms) aufblitzen. Liegt eine Störung vor, soll sie gleichmäßig zweimal pro Sekunde blinken. Auf dem Entwicklungsboard simuliert Taster 1 die Störung: Solange er gedrückt ist, gilt „Störung“. LED 1 und Taster 1 sind wie im Artikel angeschlossen.

a) Ändere das Programm aus Aufgabe 1.1 so, dass es das Muster für den Normalbetrieb erzeugt. (3 Punkte)

Nach dem Aufblitzen bleiben bis zum Ende der Periode von 2000 ms noch 1900 ms Pause. (Muster 2 Punkte, Pause richtig berechnet 1 Punkt)

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

void loop() {
  digitalWrite(LED1_PIN, HIGH);   // Normalbetrieb: kurzer Blitz ...
  delay(100);
  digitalWrite(LED1_PIN, LOW);
  delay(1900);                    // ... und lange Pause (Periode 2 s)
}

b) Erweitere das Programm so, dass die LED bei gedrücktem Taster 1 das Störungsmuster und sonst das Muster für den Normalbetrieb zeigt. Der Taster ist ohne externen Widerstand gegen GND angeschlossen. (6 Punkte)

Zweimal pro Sekunde gleichmäßig blinken heißt: Periode 500 ms, also 250 ms an und 250 ms aus. Bewertung: Taster-Pin mit INPUT_PULLUP eingerichtet (1 Punkt), Abfrage mit digitalRead() auf LOW (2 Punkte), Störungsmuster 250/250 ms (2 Punkte), Normalbetrieb im else-Zweig (1 Punkt).

//-------------------------------------------------------------------------------------
// 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() {
  pinMode(BUTTON1_PIN, INPUT_PULLUP);   // Taster gegen GND, interner Pull-up
  pinMode(LED1_PIN, OUTPUT);
}

void loop() {
  if (digitalRead(BUTTON1_PIN) == LOW) {  // Taster gedrückt: Störung simulieren
    digitalWrite(LED1_PIN, HIGH);         // gleichmäßig schnell blinken
    delay(250);
    digitalWrite(LED1_PIN, LOW);
    delay(250);
  } else {                                // Normalbetrieb
    digitalWrite(LED1_PIN, HIGH);         // kurzer Blitz ...
    delay(100);
    digitalWrite(LED1_PIN, LOW);
    delay(1900);                          // ... und lange Pause
  }
}

c) Erkläre, warum bei INPUT_PULLUP kein externer Widerstand nötig ist, und beschreibe, wie sich das Programm verhält, wenn Du stattdessen pinMode(BUTTON1_PIN, INPUT); schreibst. (3 Punkte)

Mit INPUT_PULLUP schaltet der Mikrocontroller einen internen Pull-up-Widerstand zwischen Eingang und Versorgungsspannung. Er zieht den Eingang bei offenem Taster auf HIGH; der gedrückte Taster zieht ihn auf GND (LOW). (2 Punkte)
Mit INPUT fehlt dieser Widerstand. Bei offenem Taster hängt der Eingang in der Luft (floating), digitalRead() liefert zufällig HIGH oder LOW. Die LED wechselt dann scheinbar grundlos zwischen Normal- und Störungsmuster, z. B. schon, wenn man mit der Hand in die Nähe kommt. Ausnahme: Am FLASH-Taster des NodeMCU liegt ein externer Pull-up auf der Platine, dort funktioniert das Programm auch mit INPUT. (1 Punkt)

d) Jakob möchte das Programm auf ein ESP32-C6 DevKit hochladen. Beurteile für die beiden folgenden Fälle die wahrscheinliche Ursache und nenne jeweils eine Abhilfe. (4 Punkte)

Fall 1: Unter Werkzeuge/Port erscheint nach dem Anstecken kein neuer Port.
Fall 2: Jakob hat zum Testen Serial.println("Störung"); eingebaut. Das Hochladen über die Buchse „USB“ klappt und die LED blinkt, aber der serielle Monitor bleibt leer.

Fall 1: Der Treiber des USB-Seriell-Wandlers fehlt (z. B. CH343 oder CP210x) oder das Kabel ist ein reines Ladekabel ohne Datenleitungen. Abhilfe: im Geräte-Manager nachsehen, ob ein Gerät ohne Treiber erscheint, den Treiber des Herstellers installieren bzw. ein Datenkabel verwenden. (2 Punkte)
Fall 2: Über die Buchse „USB“ (eingebaute USB-Schnittstelle des Chips) gehen Serial-Ausgaben nur, wenn „USB CDC On Boot“ eingeschaltet ist. Abhilfe: unter Werkzeuge „USB CDC On Boot: Enabled“ wählen und neu hochladen oder Kabel und Port auf die Buchse „UART“ umstecken. Außerdem Serial.begin(115200); in setup() und gleiche Baudrate im Monitor prüfen. (2 Punkte)

e) Beim Testen fällt auf: Drückt Jakob den Taster im Normalbetrieb, beginnt das Störungsmuster manchmal erst knapp zwei Sekunden später. Erläutere die Ursache. (2 Punkte)

Der Taster wird nur einmal am Anfang jedes loop()-Durchlaufs abgefragt. Im Normalbetrieb dauert ein Durchlauf 2000 ms, davon wartet delay(1900) den größten Teil. Während delay() reagiert das Programm auf nichts; ein Tastendruck in dieser Zeit wird erst beim nächsten Durchlauf erkannt. (2 Punkte) Wie man ohne delay() wartet und trotzdem sofort reagiert, zeigt die Reihe in einem späteren Artikel mit millis().

Links und weitere Informationen

zum Nachlesen: Erste Schritte mit dem Mikrocontroller: Entwicklungsumgebung, Board, Blink und Taster
für die Pins aller Boards: Pinbelegung der Mikrocontroller-Boards
als Nachschlagewerk: Arduino-Sprachreferenz

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: “Übungsaufgaben zu den ersten Schritten mit dem Mikrocontroller: Programmablauf, Blinkmuster und Taster” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/mcu-erste-schritte-uebungsaufgaben 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]

Übungsaufgaben zu den ersten Schritten mit dem Mikrocontroller: Programmablauf, Blinkmuster und Taster