id: p4mG8UQd3ozMCs4NEqsgLjME8hL7jN40mgr6PyIS
createdBy: erf3ktYZevr4
dateCreated: 1689064662293
name: Komplexaufgabe 3 - Interrupts
meta:
  logo: >-
    https://raw.githubusercontent.com/TUBAF-IfI-LiaScript/VL_EAVD/master/excercise/images/excercise_04.png
  description: >-
    Die Aufgabe 3 zielt darauf eine Motorsteuerung mit einer visuellen Ausgabe zu kombinieren und für die Synchronisation der beiden Komponenten einen Interrupt zu nutzen.
  selfAssign: true
  defaultNumberOfRooms: '2'
members:
  teacher: []
  student: []
modules:
  - url: https://edrys-labs.github.io/module-markdown-it/index.html
    config:
      content: >-
        # Komplexaufgabe 3 - Interrupts

        Liebe Teilnehmerinnen und Teilnehmer, 
        
        
        analog zu den vorangegangen soll Ihnen auch diese Komplexaufgabe Gelegenheit geben sich zusätzlich zu den praktischen Übungen mit den Grundlagen der
        Programmierung eingebetteter Systeme vertraut zu machen.
        
        
        Die Aufgabe ist so konzipiert, dass Sie die Lösung selbstständig erarbeiten können. 
        Sollten Sie dennoch Fragen haben, können Sie sich gerne an die Betreuer wenden.


        Für die Aufgabe erläutert Raum 1 die Fragestellungen und Lernziele.
        Danach ist in Raum 2 eine Simulatorübung zur Fehlerbehebung vorgesehen.
        Die praktische Umsetzung auf dem Laborsetup erfolgt auf der "Station".


        Noch umfasst unsere Lösung keinen Multi-User-Modus - entsprechend könnten Sie einen Kommilitonen ziemlich ärgern, 
        wenn Sie ihm die Kontrolle entziehen. Prüfen Sie also bitte vorher, ob das Setup gerade von jemand anderem verwendet wird.
        Die „Station" merkt sich immer den letzten Stand, 
        verlassen Sie Ihren Arbeitsplatz ordentlich und kopieren sie vor dem verlassen einfach den Original-Code in den Editor…


        Ein kleines Video-Tutorial über die Verwendung von Edrys:


        <video

        controls

        src="https://github.com/edrys-labs/lab-tubaf-embedded-systems/raw/refs/heads/main/media/task3-motivation.webm"

        width="100%">

        Sorry, your browser doesn't support embedded videos, but don't worry, you
        can

        <a
        href="https://github.com/edrys-labs/lab-tubaf-embedded-systems/raw/refs/heads/main/media/task3-motivation.webm">download
        it</a>

        and watch it with your favorite video player!

        </video>

        > Ihre Codeänderungen werden auf der Station anonymisiert gespeichert. Wir
        wollen damit tatsächliche Problemfelder identifizieren, um damit die
        Veranstaltung systematisch weiterzuentwickeln. Aus den Daten
        können keine Rückschlüsse auf den Teilnehmenden oder spezifika des
        Rechners gezogen werden. Wenn Sie Fragen dazu haben, sprechen Sie uns gern an.


        Wir freuen uns auf Ihr Feedback und Ihre Anregungen.


        _Ihr CrossLab Team_
    studentConfig:
      content: ''
    teacherConfig:
      content: ''
    stationConfig:
      content: ''
    showInCustom: lobby
    width: full
    height: huge
  - url: https://edrys-labs.github.io/module-markdown-it/index.html
    config:
      content: >-
        # Aufgabeninhalt


        ## Lernziele


        * Konfiguration und Nutzung von Interrupts zur Erkennung und Reaktion auf externe Ereignisse

        * Steuerung eines Schrittmotors mit präziser Positionsbestimmung

        * Visualisierung der Motorposition auf einem LED-Ring

        * Nutzung globaler Variablen mit volatile zur Synchronisation zwischen Hauptprogramm und Interrupt-Service-Routine

        * Strukturierung des Programmcodes durch Auslagerung wiederverwendbarer Funktionen
        

        ## Aufgabenstellung

        Entwickeln Sie einen Programmcode, der folgende Anforderungen erfüllt:

        * **Interrupt-Routine (ISR)**: implementieren Sie eine ISR, die bei einer fallenden Flanke des Sensors (Pin 2) die globale, 
          als volatile deklarierte Variable position auf 0 setzt, wenn ein Signal detektiert wird

        * **Ersatz des Polling-Ansatzes**: entfernen Sie das bisherige Polling im Hauptprogramm und ersetzen Sie es durch die ISR, 
          um den Sensorstatus effizient zu erfassen

        * **Visualisierung der Motorposition**: binden Sie den LED-Ring (24 LEDs) ein und skalieren Sie den Positionswert position auf den Wertebereich des LED-Rings, 
          um die aktuelle Motorposition anzuzeigen

        * **Ansteuerung des Schrittmotors**: steuern Sie einen Schrittmotor (2048 Schritte/Umdrehung) für 3 volle Umdrehungen an und synchronisieren Sie die LED-Visualisierung mit der Motorbewegung


        ## Technische Basis

        Die Umsetzung erfolgt auf einem Arduino Uno mit den folgenden Komponenten:


        | Bautteil                | Bezeichnung                 | Elektrische Verbindung       |

        | ----------------------- | --------------------------- | ---------------------------- |

        | Schrittmotor            | 28BYJ-48                    | Pins 8, 9, 10, 11            |

        | Motortreiber            | ULN2003                     | Versorgung des Schrittmotors |

        | Magnetischer Sensor     | Hall-Sensor                 | Pin 2, 5V, GND               |

        | LED-Ring                | Adafruit NeoPixel (24 LEDs) | Pin 3, 5V, GND               |


        > Der Zeitaufwand für die Umsetzung der Aufgabe beträgt etwa 90 Minuten.
    studentConfig:
      content: ''
    teacherConfig:
      content: ''
    stationConfig:
      content: ''
    showInCustom: Room 1
    width: full
    height: tall
  - url: https://edrys-labs.github.io/module-markdown-it/index.html
    config:
      content: >-
        # Arduino Layout


        ![ArduinoLayout](https://docs.arduino.cc/static/6ec5e4c2a6c0e9e46389d4f6dc924073/a6d36/Pinout-UNOrev3_latest.png)
    studentConfig:
      content: ''
    teacherConfig:
      content: ''
    stationConfig:
      content: ''
    showInCustom: Room 1
    width: half
    height: tall
  - url: https://edrys-labs.github.io/module-markdown-it/index.html
    config:
      content: >-
        # Simulatorübung: Fehlerhafte Interrupt-Steuerung

        Interrupts ermöglichen es einem Mikrocontroller, sofort auf externe Ereignisse zu reagieren, 
        ohne ständig die entsprechenden Pins abzufragen. Dies ist besonders nützlich für zeitkritische Anwendungen wie das Umschalten von Zuständen bei einem Tasterdruck.


        In dieser Übung verwenden wir einen Taster an Pin 2, um die LED an Pin 13 ein- und auszuschalten. 
        Ein Interrupt soll dafür sorgen, dass die LED bei jedem Tasterdruck ihren Zustand wechselt. 
        Die gegebenen Codefragmente enthalten jedoch Fehler, die behoben werden müssen.


        > **Aufgabe**: Korrigieren Sie die Fehler in den Codefragmenten, um den Interrupt korrekt zu konfigurieren und die LED bei jedem Tasterdruck umzuschalten.
    studentConfig:
      content: ''
    teacherConfig:
      content: ''
    stationConfig:
      content: ''
    showInCustom: Room 2
    width: half
    height: tall
  - url: https://edrys-labs.github.io/module-editor/index.html
    config:
      runCommand: execute
      language: cpp
      synchronize: false
      editorText: |
        #define BUTTON_PIN 2 // Der Pin, an dem der Taster angeschlossen ist 
        #define LED_PIN 13   // Die eingebaute LED 

        volatile bool ledState = false;     // Variable zur Steuerung der LED
        unsigned long lastInterruptTime = 0; // Speichert den letzten Interrupt-Zeitpunkt

        void setup() {
          pinMode(LED_PIN, OUTPUT);           // LED-Pin konfigurieren
          pinMode(BUTTON_PIN, INPUT);         // Taster-Pin ohne Pullup konfigurieren (Fehler: kein Pullup-Widerstand)

          attachInterrupt(BUTTON_PIN, toggleLED, FALLING); // Fehler: falsche Funktion Argumente

          Serial.begin(9600);

          digitalWrite(LED_PIN, HIGH);        // LED initial eingeschaltet (Fehler: sollte LOW sein)
        }

        void loop() {
          if (ledState) {                     // Fehler: Kontrolliert LED-Zustand außerhalb des Interrupts
            digitalWrite(LED_PIN, HIGH);
          } else {
            digitalWrite(LED_PIN, LOW);
          }
        }

        // Interrupt-Service-Routine (ISR) ohne Entprellung
        void toggleLED() {
            ledState = !ledState;               // Zustand der LED umschalten
            digitalWrite(LED_PIN, ledState);    // LED ein- oder ausschalten
            Serial.print("LED: ");
            if (ledState) {
              Serial.println("ON");
            } else {
              Serial.println("OFF");
            }
            lastInterruptTime = millis();       // Fehler: Entprell-Logik fehlt
        }
    studentConfig: ''
    teacherConfig: ''
    stationConfig: ''
    showInCustom: Room 2
    width: full
    height: huge
  - url: https://edrys-labs.github.io/module-avr8js/index.html
    config:
      modules: |
        <center>
          <wokwi-led color='red' pin='13' label='Pin 13'></wokwi-led>

          <wokwi-pushbutton color='green'   pin='2' label='Pin
          2'></wokwi-pushbutton>
          
          <div id='simulation-time'></div>
        </center>
      execute: execute
    studentConfig: ''
    teacherConfig: ''
    stationConfig: ''
    showInCustom: Room 2
    width: half
    height: tall
  - url: https://edrys-labs.github.io/module-editor/index.html
    config:
      runCommand: execute
      language: cpp
      theme: light
      editorText: |-
        #include <Stepper.h>
        #include <Adafruit_NeoPixel.h>

        // Anzahl der Schritte pro Umdrehung
        #define STEPS      2048
        // Motorgeschwindigkeit in RPM
        #define MOTOR_RPM     6
        Stepper stepper(STEPS, 8, 10, 9, 11); // Motor Pins

        #define PIN           3
        #define NUMPIXELS    24
        Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

        int position = 0;

        void setup()
        {
            pinMode(8, OUTPUT);
            pinMode(9, OUTPUT);
            pinMode(10, OUTPUT);
            pinMode(11, OUTPUT);
            pinMode(11, OUTPUT);
            pinMode(2, INPUT_PULLUP);

            Serial.begin(9600);
            Serial.println("Motor startet");

            pixels.begin();
            pixels.clear();

            stepper.setSpeed(MOTOR_RPM);
            int steps = 8;
            int counter = 0;
            // Generiere 3 Drehungen
            // Überwache den Endlagensensor im Polling Mode und aktiviere den LED Ring
            while (counter < 3 * STEPS) {
                stepper.step(steps);
                position=position+steps;
                if (digitalRead(2) == 0) {
                  for (int i=0; i<NUMPIXELS; i++)
                    pixels.setPixelColor(i, pixels.Color(0, 150, 0));
                  pixels.show();
                } else {
                  pixels.clear();
                  pixels.show();
                }
                counter += 3;
                Serial.println(counter);
            }
            Serial.println("3 Runden absolviert");
        }

        void loop()
        {
        }
    showInCustom: station
    width: full
    height: medium
  - url: https://edrys-labs.github.io/module-station-stream/index.html
    stationConfig:
      video: true
      audio: false
    showInCustom: station
    width: half
    height: medium
  - url: https://edrys-labs.github.io/module-pyxtermjs/index.html
    config: ''
    studentConfig: ''
    teacherConfig: ''
    stationConfig:
      server: http://localhost:5000/pty
      execute: execute
      script: >
        echo $CODE | base64 --decode > Hello.ino

        arduino-cli sketch new Hello

        olddir=$(pwd)

        mv Hello.ino Hello

        cd Hello

        arduino-cli board attach -p /dev/ttyACM0 -b arduino:avr:uno

        cd $olddir

        arduino-cli compile Hello && arduino-cli upload -p /dev/ttyACM0 Hello &&
        arduino-cli monitor -p /dev/ttyACM0
      enable:
        teacher: true
        student: true
    showInCustom: station
    width: full
    height: tall
  - url: https://edrys-labs.github.io/module-markdown-it/index.html
    config:
      content: >-
        # Komplexaufgabe 3 - Interrupts


        > Die Aufgabe 3 zielt darauf eine Motorsteuerung mit einer visuellen
        Ausgabe zu kombinieren und für die

        > Synchronisation der beiden Komponenten einen Interrupt zu nutzen.


        Die Arduino-Implementierung illustriert die erwartete Funktionalität
        grundlegend.

        Ein Schrittmotor mit 2048 Schritten bewegt sich für 3 volle Umdrehungen.

        Der Motor wird über einen Treiber (ULN2003) angesteuert.

        Die Ansteuerung erfolgt über die Pins 8, 9, 10 und 11.

        An der breiten Spitze des Zeigers ist ein Magnet befestigt, der einen
        Sensor aktiviert, sofern er darüber fährt.

        Dieser ist am Pins 2 angeschlossen.

        Die vorliegende Implementierung realisiert ein Polling des Sensors
        (`0`==Zeiger in der Nähe) und aktivert dann den LED-Ring.


        Passen Sie diesen Code so an, dass auf dem LED-Ring die jeweilige Position
        des Zeigers visualisiert wird.

        Dazu müssen Sie den Code so erweitern, dass der Sensor mittels eines
        Interrupts abgefragt wird:


        + Integrieren Sie eine Interrupt-Routine, die bei einer fallenden Flanke
        des Sensors aufgerufen wird.

        + Ersetzen Sie den Positionswert des Zeigers `count` durch eine globale
        Variabel `position`. Deren Wert wird innerhalb der Interrupt Service
        Routine auf 0 gesetzt. Vergessen Sie dabei das `volatile` für die Variable
        nicht!

        + Bilden Sie den die Wert der `position` auf den Wertebereich des
        LED-Rings (24 LEDs) ab.


        ## Original Code


        ```cpp

        #include <Stepper.h>

        #include <Adafruit_NeoPixel.h>


        // Anzahl der Schritte pro Umdrehung

        #define STEPS      2048

        // Motorgeschwindigkeit in RPM

        #define MOTOR_RPM     6

        Stepper stepper(STEPS, 8, 10, 9, 11); // Motor Pins


        #define PIN           3

        #define NUMPIXELS    24

        Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);


        int position = 0;


        void setup()

        {
            pinMode(8, OUTPUT);
            pinMode(9, OUTPUT);
            pinMode(10, OUTPUT);
            pinMode(11, OUTPUT);
            pinMode(11, OUTPUT);
            pinMode(2, INPUT_PULLUP);

            Serial.begin(9600);
            Serial.println("Motor startet");

            pixels.begin();
            pixels.clear();

            stepper.setSpeed(MOTOR_RPM);
            int steps = 8;
            int counter = 0;
            // Generiere 3 Drehungen
            // Überwache den Endlagensensor im Polling Mode und aktiviere den LED Ring
            while (counter < 3 * STEPS) {
                stepper.step(steps);
                position=position+steps;
                if (digitalRead(2) == 0) {
                  for (int i=0; i<NUMPIXELS; i++)
                    pixels.setPixelColor(i, pixels.Color(0, 150, 0));
                  pixels.show();
                } else {
                  pixels.clear();
                  pixels.show();
                }
                counter += 3;
                Serial.println(counter);
            }
            Serial.println("3 Runden absolviert");
        }


        void loop()

        {

        }

        ```
    studentConfig:
      content: ''
    teacherConfig:
      content: ''
    stationConfig:
      content: ''
    showInCustom: station
    width: half
    height: tall
  - url: https://edrys-labs.github.io/module-code-logger/
    config: ''
    studentConfig: ''
    teacherConfig: ''
    stationConfig: ''
    showInCustom: station, station-only
    width: full
    height: tall
  - url: https://edrys-labs.github.io/module-station-light-control/index.html
    config: ''
    studentConfig: ''
    teacherConfig: ''
    stationConfig: ''
    showInCustom: station, station-only
    width: third
    height: short