Mikrocontroller-Programmierung: Wiederholung und Übungsaufgaben

Mikrocontroller-Programmierung: Wiederholung und Übungsaufgaben

https://bildung.social/@oerinformatik/

https://oer-informatik.de/mikrocontroller-programmierung-uebungsaufgaben

Mikrocontroller-Programmierung, C, Datentypen, Bitoperationen, Port-Register, Programmablaufplan, Struktogramm, Interrupt, Zustandsautomat, Übungsaufgaben, Prüfungsvorbereitung

tl/dr; (ca. 71 min Lese- und Bearbeitungszeit): Wiederholung und Übungsaufgaben zur Mikrocontroller-Programmierung in C – von Datentypen und Bitoperationen über Port-Register, Schleifen, PAP und Struktogramm bis zu Interrupts, Zustandsautomat und Fehlersuche. Du rechnest mit Datentypen und Bitmasken, führst Schreibtischtests durch, setzt einen Programmablaufplan und ein Struktogramm in C um, ergänzt den Zustandsautomaten einer Torsteuerung und findest fünf Fehler in einem kurzen Programm. Zu jeder der 19 Aufgaben lässt sich eine Beispiellösung einblenden [AI-Assisted]. (Zuletzt geändert am 13.11.2026)

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

In der Geräte- und Systemtechnik gehört es zum Kernwissen, kurze C-Programme zu lesen, zu ergänzen und auf Fehler zu prüfen: Datentypen und Überläufe, Bitoperationen, Port-Register, Kontrollstrukturen, Programmablaufpläne und Struktogramme, Interrupts, Zeitsteuerung und Zustandsautomaten. Die Hardware rund um den Mikrocontroller steht im Artikel Mikrocontroller: Wiederholung und Übungsaufgaben.

Dieser Artikel ist in acht Schritten aufgebaut. Schritt 8 ist eine Fehlersuche in einem kompletten Programm. Jeder Schritt beginnt mit einer kurzen Wiederholung, danach folgen Aufgaben:

• gebundene Aufgaben (Auswahlaufgaben): Genau eine der fünf Antworten ist richtig.

• ungebundene Aufgaben: Lösungsweg mit Ansatz und Ergebnis.

Hinweise zur Bearbeitung: Die Beispiellösung lässt sich unter jeder Aufgabe einblenden. Probiere es aber erst selbst. Die Beispiellösungen sind immer gleich aufgebaut: Oben steht, was gegeben ist (Geg.), bei jeder Teilaufgabe, was gesucht ist (Ges.). Bei Programmieraufgaben ist der Code das Ergebnis; andere gleichwertige Lösungen sind ebenfalls richtig.

Die Programme sind in C für einen 8-Bit-Mikrocontroller geschrieben (Registernamen wie beim ATmega328P, Datentypen aus stdint.h).

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

Erstelle neue Übungsaufgaben zum Thema „Mikrocontroller-Programmierung“.

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/mikrocontroller-programmierung-uebungsaufgaben
- Stilbeispiel: https://oer-informatik.de/mikrocontroller-programmierung-uebungsaufgaben

Die Aufgaben sollen Inhalte zu diesen Schlagwörtern abdecken:
- Mikrocontroller-Programmierung
- C
- Datentypen
- Bitoperationen
- Port-Register
- Programmablaufplan
- Struktogramm
- Interrupt
- Zustandsautomat

