Übungsaufgaben zu digitalen Eingängen am Mikrocontroller: Taster, Pull-up/Pull-down und Entprellen

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 „Digitale Eingänge am
Mikrocontroller: Taster, Pull-up/Pull-down und Entprellen“.

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-digitale-eingaenge
- https://oer-informatik.de/spannungsteiler
- https://oer-informatik.de/komparator-schmitt-trigger
- https://oer-informatik.de/mcu-zeitsteuerung-millis
- https://oer-informatik.de/mcu-pinout
- Stilbeispiel: https://oer-informatik.de/mcu-digitale-eingaenge-uebungsaufgaben

Die Aufgaben sollen Inhalte zu diesen Schlagwörtern abdecken:
- Mikrocontroller
- digitaler Eingang
- Taster
- Pull-up-Widerstand
- Pull-down-Widerstand
- Flankenerkennung
- Öffner
- Drahtbruch
- Prellen
- Entprellen

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.

Geg.: U_\mathrm{B} = 3{,}3\ \mathrm{V}, -R1 = 10\ \mathrm{k\Omega} von PA3 nach U_\mathrm{B}, -S1 von PA3 nach Masse; -R2 = 22\ \mathrm{k\Omega} von PA4 nach Masse, -S2 von PA4 nach U_\mathrm{B}; -S3 an PA5 ohne Widerstand; Low bis 0,99 V, High ab 2,31 V

Ges.: Pegel an PA3 und PA4, aktiver Pegel

(je Zeile 2 Punkte: Pegel 1 Punkt, aktiver Pegel 1 Punkt)

Ges.: Verhalten von PA5, Aufgabe und Bezeichnung von -R1 und -R2, Abhilfe

• PA5: Bei offenem -S3 hängt der Eingang in der Luft (floatet). Ein CMOS-Eingang ist sehr hochohmig; sein Pegel ist undefiniert und wechselt durch Störungen zufällig zwischen 0 und 1 – der Controller meldet womöglich die Endlage, obwohl das Tor noch fährt. Im verbotenen Bereich zieht die Eingangsstufe zudem erhöhten Querstrom. (2 Punkte)
• Aufgabe von -R1 und -R2: Beide Widerstände ziehen den Eingang bei offenem Taster auf ein festes Potenzial und sorgen so für einen definierten Pegel; bei betätigtem Taster begrenzen sie den Strom, sodass kein Kurzschluss zwischen U_\mathrm{B} und Masse entsteht. (1 Punkt)
• Bezeichnung: -R1 (nach U_\mathrm{B}) ist ein Pull-up-Widerstand, -R2 (nach Masse) ein Pull-down-Widerstand. (1 Punkt)
• Abhilfe für PA5: im Programm den internen Pull-up einschalten (z. B. pinMode(PA5, INPUT_PULLUP) bzw. Bit im Port-Register setzen). Dann ist PA5 bei offenem Schalter High und bei betätigtem Low. (1 Punkt)

Ges.: Strom I_{R1} bei betätigtem -S1; Begründung für U_\mathrm{PA3} = 3{,}3\ \mathrm{V} bei offenem -S1

Bei betätigtem Taster liegt die ganze Spannung an -R1 (1 Punkt):

\def\arraystretch{2.3} \begin{array}{rcl|l} I_{R1} & = & \frac{U_\mathrm{B}}{R_1} & \\ I_{R1} & = & \frac{3{,}3\ \mathrm{V}}{10\ \mathrm{k\Omega}} & \\ I_{R1} & = & \underline{\underline{0{,}330\ \mathrm{mA}}} & \end{array}

(1 Punkt)

Bei offenem Taster fließt nur der winzige Eingangsstrom des CMOS-Eingangs (Leckstrom, höchstens im µA-Bereich) durch -R1. Der Spannungsabfall U_{R1} = R_1 \cdot I ist deshalb praktisch null, und an PA3 liegt nahezu die volle Spannung von 3,3 V. (1 Punkt)

