kreative Informatik mit
Kids

Calliope Mini

als Zeitfresser

Calliope Mini Zeitfresser

In der Schul AG ist es oft so laut, dass keiner mehr irgendetwas versteht. Die AG läuft über 90 Minuten und besteht aktuell aus zwei Teilen. In der ersten Runde lernen, basteln und tüfteln wir gemeinsam und, da die Köpfe dabei ganz schön rauchen, kann im zweiten Teil gespielt werden. Das klappt zwar immer besser, oft muss man aber warten, bis wieder Ruhe ist. Damit wir aber trotzdem das schaffen, was wir uns vorgenommen haben, wird diese Wartezeit von der Spielzeit abgezogen.

Der Zeitfresser startet zum Beginn, indem das linke Pad berührt und damit der Calliope Mini - Zeitfresser über Pin 0 ein Signal empfängt. Wird es zu laut, geben wir dem Zeitfresser über das rechte Pad und damit über Pin 3 ein Signal. Die Lernzeit stoppt und die Spielzeit verringert sich. Sobald wir weitermachen können, geben wir dem Zeitfresser wieder über Pin 0 ein Signal. Nun läuft die Lernzeit ab und die restliche Spielzeit bleibt erhalten.

Wenn Taste A gedrückt => es ist leise 
Die Lernzeit verringert sich und die Spielzeit bleibt unverändert.

Wenn Taste B gedrückt => es ist laut 
Die Lernzeit bleibt stehen und die Spielzeit verringert sich.

Wenn Taste A gedrückt → alles gut → die Status LED leuchtet grün.
Wenn Taste B gedrückt → nicht gut → die Status LED leuchtet rot.

Der Funktion setzeLED wird die anzuzeigende Farbe übergeben. Diese Funktion schaltet die StatusLED zunächst aus und setzt sie dann auf die übergebene Farbe.

Wir benötigen eine Variable start die dem Calliope sagt, in welchem Zustand sich das Programm gerade befindet. 

Variable start = 0
Der Calliope wurde eingeschalten und hat noch kein weiteres Signal empfangen.

Variable start = 1
Taster A wurde gedrückt.

Variable start = 2
Taster B wurde gedrückt. 

Wir benötigen noch zwei weitere Variablen:
Variable lernZeit → Zeit in Minuten → zum Lernen
Variable spielZeit → Zeit in Minuten → zum Spielen

Die Spiel- und die Lernzeit wollen wir in Millisekunden umrechnen und uns merken.
Damit können wir dann später besser rechnen.

Da wir ständig Zeiten umrechnen müssen: von Minuten in Millisekunden und von Millisekunden in Minuten, bauen wir uns auch dafür zwei Funktionen:

1. Die Funktion minInMS soll uns Minuten in Millisekunden umrechnen.
Die Funktion empfängt einen Wert (die Minuten) und legt diesen in der Variable y ab.
Die Variable y wird mit 60 multipliziert (1 min = 60 Sekunden) und das Ergebnis wiederum mit 1000 multipliziert (1 sec = 1000 ms). Die Funktion lassen wir das Ergebnis zurückgeben. So können wir den berechneten Wert gleich an die Variable lernZeitMS übergeben.

2. Die Funktion msInMin soll uns Millisekunden in Minuten umrechnen.
Die Funktion empfängt einen Wert (die Millisekunden) und legt diesen in der Variable z ab.
Die Variable z wird durch 1000 geteilt (1000 ms = 1 s) und das Ergebnis durch 60 geteilt (60 sec = 1 min). Das Ergebnis lassen wir uns zurückgeben. 
Diese Funktion benötigen wir erst später.

Jetzt interessiert uns noch, wie viel LernZeit bereits vergangen ist und wie viel uns noch bleibt. Das Gleiche wollen wir auch von der SpielZeit wissen. Wir legen uns noch 4 Variablen an, in die wir die entsprechenden Werte jeweils ablegen können:

Variable vergangeneLernZeit
Variable restLernZeit

Variable vergangeneSpielZeit
Variable restSpielZeit

Bevor das Programm startet, setzen wir den Wert der Variable restLernZeit auf die Lernzeit in Millisekunden und den Wert der Variable restSpielZeit auf die Spielzeit in Millisekunden.

Variable restLernZeit = Variable lernZeitMS
Variable restSpielZeit = Variable spielZeitMS

Wird der Taster A gedrückt, erhält die Variable start den Wert 1 und die Lernzeit läuft ab.
Dafür nutzen wir den Calliope Mini  Zeitgeber. Mit Start des Calliope Mini zählt dieser kontinuierlich in ms hoch. 

Wir müssen uns die bereits vergangene lernZeit merken. Sobald der Taster A gedrückt wird, subtrahieren wir von dem Wert der Variable lernZeitMS den Wert der Variable restLernZeit und erhalten so die bereits vergangene Lernzeit. Diesen Wert übergeben wir der Variable vergangeneLernZeit.

