Ereignisgesteuerte Programmierung

Abb. 1: Pulsierende LED

Autor:	Prof. Dr.-Ing. Schneider
Modul:	Praxismodul I
Gruppe:	B
Lektion 8:	Mechatronik, Informatikpraktikum, 1. Semester, Wintersemester

Inhalt

• Programmierrichtlinien
• Taster mittels Arduino auslesen, entprellen, Pull-Up/Pull-Down-Widerstand
• Zähler inkrementieren
• switch..case-Verzweigung
• Ansteuerung einer RGB-LED

Lernziele

Nach Durchführung dieser Lektion können die Studierenden

• einen Taster mithilfe eines Hardware-Interrupts einlesen und das Eingangssignal softwareseitig entprellen.
• die Aufgaben einer Interrupt-Service-Routine und der Hauptprogrammschleife unterscheiden.
• Ereignisse mithilfe globaler Variablen zwischen Interrupt-Service-Routine und Hauptprogramm austauschen.
• einfache Zustandsautomaten mithilfe von Zählern und switch-case-Verzweigungen implementieren.
• LEDs mithilfe von PWM-Signalen in unterschiedlichen Helligkeitsstufen ansteuern.
• eine RGB-LED durch Kombination mehrerer PWM-Signale in unterschiedlichen Farben ansteuern.
• ihre Programme systematisch testen, dokumentieren und mithilfe von SVN versionieren.

Lernzielkontrolle

1. Wurde der Taster erfolgreich eingelesen und entprellt?
2. Wozu benötigt man einen Pull-Up/Pull-Down-Widerstand?
3. Wurde der Quelltext durch Header und Kommentare aufgewertet?
4. Welche Möglichkeiten gibt es einen Zähler zu in-/dekrementieren?
5. Wurde in Aufgabe 4.3 ein switch...case verwendet?
6. Welche Version der RGB-LED haben Sie verwendet (gemeinsame Anode oder Kathode)?

Arbeitsergebnisse in SVN: Lernzielkontrolle_Termin_04.pdf

Tutorials

• Arduino Befehlsübersicht
• Funduino: Taster am Arduino
• Funduino: RGB LED ansteuern
• Schalter entprellen mit Interrupt Service Routine
• Wiki: HSHL-Bibliothek einbinden
• Programmierrichtlinie für C

Demo

SVN: DemoInterrupt.ino

Versuchsvorbereitung

1. Binden Sie die HSHL-Bibliothek ein.
2. Studieren Sie den Artikel Interrupt Service Routine.
3. Studieren Sie das Demo SVN: DemoInterrupt.ino.
4. Studieren Sie das Tutorials.
5. Studieren Sie die Programmierrichtlinie.
6. Planen Sie die Software via PAP.
7. Beantworten Sie die Lernzielkontrollfragen, welche die Vorbereitung betreffen.
8. Lösen Sie im Vorfeld die Aufgaben 2-4 mit Wokwi.
9. Sichern Sie Ihre Versuchsvorbereitung in SVN: TasterSchaltetLED.ino, switchLED.ino und steureFarbigeLED.ino.

Musterlösung 1 

• Studieren Sie den Artikel Interrupt Service Routine.
• SVN: DemoInterrupt.ino

Musterlösung 2 

Lösung 2 - millis(): Beispiel, wie man einen Taster entprellt.

Versuchsdurchführung

Aufgabe 1: Besprechung der Versuchsvorbereitung