• Pegel statt Flanke: Das Programm fragt den Pegel ab, nicht die Änderung. loop() läuft viele tausend Mal pro Sekunde; solange der Taster gedrückt ist, ist die Bedingung in jedem Durchlauf wahr, und der Zähler steigt bei jedem Durchlauf. Ein Druck von 0,2 s ergibt so Hunderte Zählungen (gebremst nur durch die serielle Ausgabe). (2 Punkte)
• Prellen: Auch wenn nur der Wechsel von HIGH nach LOW gezählt wird, öffnet und schließt der mechanische Kontakt in den ersten Millisekunden mehrmals. Jede dieser Flanken würde gezählt. (1 Punkt)

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)

const unsigned long DEBOUNCE_MS = 20;   // Wartezeit zum Entprellen in ms
const int TARGET_COUNT = 10;            // Sollzahl der Betätigungen

int lastState = HIGH;                   // letzter gültiger Pegel (unbetätigt: HIGH)
int pressCount = 0;                     // gezählte Betätigungen

void setup() {
  Serial.begin(115200);
  pinMode(BUTTON1_PIN, INPUT_PULLUP);   // Taster gegen GND, interner Pull-up
  pinMode(LED1_PIN, OUTPUT);
  digitalWrite(LED1_PIN, LOW);
}

void loop() {
  int state = digitalRead(BUTTON1_PIN);
  if (state != lastState) {             // Flanke erkannt
    delay(DEBOUNCE_MS);                 // Prellen abwarten
    state = digitalRead(BUTTON1_PIN);
    if (state != lastState) {           // neuer Pegel ist stabil
      lastState = state;
      if (state == LOW) {               // nur die fallende Flanke zählt
        pressCount++;
        Serial.print("Betaetigungen: ");
        Serial.println(pressCount);
        if (pressCount >= TARGET_COUNT) {
          digitalWrite(LED1_PIN, HIGH); // Sollzahl erreicht: LED 1 an
        }
      }
    }
  }
}

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

const unsigned long DEBOUNCE_MS = 20;   // Wartezeit zum Entprellen in ms
const int TARGET_COUNT = 10;            // Sollzahl der Betätigungen

int lastState = HIGH;                   // letzter gültiger Pegel (unbetätigt: HIGH)
int pressCount = 0;                     // gezählte Betätigungen

void setup() {
  Serial.begin(115200);
  pinMode(BUTTON1_PIN, INPUT_PULLUP);   // Taster gegen GND, interner Pull-up
  pinMode(LED1_PIN, OUTPUT);
  digitalWrite(LED1_PIN, LOW);
}

void loop() {
  int state = digitalRead(BUTTON1_PIN);
  if (state != lastState) {             // Flanke erkannt
    delay(DEBOUNCE_MS);                 // Prellen abwarten
    state = digitalRead(BUTTON1_PIN);
    if (state != lastState) {           // neuer Pegel ist stabil
      lastState = state;
      if (state == LOW) {               // nur die fallende Flanke zählt
        pressCount++;
        Serial.print("Betaetigungen: ");
        Serial.println(pressCount);
        if (pressCount >= TARGET_COUNT) {
          digitalWrite(LED1_PIN, HIGH); // Sollzahl erreicht: LED 1 an
        }
      }
    }
  }
}

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

const unsigned long DEBOUNCE_MS = 20;   // Wartezeit zum Entprellen in ms
const int TARGET_COUNT = 10;            // Sollzahl der Betätigungen

int lastState = HIGH;                   // letzter gültiger Pegel (unbetätigt: HIGH)
int pressCount = 0;                     // gezählte Betätigungen

void setup() {
  Serial.begin(115200);
  pinMode(BUTTON1_PIN, INPUT_PULLUP);   // Taster gegen GND, interner Pull-up
  pinMode(LED1_PIN, OUTPUT);
  digitalWrite(LED1_PIN, LOW);
}