Der Calliope Mini hat eine eigene Uhr, den Zeitgeber. Mit dem Einschalten des Calliope Mini startet dieser und zählt im Hintergrund die vergangene Zeit bis der Calliope Mini ausgeschalten oder der Zeitgeber zurückgesetzt wird.

Wir setzen den Calliope Mini Zeitgeber auf 0 zurück, sobald der Taster A gedrückt wird. 

Während die LernZeit abläuft, aktualisieren wir kontinuierlich den Wert der Variable restLernZeit. Wir addieren zum Wert der Variable vergangeneLernZeit den aktuellen Wert des Calliope Mini Zeitgebers. Die Summe dessen subtrahieren wir vom Wert der Variable lernZeitMS.

Für das Testen tragen wir für die Variablen lernZeit und spielZeit überschaubare Werte ein.

Unten im Rumpf der Endlosschleife lassen wir uns den aktuellen Wert der Variable restLernZeit in gerundeten Minuten für diesen Test ausgeben.

Der Simulator zeigt uns die restliche Lernzeit an. 
Da der Knopf A noch nicht gedrückt wurde, läuft das Programm noch nicht und der Wert der Variablen restLernZeit und restSpielZeit bleiben unverändert.

Wird der Taster A gedrückt, reagiert der Calliope darauf, startet das Programm und setzt die LED auf grün. Die verbleibende Lernzeit verringert sich kontinuierlich.

Wird der Taster B gedrückt, schaltet die LED auf rot und die verbleibende Lernzeit verringert sich nicht weiter. Hier soll sich später die verbleibende Spielzeit verringern.

Wird der Taster A erneut gedrückt, so verringert sich die Lernzeit weiter und die Spielzeit bleibt stehen.

Die Spielzeit berechnen wir jetzt ebenso.

 

Wird der Taster B gedrückt subtrahieren wir den Wert der Variable restSpielZeit vom Wert der Variable spielZeitMS und schreiben das Ergebnis als Wert in die Variable VergangeneSpielzeit. Bei Programmstart muss der Wert 0 sein.

So lange der Schalter A nicht gedrückt, wird verringert sich die Spielzeit und nicht die Lernzeit.

Auch das testen wir, indem wir uns die restliche Spielzeit bei jedem Schleifendurchlauf ausgeben lassen.

Damit unsere Anzeige für die verbleibende Spielzeit etwas netter aussieht erstellen wir eine Funktion für die Ausgabe. Die verbleibende Spielzeit, die in der Variable restSpielZeit abgelegt wurde, wird der Funktion anzeige in gerundeten min übergeben und innerhalb der Funktion anzeige in der Variable a abgelegt.

Je mehr Spielzeit abgelaufen ist, umso weniger LEDs leuchten auf dem Display.

Für jeden Wert, den die Variable a annimmt, erstellen wir ein Bild. (25 - 0)

Unsere Testausgabe löschen wir natürlich.

Bei jedem Tastendruck, A oder B, soll die verbleibende Lernzeit gerundet in min angezeigt werden. Diese Anzeige lassen wir 2 sec lang stehen.

Jetzt müssen wir noch festlegen was passiert, wenn die Spielzeit verbraucht und/oder die Lernzeit abgelaufen sind.

Unten im Rumpf der Endlosschleife formulieren wir die Bedingungen dafür. 
Solange das Programm läuft, also der Wert der Variable start größer/gleich 1 ist, fragen wir nach den Werten der Variablen restLernZeit und restSpielZeit. 

Die Funktion anzeige wollen wir jetzt aufrufen, wenn keine der Bedingungen erfüllt ist. 
Wir verschieben sie also aus dem Rumpf der Endlosschleife in unsere Wenn-Dann-Sonst Anweisung. Sie soll ausgeführt werden, wenn keine der Bedingungen zutrifft.

Ist der Wert der Variable start größer oder gleich 1 ist und die Lernzeit abgelaufen aber noch Spielzeit vorhanden, wird die LED auf blau gesetzt und in die Variable start der Wert 2 geschrieben. Somit kann sich ab jetzt nur noch die Spielzeit verringern und die LED wird auf blau gesetzt.

Ist der Wert der Variable start größer oder gleich 1, noch Lernzeit vorhanden aber die Spielzeit bereits abgelaufen, wird die LED auf gelb gesetzt und in die Variable start der Wert 1 geschrieben. Zusätzlich lassen wir uns die restliche Lernzeit auf dem Display anzeigen.

Zuletzt legen wir noch fest, was passieren soll, wenn Lern- und Spielzeit abgelaufen sind.
Der Wert der Variable start wird auf 0 gesetzt, damit kann auch die Funktion anzeige nicht mehr ausgeführt werden, das Display wird gelöscht und ein Herzsymbol angezeigt und die Variablen lernZeit und spielZeit setzen wir zurück auf 0.

Die Farbe der LED bleibt stehen, entweder ist sie blau oder gelb.

Diese .xml Datei für das Demo könnt ihr im lab.open-roberta.org verwenden und anpassen.

Informatik entdecken und begreifen - probier dich aus!