Kompetenzstufe: Kernkompetenz (alternativ: Basiskompetenz, 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.

1 Datentypen und Zahlenbereiche

Grundlagen

• Ein Überlauf entsteht, wenn ein Ergebnis nicht in den Datentyp passt. Bei vorzeichenlosen Typen wird modulo 2^n weitergezählt: 255 + 1 ergibt nach der Zuweisung an eine uint8_t-Variable 0.

• Rechnungen werden in C mindestens im Typ int bzw. unsigned int ausgeführt; auf 8-Bit-Mikrocontrollern haben diese nur 16 Bit. Zwischenergebnisse können deshalb überlaufen, obwohl das Endergebnis passt. Abhilfe: einen Operanden vorher in einen größeren Typ umwandeln (Typumwandlung, cast), z. B. (uint32_t)a * b.

• Die Division ganzer Zahlen schneidet die Nachkommastellen ab: 7 / 2 ergibt 3, 7 % 2 (Rest) ergibt 1.

• Auf Mikrocontrollern ohne Gleitkommaeinheit ist float langsam und speicherhungrig; man rechnet deshalb oft mit ganzen Zahlen in kleinen Einheiten (mV statt V).

Aufgabe 1.1 (gebunden)

Ein 10-Bit-AD-Umsetzer liefert Werte von 0 bis 1023. Welcher Datentyp speichert den Wert mit dem geringsten Speicherbedarf?

1. uint8_t

2. uint16_t

3. int8_t

4. float

5. uint32_t

Aufgabe 1.2 (gebunden)

Welchen Wert hat z nach den folgenden Zeilen?

uint8_t z = 250;
z = z + 10;

1. 260

2. 255

3. 4

4. 0

5. -6

Aufgabe 1.3 (ungebunden, 6 Punkte)

uint16_t adc = 1000;                 // Messwert, 0 ... 1023
uint16_t mv  = adc * 5000 / 1023;    // Spannung in mV

1. Erkläre, warum mv nicht den erwarteten Wert enthält, wenn int 16 Bit groß ist. (2 Punkte)

2. Korrigiere die zweite Zeile und berechne das Ergebnis. (2 Punkte)

3. Gib die Werte von 17 / 5 und 17 % 5 an. (2 Punkte)

uint16_t mv = (uint32_t)adc * 5000 / 1023;

2 Bitoperationen

Grundlagen

Bitoperatoren (Beispiel mit x = 0b1100):

• & bitweises UND: x & 0b1010 ergibt 0b1000

• | bitweises ODER: x | 0b0011 ergibt 0b1111

• ^ bitweises XOR: x ^ 0b0110 ergibt 0b1010

• ~ bitweise Negation: ~x invertiert alle Bits

• <<, >> Schieben nach links bzw. rechts: 1 << 3 ergibt 0b1000

Mit einer Maske (1 << n) wird gezielt Bit n bearbeitet, ohne die anderen Bits zu verändern:

• Bit setzen: reg |= (1 << n);

• Bit löschen: reg &= ~(1 << n);

• Bit umschalten: reg ^= (1 << n);

• Bit abfragen: if (reg & (1 << n)) { ... }

Logische Operatoren (&&, ||, !) liefern dagegen nur „wahr“ (1) oder „falsch“ (0). Die Schreibweise 0b… ist eine Erweiterung des AVR-Compilers (GCC).

Aufgabe 2.1 (gebunden)

Welche Anweisung setzt Bit 5 von PORTB auf 1, ohne die übrigen Bits zu verändern?

1. PORTB = (1 << 5);

2. PORTB &= (1 << 5);

3. PORTB ^= (1 << 5);

4. PORTB |= (1 << 5);

5. PORTB |= 5;

Aufgabe 2.2 (gebunden)

Welchen Wert hat y?

uint8_t x = 0b10110110;
uint8_t y = x & 0x0F;

1. 0xB6

2. 0x06

3. 0xB0

4. 0x0B

5. 0xF6

Aufgabe 2.3 (ungebunden, 10 Punkte)

Ein Register enthält r = 0xA6. Gib jeweils das Ergebnis dual und hexadezimal an. Jede Teilaufgabe geht von r = 0xA6 aus.

1. r | 0x09 (2 Punkte)

2. r & ~0x06 (2 Punkte)

3. r ^ 0xFF (2 Punkte)

4. r >> 4 (2 Punkte)

5. Prüfe, ob die Bedingung (r & (1 << 2)) erfüllt ist. (2 Punkte)

3 Port-Register

Grundlagen

Bei vielen 8-Bit-Mikrocontrollern hat jeder Port drei Register:

• DDRx (Data Direction Register): Bit = 1 → Pin ist Ausgang, Bit = 0 → Pin ist Eingang.

• PORTx: Bei einem Ausgang bestimmt das Bit den Pegel. Bei einem Eingang schaltet ein 1-Bit den internen Pull-up-Widerstand ein.

• PINx: Lesen des aktuellen Pegels an den Pins.

• Nach dem Reset sind DDRx und PORTx 0: Alle Pins sind Eingänge ohne Pull-up.

Aufgabe 3.1 (gebunden)

Für Pin PD2 gilt: Bit 2 in DDRD ist 0, Bit 2 in PORTD ist 1. Wie arbeitet der Pin?

1. als Ausgang mit High-Pegel

2. als Ausgang mit Low-Pegel

3. als Eingang ohne Pull-up

4. als Analogeingang

5. als Eingang mit internem Pull-up

Aufgabe 3.2 (ungebunden, 8 Punkte)

An PB0 bis PB3 sind LEDs (high-aktiv) angeschlossen, an PD2 ein Taster gegen 0 V.

1. Schreibe die Anweisungen, die PB0 bis PB3 als Ausgänge einstellen, ohne die übrigen Pins von Port B zu verändern. (2 Punkte)

2. Schreibe die Anweisungen, die PD2 als Eingang mit Pull-up einstellen. (2 Punkte)

3. Schreibe eine Abfrage, die die LED an PB1 einschaltet, solange der Taster gedrückt ist, und sonst ausschaltet. (4 Punkte)

DDRB |= (1 << PB0) | (1 << PB1) | (1 << PB2) | (1 << PB3);   // oder: DDRB |= 0x0F;

DDRD  &= ~(1 << PD2);   // Eingang
PORTD |=  (1 << PD2);   // Pull-up ein

if (!(PIND & (1 << PD2))) {     // Taster gedrückt (Low)
    PORTB |= (1 << PB1);        // LED an
} else {
    PORTB &= ~(1 << PB1);       // LED aus
}

4 Kontrollstrukturen

Grundlagen

Ein Schreibtischtest verfolgt die Werte aller Variablen Schritt für Schritt in einer Tabelle.

Aufgabe 4.1 (gebunden)

Wie oft wird der Schleifenrumpf ausgeführt?

for (uint8_t i = 0; i < 10; i += 3) { ... }

1. 4-mal

2. 3-mal

3. 10-mal

4. 9-mal

5. 0-mal

Aufgabe 4.2 (gebunden)

Welchen Wert hat n nach der Schleife?

uint8_t x = 20, n = 0;
while (x > 0) {
    x = x / 2;
    n++;
}

1. 10

2. 4

3. 20

4. 5

5. 0

Aufgabe 4.3 (ungebunden, 8 Punkte)

uint8_t a = 3, b = 0;
for (uint8_t i = 1; i <= 4; i++) {
    if (i % 2 == 0) {
        b = b + a;
    } else {
        a = a + i;
    }
}

1. Führe einen Schreibtischtest durch und gib a und b nach der Schleife an. (5 Punkte)

2. Im folgenden Ausschnitt fehlt ein break. Gib an, welche Funktionen bei modus = 1 aufgerufen werden. (3 Punkte)

switch (modus) {
    case 1:  led_gruen();
    case 2:  led_gelb();
             break;
    default: led_rot();
}

5 Programmablaufplan und Struktogramm

Grundlagen

• Der Programmablaufplan (PAP, DIN 66001) zeigt den Ablauf mit Sinnbildern: abgerundetes Rechteck für Start und Ende, Rechteck für Verarbeitung, Parallelogramm für Ein- und Ausgabe, Raute für Verzweigung; die Pfeile geben die Richtung an.

• Das Struktogramm (Nassi-Shneiderman, DIN 66261) stellt nur strukturierte Abläufe dar: Folge, Verzweigung (Dreieck mit ja/nein), Schleifen. Bei einer kopf- oder zählgesteuerten Schleife steht die Bedingung oben, der Rumpf ist eingerückt; bei einer fußgesteuerten Schleife steht sie unten.

• Eine Hysterese (zwei verschiedene Schaltschwellen) verhindert, dass ein Ausgang an einer Schwelle ständig ein- und ausschaltet.

Aufgabe 5.1 (gebunden)

Welche Schleifenart zeigt das Struktogramm zur Mittelwertbildung?

1. fußgesteuerte Schleife

2. Zählschleife (kopfgesteuert)

3. Endlosschleife

4. Verzweigung

5. Mehrfachauswahl

Aufgabe 5.2 (ungebunden, 10 Punkte)

Verwende den Programmablaufplan der Pumpensteuerung. Es stehen die Funktionen fuellstand() (liefert uint16_t), pumpe_ein(), pumpe_aus() und _delay_ms(ms) zur Verfügung.

1. Setze den Ablauf in ein C-Programm um. (5 Punkte)

2. Gib an, was bei einem Füllstand von 500 geschieht, und erkläre den Zweck der beiden Schwellen. (3 Punkte)

3. Begründe, warum die Rücksprunglinie oberhalb von „Füllstand lesen“ und nicht vor „Pumpe aus“ endet. (2 Punkte)

int main(void) {
    uint16_t f;
    pumpe_aus();                 // Initialisierung
    while (1) {
        f = fuellstand();
        if (f < 200) {
            pumpe_ein();
        } else if (f > 800) {
            pumpe_aus();
        }
        _delay_ms(100);
    }
}

Aufgabe 5.3 (ungebunden, 6 Punkte)

Verwende das Struktogramm zur Mittelwertbildung. Die Funktion uint16_t adc_lesen(uint8_t kanal) liefert 0 … 1023, die Funktion ausgeben() zeigt einen Wert an.

1. Setze das Struktogramm in C um. (3 Punkte)

2. Wähle einen geeigneten Datentyp für summe und begründe die Wahl. (2 Punkte)

3. Ersetze die Division durch eine Schiebeoperation. (1 Punkt)

uint16_t summe = 0;
uint16_t mittel;
for (uint8_t i = 0; i <= 7; i++) {
    uint16_t wert = adc_lesen(0);
    summe = summe + wert;
}
mittel = summe / 8;
ausgeben(mittel);

mittel = summe >> 3;

6 Funktionen, Interrupts und volatile

Grundlagen

• Eine Funktion kapselt eine Teilaufgabe, erhält Parameter und gibt einen Wert zurück (uint16_t messen(uint8_t kanal)); void bedeutet „kein Rückgabewert“.

• Lokale Variablen gelten nur in ihrer Funktion; globale Variablen im ganzen Programm.

• Eine Interrupt-Service-Routine (ISR) wird bei einem Ereignis automatisch aufgerufen. Sie soll kurz sein (keine Wartezeiten, keine langen Berechnungen).

• Variablen, die in einer ISR und im Hauptprogramm verwendet werden, werden als volatile deklariert. Der Compiler liest sie dann bei jedem Zugriff aus dem Speicher, statt einen in einem Register zwischengespeicherten Wert zu verwenden.

• Auf einem 8-Bit-Mikrocontroller wird eine 16-Bit-Variable in zwei Schritten gelesen. Ändert eine ISR sie dazwischen, entsteht ein falscher Wert. Abhilfe: Interrupts während des Zugriffs kurz sperren (cli(), danach sei()).

Aufgabe 6.1 (gebunden)

Warum wird eine globale Variable, die in einer ISR verändert wird, als volatile deklariert?

1. Damit sie im EEPROM gespeichert wird.

2. Damit sie nach dem Abschalten erhalten bleibt.

3. Damit der Compiler sie bei jedem Zugriff neu aus dem Speicher liest.

4. Damit die ISR schneller ausgeführt wird.

5. Damit die Variable nur in der ISR verwendet werden kann.

Aufgabe 6.2 (ungebunden, 10 Punkte)

Ein Programm misst eine Frequenz. Jede steigende Flanke an INT0 löst einen Interrupt aus.

volatile uint16_t impulse = 0;

ISR(INT0_vect) {
    impulse++;
}

int main(void) {
    uint16_t frequenz;
    /* Initialisierung von INT0 ... */
    sei();
    while (1) {
        _delay_ms(1000);
        frequenz = impulse;
        impulse = 0;
        anzeigen(frequenz);
    }
}

1. Nach einer Torzeit von 1 s wurden 437 Impulse gezählt. Gib die Frequenz an und berechne die höchste Frequenz, die die Variable ohne Überlauf erfassen kann. (3 Punkte)

2. Erkläre, warum in der ISR kein _delay_ms() stehen darf. (2 Punkte)

3. Beschreibe den Fehler, der beim Kopieren von impulse auftreten kann, und ergänze das Programm so, dass er nicht auftritt. (3 Punkte)

4. Nenne einen Grund, warum die Torzeit mit _delay_ms() ungenau ist. (2 Punkte)

cli();                  // Interrupts sperren
frequenz = impulse;
impulse = 0;
sei();                  // Interrupts freigeben

7 Zeitsteuerung und Zustandsautomat

Grundlagen

• _delay_ms() blockiert: Während der Wartezeit kann das Programm nichts anderes tun (z. B. keine Taster abfragen).

• Nicht blockierend arbeitet man mit einem Zeitzähler, den ein Timer-Interrupt hochzählt (z. B. jede Millisekunde). Das Hauptprogramm prüft nur, ob seit dem letzten Ereignis genug Zeit vergangen ist.

• Ein Zustandsautomat beschreibt ein System durch Zustände und Übergänge. Im Programm speichert eine Variable den aktuellen Zustand; eine switch-Anweisung prüft in jedem Durchlauf der Hauptschleife die Übergangsbedingungen des aktuellen Zustands.

Aufgabe 7.1 (gebunden)

Warum sollte in der Hauptschleife einer Torsteuerung kein _delay_ms(500) verwendet werden?

1. Weil _delay_ms() nur in Interrupts erlaubt ist.

2. Weil die Funktion den Timer zerstört.

3. Weil 500 ms nicht in einen uint8_t passen.

4. Weil der Watchdog dadurch abgeschaltet wird.

5. Weil das Programm während der Wartezeit nicht auf Endschalter oder Lichtschranke reagiert.

Aufgabe 7.2 (ungebunden, 10 Punkte)

Die Torsteuerung wird nach dem Zustandsdiagramm programmiert. Es gibt die Funktionen taster(), end_oben(), end_unten(), lichtschranke() (liefern 1, wenn betätigt bzw. unterbrochen) sowie motor_auf(), motor_zu(), motor_aus().

enum zustand { ZU, OEFFNET, OFFEN, SCHLIESST };
enum zustand z = ZU;

while (1) {
    switch (z) {
        case ZU:
            if (taster()) { motor_auf(); z = OEFFNET; }
            break;
        case OEFFNET:
            if (end_oben()) { motor_aus(); z = OFFEN; }
            break;
        case OFFEN:
            if (taster()) { motor_zu(); z = SCHLIESST; }
            break;
        case SCHLIESST:
            /* ergänzen */
            break;
    }
}

1. Gib alle Übergänge aus dem Zustand SCHLIESST mit Bedingung und Folgezustand an. (2 Punkte)

2. Ergänze den Programmteil für case SCHLIESST. Die Lichtschranke soll Vorrang vor dem Endschalter haben. (5 Punkte)

3. Ein Tastendruck dauert einige hundert Millisekunden, die Hauptschleife läuft in wenigen Mikrosekunden durch. Beschreibe das Problem beim Übergang von OFFEN nach SCHLIESST und eine Lösung. (3 Punkte)

case SCHLIESST:
    if (lichtschranke() || taster()) {   // Hindernis oder Taster: Vorrang
        motor_auf();
        z = OEFFNET;
    } else if (end_unten()) {
        motor_aus();
        z = ZU;
    }
    break;

8 Fehlersuche

Grundlagen

Typische Fehler in kurzen C-Programmen:

• Zuweisung = statt Vergleich == in einer Bedingung,

• falsche Maske beim Löschen (&= (1 << n) statt &= ~(1 << n)),

• Semikolon direkt hinter if (...), for (...) oder while (...),

• fehlendes break in switch,

• zu kleiner Datentyp (Überlauf),

• Lesen von PORTx statt PINx bei einem Eingang.

Aufgabe 8.1 (ungebunden, 10 Punkte)

Das folgende Programm soll die LED an PB3 einschalten, solange der Taster an PD2 (gegen 0 V, interner Pull-up) gedrückt ist. Eine Variable zählt die Schleifendurchläufe mit gedrücktem Taster bis 300 und beginnt dann wieder bei 0. Das Programm enthält fünf Fehler.

int main(void) {
    uint8_t zaehler = 0;            // Zeile 2
    DDRB |= (1 << PB3);             // Zeile 3
    PORTD |= (1 << PD2);            // Zeile 4
    while (1) {
        if (PORTD & (1 << PD2)) ;   // Zeile 6: nicht gedrückt?
        {
            PORTB &= (1 << PB3);    // Zeile 8: LED aus
        } else {
            PORTB |= (1 << PB3);    // Zeile 10: LED an
            zaehler++;              // Zeile 11
        }
        if (zaehler = 300) {        // Zeile 13
            zaehler = 0;
        }
    }
}

Gib zu jedem Fehler die Zeile an, beschreibe den Fehler und korrigiere ihn; je Fehler gibt es 2 Punkte. (10 Punkte)

int main(void) {
    uint16_t zaehler = 0;
    DDRB  |= (1 << PB3);
    PORTD |= (1 << PD2);
    while (1) {
        if (PIND & (1 << PD2)) {        // nicht gedrückt
            PORTB &= ~(1 << PB3);       // LED aus
        } else {
            PORTB |= (1 << PB3);        // LED an
            zaehler++;
        }
        if (zaehler == 300) {
            zaehler = 0;
        }
    }
}

Leitfragen

1. Welcher Datentyp passt zu welchem Wertebereich, und wann entsteht ein Überlauf? Antwort

uint8_t reicht von 0 bis 255, int8_t von −128 bis 127, uint16_t bis 65 535, int16_t von −32 768 bis 32 767 und uint32_t bis etwa 4,29 Milliarden – ein 10-Bit-ADC-Wert braucht also uint16_t. Ein Überlauf entsteht, wenn ein Ergebnis nicht in den Typ passt; vorzeichenlose Typen zählen dann modulo 2^n weiter (250 + 10 ergibt in uint8_t 4), und auch Zwischenergebnisse im 16-Bit-int können überlaufen, was ein Cast wie (uint32_t)a * b verhindert – siehe Abschnitt „1 Datentypen und Zahlenbereiche“ und Aufgabe 1.3.

2. Wie setzt, löscht, schaltet und prüft man ein einzelnes Bit? Antwort

Du arbeitest mit der Maske (1 << n): Setzen mit reg |= (1 << n);, Löschen mit reg &= ~(1 << n);, Umschalten mit reg ^= (1 << n); und Abfragen mit if (reg & (1 << n)). So bleiben alle anderen Bits unverändert – siehe Abschnitt „2 Bitoperationen“ und Aufgabe 2.1.

3. Welche Aufgabe haben die Register DDRx, PORTx und PINx? Antwort

DDRx legt die Richtung fest (Bit 1 = Ausgang, Bit 0 = Eingang). PORTx bestimmt bei einem Ausgang den Pegel und schaltet bei einem Eingang mit einem 1-Bit den internen Pull-up ein; über PINx liest Du den aktuellen Pegel an den Pins. Nach dem Reset sind alle Pins Eingänge ohne Pull-up – siehe Abschnitt „3 Port-Register“ und Aufgabe 3.1.

4. Wie führt man einen Schreibtischtest durch? Antwort

Beim Schreibtischtest verfolgst Du die Werte aller Variablen Schritt für Schritt in einer Tabelle, mit einer Zeile je Schleifendurchlauf und Spalten für Bedingung, ausgeführte Anweisung und Variablenwerte. So erkennst Du etwa, dass die Schleife mit x = x / 2 ab 20 genau fünfmal läuft – siehe Abschnitt „4 Kontrollstrukturen“ und Aufgabe 4.3.

5. Wie liest man einen Programmablaufplan oder ein Struktogramm und setzt es in C um? Antwort

Im PAP nach DIN 66001 stehen abgerundete Rechtecke für Start/Ende, Rechtecke für Verarbeitung, Parallelogramme für Ein-/Ausgabe und Rauten für Verzweigungen; im Struktogramm nach DIN 66261 steht die Schleifenbedingung oben (kopf- oder zählgesteuert) oder unten (fußgesteuert) und Verzweigungen als Dreieck. Du übersetzt die Elemente in if/else, for, while und die Endlosschleife while (1) und achtest darauf, wohin Rücksprünge führen (z. B. nicht vor die Initialisierung) – siehe Abschnitt „5 Programmablaufplan und Struktogramm“ und Aufgabe 5.2.

6. Warum muss eine Variable, die eine ISR verändert, volatile sein, und was bedeutet atomarer Zugriff? Antwort

Mit volatile liest der Compiler die Variable bei jedem Zugriff neu aus dem Speicher, statt einen im Register zwischengespeicherten Wert zu verwenden, der die Änderungen der ISR nicht kennt. Atomar heißt, dass ein Zugriff nicht unterbrochen werden kann: Eine 16-Bit-Variable wird auf einem 8-Bit-Mikrocontroller in zwei Schritten gelesen, deshalb sperrst Du währenddessen kurz die Interrupts mit cli() und sei() (oder ATOMIC_BLOCK) – siehe Abschnitt „6 Funktionen, Interrupts und volatile“ und Aufgabe 6.2.

7. Warum blockiert _delay_ms(), und wie programmiert man einen Zustandsautomaten? Antwort

_delay_ms() ist eine Warteschleife, während der das Programm nichts anderes tun kann, also z. B. nicht auf Endschalter oder Lichtschranke reagiert; nicht blockierend arbeitest Du mit einem Zeitzähler aus einem Timer-Interrupt. Für einen Zustandsautomaten speichert eine Variable (z. B. ein enum) den aktuellen Zustand, und eine switch-Anweisung prüft in jedem Durchlauf der Hauptschleife die Übergangsbedingungen dieses Zustands – siehe Abschnitt „7 Zeitsteuerung und Zustandsautomat“ und Aufgabe 7.2.

8. Welche typischen Fehler kommen in C-Programmen vor? Antwort

Typisch sind = statt == in Bedingungen, die falsche Löschmaske &= (1 << n) statt &= ~(1 << n), ein Semikolon direkt hinter if, for oder while, ein fehlendes break im switch, ein zu kleiner Datentyp und das Lesen von PORTx statt PINx bei einem Eingang – siehe Abschnitt „8 Fehlersuche“ und Aufgabe 8.1.

Links und weitere Informationen

• Wikipedia: Bitweiser Operator

• Wikipedia: Nassi-Shneiderman-Diagramm

• Wikipedia: Endlicher Automat

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-Programmierung: Wiederholung und Übungsaufgaben” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/mikrocontroller-programmierung-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: 13.11.2026.

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