void loop() {
  int state = digitalRead(BUTTON1_PIN);
  if (state != lastState) {             // Flanke erkannt
    delay(DEBOUNCE_MS);                 // Prellen abwarten
    state = digitalRead(BUTTON1_PIN);
    if (state != lastState) {           // neuer Pegel ist stabil
      lastState = state;
      if (state == LOW) {               // nur die fallende Flanke zählt
        pressCount++;
        Serial.print("Betaetigungen: ");
        Serial.println(pressCount);
        if (pressCount >= TARGET_COUNT) {
          digitalWrite(LED1_PIN, HIGH); // Sollzahl erreicht: LED 1 an
        }
      }
    }
  }
}

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

const unsigned long DEBOUNCE_MS = 20;   // Wartezeit zum Entprellen in ms
const int TARGET_COUNT = 10;            // Sollzahl der Betätigungen

int lastState = HIGH;                   // letzter gültiger Pegel (unbetätigt: HIGH)
int pressCount = 0;                     // gezählte Betätigungen

void setup() {
  Serial.begin(115200);
  pinMode(BUTTON1_PIN, INPUT_PULLUP);   // Taster gegen GND, interner Pull-up
  pinMode(LED1_PIN, OUTPUT);
  digitalWrite(LED1_PIN, LOW);
}

void loop() {
  int state = digitalRead(BUTTON1_PIN);
  if (state != lastState) {             // Flanke erkannt
    delay(DEBOUNCE_MS);                 // Prellen abwarten
    state = digitalRead(BUTTON1_PIN);
    if (state != lastState) {           // neuer Pegel ist stabil
      lastState = state;
      if (state == LOW) {               // nur die fallende Flanke zählt
        pressCount++;
        Serial.print("Betaetigungen: ");
        Serial.println(pressCount);
        if (pressCount >= TARGET_COUNT) {
          digitalWrite(LED1_PIN, HIGH); // Sollzahl erreicht: LED 1 an
        }
      }
    }
  }
}

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.

Bewertung: Liste mit Taster 1 und LED 1 (1 Punkt), pinMode() mit INPUT_PULLUP und OUTPUT (1 Punkt), letzten Pegel speichern und Änderung erkennen (2 Punkte), Wartezeit und erneutes Lesen (1 Punkt), nur fallende Flanke zählen (1 Punkt), Ausgabe des Zählerstands (1 Punkt), LED ab zehn Betätigungen (1 Punkt). Eine Lösung, die statt delay() mit millis() entprellt, ist ebenso richtig.

Geg.: U_\mathrm{B} = 3{,}3\ \mathrm{V}, R_\mathrm{int} = 45\ \mathrm{k\Omega}, R_\mathrm{ext} = 4{,}7\ \mathrm{k\Omega}

Ges.: I_\mathrm{int}, I_\mathrm{ext} bei gedrücktem Taster; Begründung

Bei gedrücktem Taster liegt die ganze Spannung am Pull-up-Widerstand:

\def\arraystretch{2.3} \begin{array}{rcl|l} I_\mathrm{int} & = & \frac{U_\mathrm{B}}{R_\mathrm{int}} & \\ I_\mathrm{int} & = & \frac{3{,}3\ \mathrm{V}}{45\ \mathrm{k\Omega}} & \\ I_\mathrm{int} & = & \underline{\underline{73{,}3\ \mathrm{\mu A}}} & \end{array}

(1 Punkt)

\def\arraystretch{2.3} \begin{array}{rcl|l} I_\mathrm{ext} & = & \frac{U_\mathrm{B}}{R_\mathrm{ext}} & \\ I_\mathrm{ext} & = & \frac{3{,}3\ \mathrm{V}}{4{,}7\ \mathrm{k\Omega}} & \\ I_\mathrm{ext} & = & \underline{\underline{0{,}702\ \mathrm{mA}}} & \end{array}

(1 Punkt)

Begründung: Eine lange Leitung fängt Störungen ein und hat eine merkliche Kapazität. Der niederohmige externe Pull-up hält den Eingang mit etwa zehnmal mehr Strom fest auf High, sodass eingekoppelte Störimpulse ihn kaum unter die Low-Schwelle ziehen, und lädt die Leitungskapazität nach dem Loslassen schneller wieder auf. Der Mehrverbrauch von 0,7 mA fließt nur, solange der Taster gedrückt ist, und ist für ein netzversorgtes Gerät unerheblich. (2 Punkte)