1. Starten Sie den Arbeitsplatzrechner.
2. Loggen Sie sich als .\hshl-user ein.
3. Löschen Sie unter Tortoise SVN → Settings → Saved Data → Authentification Data.
4. Legen Sie sich auf der Datenpartition unter D:\SVN ein Repositorium "Inf1P" an.
5. Stellen Sie mit SVN Checkout die Verbindung zum SVN-Server her (Checkout-URL: https://svn.hshl.de/svn/Informatikpraktikum_1/trunk/Gruppen).
6. Präsentieren Sie Prof. Schneider die Ergebnis Ihrer Vorbereitung.

Aufgabe 2: Eine LED per Tastendruck aktivieren

Eine LED soll für 5 Sekunden leuchten, wenn ein Taster betätigt wurde.

1. Lesen Sie einen Tasterdruck via Interrupt-Service-Routine ein und speichern Sie diesen in die globale Variable TasterStatus_bit.
2. Werten Sie die Variable TasterStatus_bit im void loop() aus.
3. Geben Sie den Wert der Variable TasterStatus_bit im seriellen Monitor aus.
4. Wird der Taster gedrückt, soll eine LED für fünf Sekunden leuchten. Die LED soll nach fünf Sekunden automatisch ausgehen, ohne dass die Interruptverarbeitung blockiert wird.

Nützliche Befehle: pinMode(), digitalRead(), digitalWrite(), delay, if..else, attachInterrupt, digitalPinToInterrupt, millis()

Arbeitsergebnisse in SVN: TasterSchaltetLED.ino

Teillösung 

Eine LED per Tastendruck aktivieren

volatile 

In C bedeutet volatile, dass sich der Wert einer Variablen jederzeit außerhalb des normalen Programmablaufs ändern kann. Der Compiler darf deshalb bestimmte Optimierungen für Zugriffe auf diese Variable nicht durchführen.
Typische Anwendungsfälle sind:

• Hardware-Register: Ein Mikrocontroller-Register kann sich durch die Hardware ändern.
• Interrupts: Eine Variable wird beispielsweise in einer Interrupt-Service-Routine verändert.
• Memory-mapped I/O: Speicheradressen repräsentieren Hardwaregeräte.
• Externe Änderungen: Ein Wert kann sich unabhängig vom normalen Programmablauf ändern.

DemoInterrupt.ino 

//*****************************************************************************
// Voraussetzungen: Taster an D2 gegen GND, interner Pullup-Widerstand Z. 30
//*****************************************************************************
const byte INTERRUPT_PIN_u8  = 2;      // Interrupt an Port D2
const byte LED_PIN_u8        = 13;     // LED auf dem Arduino an Pin 13

// Eine Variable sollte als volatile deklariert werden, wenn sie von irgendwo anders geändert werden kann außer in dem Codeteil, in dem sie auftaucht (z.B. ISR). 
volatile byte LEDZustand_u8 = LOW;     // Definiere eine globale volatile Variable für den Status der LED
volatile unsigned long alteZeit_u32=0; // Variablen für das Entprellen des Schalters,
unsigned long entprellZeit_u32=20;     // Entprellzeit 20 ms

void setup(){
/* Einmalige Initialisierung */
  pinMode(LED_PIN_u8, OUTPUT);             // Legt LED_PIN als Ausgabe fest
  pinMode(INTERRUPT_PIN_u8, INPUT_PULLUP); // Lege den Interruptpin als Eingang mit internem Pullup-Widerstand fest

  // Lege die ISR ISRwechselLED auf den Interruptpin mit Modus 'FALLING':
  // Bei fallender Flanke auf dem Interruptpin --> Führe die ISR aus
  attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN_u8), ISRwechselLED, FALLING);
}

void loop(){
  delay(10000);                        // Kann der Interrupt das 10s Delay unterbrechen?
}

void ISRwechselLED() {
    unsigned long aktuelleZeit_u32 = millis();
    if((aktuelleZeit_u32 - alteZeit_u32) > entprellZeit_u32) { // innerhalb der entprellZeit nichts machen
      LEDZustand_u8 = !LEDZustand_u8;                          // Invertierung des Zustandes, An wird aus
      digitalWrite(LED_PIN_u8, LEDZustand_u8);                 // LED ansteuern
      alteZeit_u32 = aktuelleZeit_u32;                         // letzte Schaltzeit merken      
  }
}

Aufgabe 3: Auf Knopfdruck dimmen

Ein Taster dimmt eine LED:

1. Tastendruck: an, 100% Lichtleistung
2. Tastendruck: an, 50% Lichtleistung
3. Tastendruck: aus 0%

Nützliche Befehle: pinmode(), analogWrite(), delay(), switch..case