• Pegel: Bei abgezogenem Stecker hängt nur noch der Pull-up am Eingang; er liest dauerhaft HIGH. (1 Punkt)
• Schließer: HIGH bedeutet „nicht betätigt“. Der Fehler fällt nicht auf, und die Pumpe ließe sich im Ernstfall nicht ausschalten. (1 Punkt)
• Öffner: HIGH bedeutet „betätigt“. Bei abgezogenem Stecker oder Drahtbruch schaltet die Steuerung die Pumpe ab, der Fehler fällt sofort auf. Für „Pumpe aus“ ist deshalb ein Öffner zu wählen; das Programm wertet dann HIGH als Abschaltbefehl. (1 Punkt)

Geg.: R_1 = 22\ \mathrm{k\Omega}, R_2 = 470\ \mathrm{\Omega}, C_1 = 470\ \mathrm{nF}, U_\mathrm{B} = 3{,}3\ \mathrm{V}, U_\mathrm{T+} = 1{,}9\ \mathrm{V}, U_\mathrm{T-} = 1{,}1\ \mathrm{V}, Prellzeit höchstens 5 ms

Ges.: Ursache für Mehrfachzählung

Mechanische Kontakte prellen: Beim Schließen (und Öffnen) federn die Kontaktflächen zurück und öffnen und schließen in den ersten Millisekunden mehrmals. (1 Punkt) Der Zählereingang ist schnell genug, um jede dieser Flanken als eigenes Ereignis zu zählen; aus einem Tastendruck werden so mehrere Stück. (1 Punkt)

Ges.: Zeit t_1 beim Betätigen bis u_C < U_\mathrm{T-}, Zeit t_2 nach dem Loslassen bis u_C > U_\mathrm{T+}, Beurteilung

Betätigen: Der Taster entlädt C_1 über R_2 (der Knoten am Taster liegt auf Masse, R_1 spielt für den Kondensator keine Rolle) (1 Punkt):

\def\arraystretch{2.3} \begin{array}{rcl|l} u_C & = & U_\mathrm{B} \cdot e^{-\frac{t_1}{R_2 \cdot C_1}} & \color{gray}{\text{mit } u_C = U_\mathrm{T-}} \\ t_1 & = & R_2 \cdot C_1 \cdot \ln\frac{U_\mathrm{B}}{U_\mathrm{T-}} & \\ t_1 & = & 470\ \mathrm{\Omega} \cdot 470\ \mathrm{nF} \cdot \ln\frac{3{,}3\ \mathrm{V}}{1{,}1\ \mathrm{V}} & \\ t_1 & = & 0{,}221\ \mathrm{ms} \cdot 1{,}10 \approx \underline{\underline{0{,}243\ \mathrm{ms}}} & \end{array}

(1 Punkt)

Loslassen: C_1 lädt sich über R_1 + R_2 auf (1 Punkt):

\def\arraystretch{2.3} \begin{array}{rcl|l} u_C & = & U_\mathrm{B} \cdot \left(1 - e^{-\frac{t_2}{(R_1 + R_2) \cdot C_1}}\right) & \color{gray}{\text{mit } u_C = U_\mathrm{T+}} \\ e^{-\frac{t_2}{(R_1 + R_2) \cdot C_1}} & = & \frac{U_\mathrm{B} - U_\mathrm{T+}}{U_\mathrm{B}} & \color{gray}{\ln} \\ t_2 & = & (R_1 + R_2) \cdot C_1 \cdot \ln\frac{U_\mathrm{B}}{U_\mathrm{B} - U_\mathrm{T+}} & \\ t_2 & = & 22{,}47\ \mathrm{k\Omega} \cdot 470\ \mathrm{nF} \cdot \ln\frac{3{,}3\ \mathrm{V}}{1{,}4\ \mathrm{V}} & \\ t_2 & = & 10{,}6\ \mathrm{ms} \cdot 0{,}857 \approx \underline{\underline{9{,}08\ \mathrm{ms}}} & \end{array}

Mit gerundeten Zwischenergebnissen ergibt sich: t_2 \approx 9{,}08\ \mathrm{ms}

Ohne gerundete Zwischenergebnisse ergibt sich: t_2 \approx 9{,}06\ \mathrm{ms}

(1 Punkt)

Beurteilung: Beim Betätigen schaltet der Ausgang nach rund 0,24 ms – die kurzen Öffnungen beim Prellen laden C_1 über die 22 kΩ kaum auf, die Spannung bleibt unter U_\mathrm{T+}. Beim Loslassen vergehen rund 9 ms bis zum Umschalten; jedes erneute Schließen während des Prellens entlädt C_1 wieder. Da 9 ms deutlich länger sind als die höchstens 5 ms Prellzeit, entsteht je Tastendruck genau ein Impuls. Die Entprellung reicht aus, und die Verzögerung merkt die Mitarbeiterin nicht. (2 Punkte)

Ges.: Auswirkung eines Inverters ohne Schmitt-Trigger

Ein gewöhnlicher Inverter hat nur eine Schaltschwelle und keine Hysterese. Die langsam ansteigende Kondensatorspannung verweilt lange im Übergangsbereich; kleine Störungen oder Restprellen lassen den Ausgang dort mehrfach kippen oder schwingen, und die Eingangsstufe zieht erhöhten Querstrom. (1 Punkt) Der Zähler kann dadurch wieder Mehrfachimpulse zählen. Die Reparatur ist fehlerhaft; es muss wieder ein Baustein mit Schmitt-Trigger-Eingang eingesetzt werden. (1 Punkt)

Ges.: Fehler, Verhalten, Korrektur

• Fehler: Das RS-Flipflop braucht einen Wechsler, der abwechselnd \overline{S} und \overline{R} gegen Masse schaltet. Mit einem Schließer an \overline{S} wird das Flipflop nie zurückgesetzt. (1 Punkt)
• Verhalten: Beim ersten Tastendruck geht Q auf 1 und bleibt dort, weil \overline{R} dauerhaft High ist (Speichern). Der Zähler zählt nach dem Einschalten genau ein Paket und danach keines mehr. (1 Punkt)
• Korrektur: Taster gegen einen Wechsler tauschen: gemeinsamer Kontakt an Masse, Schließer-Kontakt an \overline{S}, Öffner-Kontakt an \overline{R}, beide Eingänge mit Pull-up. Alternativ das RC-Glied mit Schmitt-Trigger einsetzen, das mit einem Schließer auskommt. (1 Punkt)

Ges.: Beurteilung des Reset-Entwurfs, drei Verbesserungen

Beurteilung: Der Entwurf ist ungünstig. Der Taster prellt direkt am Reset-Eingang und erzeugt beim Drücken und Loslassen mehrere kurze, unterschiedlich lange Impulse; zu kurze Impulse lösen keinen sicheren Reset aus oder lassen den Controller in einem undefinierten Zustand anlaufen. Der hochohmige interne Pull-up macht den Eingang außerdem störempfindlich (Fehl-Resets). (1 Punkt)

Verbesserungen (3 Punkte, je Bauteil mit Aufgabe 1 Punkt):

• Kondensator (z. B. 100 nF … 1 µF) vom Reset-Eingang gegen Masse: bildet mit dem Pull-up ein RC-Glied, überbrückt das Prellen und verlängert den Impuls nach dem Loslassen auf einige Millisekunden.
• Externer Pull-up-Widerstand (z. B. 10 kΩ) nach U_\mathrm{B}: niederohmiger als der interne, legt die Zeitkonstante fest und macht den Eingang störfest.
• Schutzwiderstand (einige 100 Ω) in Reihe zum Taster: begrenzt den Entladestrom des Kondensators.
• alternativ bzw. zusätzlich ein Reset-Baustein (supervisor) mit Schmitt-Trigger-Eingang, der einen Impuls fester Mindestlänge liefert, oder eine Diode nach U_\mathrm{B}, die den Kondensator beim Abschalten entlädt.