Arbeitsergebnisse in SVN: switchLED.ino

DemoPulsierendeLED.ino  Beschaltung: Arduino-Pin D9 → Vorwiderstand (z. B. 220–330 Ω) → LED-Anode (langes Bein), LED-Kathode (kurzes Bein) → GND

/* Eine LED pulsiert langsam heller und dunkler. */
const uint8_t LED_PIN_u8 = 9; // LED mit Vorwiderstand an D9

void setup() {
    pinMode(LED_PIN_u8, OUTPUT);
}

void loop() {
    // LED langsam heller werden lassen
    static byte Helligkeit_u8 = 0;
    Helligkeit_u8++; // Überlauf bei 255
    analogWrite(LED_PIN_u8, Helligkeit_u8);
    delay(8);
}

DemoSwitchCase.ino  Eine Anleitung zur Verwendung von switch..case findet sich in der Arduino-Dokumentation.

Demo-Quelltext DemoSwitchCase.ino

//*****************************************************************************
// Modul           : DemoSwitchCase                                           *
//                                                                            *
// Datum           : 17.10.2022                                               *
//                                                                            *
// Funktion        : Demo für eine switch...case-verzweigung                  *
//                                                                            *
// Implementation  : Arduino IDE vers. 2.0.0                                  *
//                                                                            *
// Hardware        : Arduino UNO R3                                           *
//                                                                            *
// Author          : (c) 2022, Dr. Ulrich Schneider                           *
//                                                                            *
// Letzte Änderung : 17.10.2022                                               *
//                                                                            *
//*****************************************************************************
byte Cnt_u8 =0;              // Zählvariable wird angelegt und initialisiert

void setup() {
  Serial.begin(9600);        // Seriellen Monitor initialisieren, 9600 Baud
}
void loop() {
Cnt_u8++;                    // Zähler inkrementieren
if (Cnt_u8>2) Cnt_u8=0;      // Überlauf ab 2: 012012...
switch (Cnt_u8)
{
case 0:
  Serial.println("Fall 0");
  break;
case 1:
  Serial.println("Fall 1");
  break;
case 2:
  Serial.println("Fall 2");
  break;
default:
  // wird in diesem Beispiel nicht erreicht
  break;
}
delay(500); // ms für die Darstellung
}
end;

---

Aufgabe 4: Ansteuerung einer farbigen LED

Eine RGB-LED soll in verschiedenen Farben leuchten. Auf Druck des Tasters soll die RGB-LED in folgenden Modi betrieben werden:

1. Weiß
2. Rot
3. Blau
4. Grün
5. Langsamer Übergang durch das gesamte Farbspektrum (Einschlaflicht)

Nützliche Befehle: pinmode(), analogWrite(), delay()

Arbeitsergebnisse in SVN: steureFarbigeLED.ino

Teillösung 

RGB-LED ansteuern

---

Aufgabe 5: Nachhaltige Dokumentation

• Sichern Sie alle Ergebnisse mit beschreibendem Text (message) in SVN.
• Beachten Sie dabei die Software Anforderungen.

Arbeitsergebnisse in SVN: SVN Log

Literatur

1. Brühlmann, T.: Arduino Praxiseinstieg. Heidelberg: mitp, 4. Auflage 2019. ISBN 978-3-7475-0056-9. URL: HSHL-Bib, O'Reilly-URL
2. Brühlmann, T.: Sensoren im Einsatz mit Arduino. Frechen : mitp Verlag, 1. Auflage 2017. ISBN: 9783958451520. URL: HSHL-Bib, O'Reilly
3. Snieders, R.: ARDUINO lernen. Nordhorn: 8. Auflage 2022. URL: https://funduino.de/vorwort
4. Schneider, U.: Programmierrichtlinie für für die Erstellung von Software in C. Lippstadt, 1. Auflage 2022. PDF-Dokument (212 kb)

---

→ Termine von Gruppe B 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
→ zurück zum Hauptartikel: Arduino Praxiseinstieg
→ Haben Sie Fragen? Informatik Praktikum FAQ