5 Dein rechter, rechter Platz ist leer

In diesem Kapitel geht es um Platzhalter, die man auch Variablen nennt.

Die Einführung zu diesem Kapitel wurde von Natalia Prost geschrieben. Das Projekt »Der Klickzähler« wurde von Natalia Prost erstellt, ebenso wie »Die digitale Sanduhr«. Das Calliope-Projekt »Das Metronom« stammt von Patrick Franken.

5.1 Variable »Platzhalter«

Eine der Befehlsgruppen im PXT-Editor heißt »Platzhalter«. Im nächsten Projekt, dem Klickzähler, lernst du, wie du einen neuen Platzhalter erstellen kannst. Hier erfährst du aber erst einmal, was ein Platzhalter überhaupt ist.

Platzhalter = Variable

Der PXT-Editor benutzt das Wort »Platzhalter« und meint damit etwas, was die meisten Programmierer als »Variable« bezeichnen. Wenn etwas variabel ist, dann verändert es sich ständig (von alleine) oder kann zum Beispiel durch jemanden oder etwas verändert werden. Lass dich also nicht verwirren, wenn du schon einmal programmiert hast und weißt, was eine Variable ist. In der Informatik gibt es verschiedene Arten von Daten, die mit einer Variablen dargestellt werden können. Sie heißen »Datentypen«. Die wichtigsten Datentypen sind Zahlen und Texte verschiedener Längen.

Am einfachsten ist es, wenn du dir Platzhalter wie eine abschließbare Box vorstellst. Jeder Schlüssel öffnet nur genau eine Box, und auf dem Schlüssel steht der Name dieser einen Box. In der Box kann eine Zahl drin sein oder ein Wort oder auch ein ganzer Satz. Es können aber auch viele andere kleine Boxen drin sein.

Der Inhalt einer Box kann geändert werden, das heißt, Platzhalter können auch verändert werden: Sie sind variabel. Es gibt verschiedene Befehle, mit denen Platzhalter verändert werden können. Wir werden in diesem Kapitel nur mit Nummer-Platzhaltern arbeiten, also stell dir vor, dass in diese Boxen nur Zahlen hineinpassen.

Nun überlege dir, wie du Zahlen überhaupt verändern kannst. Wie kannst du mit einer oder mehreren Zahlen rechnen? Richtig: Du kannst zum Beispiel zwei Zahlen zusammenrechnen (+), voneinander abziehen (-), sie miteinander multiplizieren (∙ oder x) und teilen (: oder ÷) – und natürlich noch vieles andere mehr.

Computerprogramme arbeiten oft so, dass Zahlen nach einer bestimmten Zeit oder nach einem bestimmten Befehl um 1 größer oder um 1 kleiner werden. Dafür braucht das Programm also keine zweite Zahl, sondern es reicht ein einziger Platzhalter, der so verändert wird, dass zum Beispiel +1 dazugerechnet wird. Der Zahlenwert des Platzhalters, also der Inhalt der Box, wird dadurch um 1 größer.

Vielleicht kannst du dir schon vorstellen, dass du mit Hilfe von Platzhaltern viele verschiedene Dinge zählen kannst.

5.2 Der Klickzähler

Viele Kinder spielen auf dem Schulhof gerne mit Springseilen, Basketbällen oder Tischtennisschlägern. Es ist spannend herauszufinden, wer die meisten Seilsprünge in einer Minute schafft oder am häufigsten den Ball auf dem Schläger springen lassen kann. Hast du schon einmal versucht, dabei ganz schnell mitzuzählen? Manchmal ist es schwierig, weil die Bewegung so schnell ist, dass du die Zahl gar nicht (im Kopf) zu Ende sprechen kannst. Bestimmt hast du dich dabei auch schon einmal verzählt.

In diesem Projekt lernst du, wie du mit dem Calliope mini ein Programm schreiben kannst, das jeden Klick – oder, besser gesagt, jeden Knopfdruck – auf eine der beiden Tasten ganz schnell zählen kann. Damit wirst du dich nicht mehr verzählen, weil du bei jedem Sprung nur ganz schnell klicken musst – und der Calliope mini zählt für dich.

Abb. 5–1 Der Klickzähler zählt jeden Knopfdruck von dir.

Öffne den Editor und beginn ein neues Projekt, das du »Klickzähler« nennen kannst.

5.2.1 Platzhalter erstellen

Als Erstes musst du einen neuen Platzhalter für dein Projekt erstellen, damit darin gespeichert werden kann, wie viele Sprünge du oder deine Freunde geschafft haben. Wähle die Befehlsgruppe »Platzhalter« und klicke dort auf »Neuen Platzhalter anlegen«.

Abb. 5–2 Blöcke in der Befehlsgruppe »Platzhalter«

Es erscheint ein neues Fenster, in dem du dem neuen Platzhalter einen eigenen Namen geben kannst. Du kannst deinen Platzhalter nennen, wie du möchtest, aber überlege dir am besten einen guten, passenden Namen, damit du nicht vergisst, wofür du diesen Platzhalter benutzen willst. Wenn du Seilsprünge zählen möchtest, dann nenne deinen Platzhalter »sprünge«.

Schreibweise

Du kannst den Namen auch mit einem großen Anfangsbuchstaben schreiben, wenn du möch-test. Es ist aber nicht wichtig, damit das Programm funktioniert.

Abb. 5–3 Der neue Platzhalter heißt »sprünge«.

Klicke mit der Maus auf den grünen »OK«-Knopf. Dadurch wird dein Platzhalter gespeichert. Das kannst du daran erkennen, dass ein neuer Block mit dem Namen deines Platzhalters erschienen ist.

Abb. 5–4 Es gibt einen neuen »Platzhalter«-Block mit dem Namen »sprünge«.

Nun hast du einen neuen Platzhalter, und der Calliope mini weiß, dass dieser Platzhalter »sprünge« heißt. Im nächsten Schritt wirst du den Platzhalter, das heißt seinen Zahlenwert, auf der LED-Matrix anzeigen.

5.2.2 Platzhalter anzeigen

Zu Beginn dieses Buchs hast du gelernt, wie du deinen Namen mit dem Calliope mini anzeigen kannst. Dein Name ist ein Text, auch »Zeichenkette« genannt. Ein Platzhalter in dem PXT-Editor ist aber kein Text mit Buchstaben, sondern eine Zahl.

Probier zunächst aber aus, was passiert, wenn du den Programmierbefehl »zeige Zeichenfolge« aus der Befehlsgruppe »Grundlagen« benutzt und dort den Platzhalter »sprünge« hineinziehst. Du hast bestimmt gesehen, dass der »sprünge«-Block eine Ausbuchtung an der linken Seite hat. Er passt damit an jede Stelle, wo eine Zahl oder ein Text in einem Befehl eingetragen werden soll.

Abb. 5–5 Benutze den Platzhalter »sprünge« als Zeichenfolge.

Siehst du eine Anzeige im Simulator auf der linken Seite? Nein. Aber warum zeigt der Simulator dir nichts an? Das liegt daran, dass in der »Platzhalter«-Box noch nichts drin ist – und schon gar keine Zeichenfolge aus Buchstaben. Der Platzhalter »sprünge« soll die Anzahl von Sprüngen zählen, er muss also eine Zahl sein, kein Text. Wie groß ist die Zahl ganz am Anfang, wenn du das Programm startest und noch keine Sprünge gezählt hast? Richtig: 0. Das Programm weiß das aber noch nicht, und du musst ihm das beim Start mit einem bestimmten Befehl einprogrammieren.

Wähle dazu in der Befehlsgruppe »Grundlagen« den Befehl »beim Start« aus. Du findest ihn dort ganz unten und musst dafür vielleicht etwas nach unten scrollen.

Abb. 5–6 »beim Start«-Befehl auswählen

In dieser »beim Start«-Klammer fügst du nun einen Programmierbefehl ein, der dem Platzhalter »sprünge« den Wert 0 zuweist, also die Zahl 0 in die Box mit dem Namen »sprünge« legt. Wähle dafür in der Befehlsgruppe »Platzhalter« den Befehle »ändere Platzhalter auf 0«.

Hinweis

Bei der Auswahl des Befehls musst du genau hinschauen. Der Befehl »ändere Platzhalter auf« setzt den Platzhalter immer auf den gleichen dort eingetragenen Zahlenwert, während »ändere Platzhalter um« den Zahlenwert des Platzhalters um die dort eingetragene Zahl erhöht. Der Zahlenwert des Platzhalters kann ebenso verringert werden, wenn du ein Minus (-) vor der Zahl eingibst.

Abb. 5–7 Platzhalter können verändert werden.

Du kannst in dem »ändere«-Befehl mit einem Klick auf das kleine Dreieck neben dem Wort »Platzhalter« deinen eigenen Platzhalter »sprünge« auswählen.

Abb. 5–8 Wähle deinen eigenen Platzhalter »sprünge« aus.

Nachdem du »sprünge« auf 0 geändert hast, siehst du ein blaues Dreieck auf der linken Seite des Programmierbefehls. Das ist eine Fehlermeldung. Der Editor zeigt dir dadurch, dass er deinen Befehl nicht versteht: »sprünge« soll eine Zahl sein, aber in der Dauerschleife hast du noch den Programmierbefehl »zeige Zeichenfolge« ausgewählt. Der Platzhalter »sprünge« ist nun aber vom Typ Zahl und passt dadurch nicht mehr in einen Befehl für Buchstaben.

Abb. 5–9 Fehlermeldung, weil die Zahl 0 nicht vom Typ Zeichenfolge ist.

Du brauchst also einen Befehl, der dir statt einer Zeichenfolge eine Zahl (Nummer) anzeigen kann. Du findest ihn ganz oben in der Befehlsgruppe »Grundlagen«.

Abb. 5–10 »zeige Nummer«-Befehl auswählen

Wähle den Befehl aus und zieh ihn in die Dauerschleife. Als Nächstes ziehst du die »sprünge« aus dem »Zeichenfolge«-Befehl heraus und legst ihn auf die 0 im »Nummer«-Befehl. Du wirst sehen, dass die Fehlermeldung nun verschwunden ist. Jetzt passt der Zahleninhalt des Platzhalters »sprünge« zum anzeigenden »Nummer«-Befehl. Lösche den »Zeichenfolge«-Befehl, indem du ihn aus der Dauerschleife herausziehst.

Abb. 5–11 »zeige Nummer«-Befehl einsetzen und »sprünge« anzeigen.

Wenn du bis hierhin alles richtig gemacht hast, dann siehst du im Simulator auf der linken Seite eine 0. Das ist der Wert deines Platzhalters, wenn du das Programm startest und noch nichts gezählt hast. Als Nächstes wirst du deinen Platzhalter verändern.

5.2.3 Platzhalter mit Knopfdruck verändern

Du willst, dass dein Calliope mini bei jedem Tastendruck oder Klick mitzählt. Anders gesagt: Wenn du den Knopf »A« drückst, soll dein Platzhalter um 1 erhöht werden. Dafür gibt es in der Befehlsgruppe »Eingabe« den Programmierbefehl »wenn Knopf »A« gedrückt«.

Abb. 5–12 »wenn Knopf »A« gedrückt«-Befehl auswählen

Schau genau hin: Dieser Befehl hat keine Delle am oberen Außenrand. Das bedeutet, dass er nicht in die Dauerschleife eingefügt werden kann, sondern selbst eine eigene neue Klammer darstellt.

Nun brauchst du noch einen Befehl aus der Befehlsgruppe »Platzhalter«. Wähle dort den »ändere Platzhalter um 1«-Befehl aus und ziehe ihn in deine neue »wenn«-Klammer hinein. Durch einen Klick auf das kleine Dreieck neben dem Wort »Platzhalter« wählst du wieder deinen eigenen Platzhalter »sprünge« aus.

Abb. 5–13 Erhöhe die »sprünge« um 1 nach jedem Druck auf Knopf »A«.

Nun kannst du deinen Code im Simulator auf der linken Seite ausprobieren. Klicke dazu mit der Maus auf den Knopf »A«. Du siehst, wie sich die Zahl auf der Anzeige mit jedem Klick verändert und die neue Zahl angezeigt wird. Das klappt bei den ersten Zahlen 0–9 sehr schnell. Wenn die Zahl größer als 9 ist, reicht der Platz auf der LED-Matrix nicht mehr aus, und die Anzeige wird automatisch zu einer Laufanzeige umgewandelt, wie du es schon von der Anzeige von Texten kennst.

Jetzt ist alles fertig. Oder? Fällt dir ein Problem auf? Ach so, wenn du 21-mal auf den Knopf »A« gedrückt hast, sieht der angezeigte Text so aus: 212121212121 … Je nachdem, wann du auf die LED-Matrix schaust, wirst du entweder 21 oder 12 lesen (oder 212 oder sogar 2121). Deswegen solltest du die Anzeige noch etwas verbessern.

5.2.4 Anzeige beim Zählen verbessern

Um zu sehen, wo die echte Anzahl der »sprünge« anfängt und aufhört, brauchst du irgendeine Form von Abstand oder Trennung zwischen jeder Anzeige. Es gibt verschiedene Möglichkeiten, wie du die einzelnen Zahlenanzeigen voneinander trennen kannst, zum Beispiel diese Blöcke aus der Befehlsgruppe »Grundlagen«:

Bei allen drei Möglichkeiten soll der Calliope mini nach jeder Anzeige der Anzahl kurz etwas anderes zeigen, bevor er dann wieder die Anzahl zeigt. Du brauchst also einen weiteren Befehl in der Dauerschleife. Wähle den großen Programmierbefehl »zeige LEDs« und ziehe ihn in die Klammer der Dauerschleife. Male nun ein kleines Muster, zum Beispiel einen langen Bindestrich »–«, indem du einzelne LEDs durch einen Klick rot markierst.

Abb. 5–14 Erstelle eine abwechselnde Anzeige mit einem trennenden Muster.

Probier aus, ob dir die Anzeige im Simulator gefällt. Wenn du noch nicht zufrieden bist, kannst du das Muster ändern oder eine andere der oben genannten Möglichkeiten ausprobieren, um deine Anzeigen voneinander zu trennen.

Hinweis

Möchtest du schneller sehen, ob dir die Anzeige bei größeren Zahlen gefällt, ohne dass du vorher immer so oft auf den Knopf drücken musst? Du kannst zum Testen den Startwert (»beim Start«) von »sprünge« schon auf 21 oder eine andere Zahl einstellen. Vergiss nicht, diesen Wert wieder auf 0 zu ändern, bevor du das Programm herunterlädst.

5.2.5 Von vorne zählen

Wenn ihr euch beim Spielen abwechselt, dann wollt ihr auch nacheinander eure Sprünge oder Punkte zählen. Der Calliope mini soll dann nicht bei der ersten Anzahl weiterzählen, sondern von vorne beginnen mit 0 Sprüngen. Dazu programmierst du es so, dass beim Drücken von Knopf »B« der Platzhalter »sprünge« wieder auf 0 gesetzt wird.

Du brauchst einen neuen »wenn Knopf gedrückt«-Befehl, bei dem du diesmal den Knopf »B« auswählst. Du findest ihn wieder in der Befehlsgruppe »Eingabe«. Über einen Klick auf das kleine Dreieck neben dem »A« kannst du den entscheidenden Knopf auswählen.

Abb. 5–15 Ändere den Knopf auf »B«

Wähle außerdem in der Befehlsgruppe »Platzhalter« einen neuen »ändere Platzhalter auf 0«-Befehl und füge ihn in die neue Klammer ein. Wähle über das kleine Dreieck erneut »sprünge« aus. Dein Programm reagiert nun sowohl auf den Knopf »A« (»ändere sprünge um 1«) als auch auf den Knopf »B« (»ändere sprünge auf 0«).

Abb. 5–16 So sieht das fertige Programm für den Klickzähler aus.

Probier dein Programm im Simulator aus. Wenn alles so funktioniert, wie du es möchtest, dann lade das Programm auf deinen Calliope mini herunter. Teste dein Programm und drücke auf die beiden Knöpfe.

5.2.6 Noch mehr zählen

Nun hast du einen einfachen Klickzähler programmiert und der Calliope mini reagiert auf jeden Knopfdruck von dir. Überleg dir, wie du dein Programm verändern musst, wenn du die Punkte für zwei Teams, also Team A und Team B, zählen möchtest? Wie viele Platzhalter braucht ihr? Wie erhöht ihr die Platzhalter? Und wie funktionieren die Anzeige und der Neustart?

Du kannst das Programm auch dafür verwenden, um eine Zahl mit jedem Klick kleiner zu machen, bis der Zahlenwert 0 erreicht ist. Welchen Wert muss dein Platzhalter dafür beim Start haben? Am Ende kannst du außerdem einen Ton abspielen. Wenn ihr im Sportunterricht zum Beispiel 50 Hampelmänner machen sollt, wisst ihr dadurch immer, wie viele noch übrig sind, und hört am Schluss eine Melodie zur Belohnung.

Bestimmt fallen dir auch noch viel mehr Dinge ein, die du zählen kannst.

5.3 Die digitale Sanduhr

Du möchtest ein Spiel spielen, bei dem eine Runde eine ganz bestimmte Zeit hat? Oder willst du eine bestimmte Zeit lang auf einem Bein balancieren? Dann brauchst du eine Uhr, die die Zeit wie bei einem Countdown herunter zählt und am besten auch noch anzeigt, wie viel Zeit noch übrig ist. Genau das macht eine Sanduhr, und du wirst in diesem Projekt eine eigene digitale Sanduhr programmieren.

In diesem Kapitel lernst du, wie du ein Programm für den Calliope mini schreiben kannst, bei dem die einzelnen LEDs wie (ziemlich große) Sandkörner nacheinander verschwinden.

Abb. 5–17 Die digitale Sanduhr läuft ab.

5.3.1 Platzhalter erstellen

Das Programm deiner digitalen Sanduhr läuft eine bestimmte Zeit. Dabei möchtest du, dass diese ganze Zeit so aufgeteilt wird, dass die 25 LEDs nacheinander ausgeschaltet werden. Du musst dem Programm dafür sagen, in welcher Reihe und in welcher Spalte du den Punkt ausschalten willst. Du kennst schon Spalten und Reihen in Tabellen, so ähnlich funktioniert das hierbei auch, wie du später noch genau sehen wirst. Für dieses Programm brauchst du insgesamt vier Platzhalter:

Abb. 5–18 Diese vier Platzhalter brauchst du für die Sanduhr.

Öffne die Befehlsgruppe »Platzhalter« und klicke dort mit der Maus auf »Neuen Platzhalter anlegen«. Benenne den neuen Platzhalter mit »Startzeit« und wiederhole diesen Schritt für die anderen Platzhalter, bis du alle vier Platzhalter hast.

5.3.2 Sanduhr startbereit machen

Schon bevor das Programm startet, muss es wissen, wie lange es insgesamt laufen soll. Bei einer echten Sanduhr hängt die Dauer vor allem von der Menge der Sandkörner ab. Bei deinem Calliope mini kannst du aber nichts an der Anzahl der LEDs ändern, also musst du es etwas anders machen. Du erreichst es dadurch, dass du den Wert der »Startzeit« ganz am Anfang auf die Zeit setzt, die das Programm dauern soll. Dafür brauchst du die Programmierbefehle »beim Start« und »ändere Platzhalter auf« aus der Befehlsgruppe »Platzhalter«. Ändere den Platzhalter durch das kleine Dreieck auf »Startzeit«. Die Zahl dort musst du in Millisekunden (ms) angeben. Zur Erinnerung: 1 Sekunde hat 1000 Millisekunden. Wenn du also möchtest, dass deine Sanduhr 25 Sekunden dauert, musst du den Befehl »ändere Startzeit auf 25000« (25 × 1000) verwenden. Dann solltest du auch berechnen, wie viel Zeit vergeht, bis die nächste LED ausgeschaltet wird. Dafür brauchst du den »ändere auf«-Befehl und einen »0 ÷ 0«-Block aus der Gruppe »Mathematik«. Ersetze die erste 0 durch einen »Startzeit«-Block und die zweite 0 durch 25.

Und was glaubst du, sollte zu sehen sein, wenn du die Calliope-Sanduhr anmachst? Nun, da am Anfang alle Sandkörner noch drin sind, solltest du auch alle LEDs rot anzeigen. Dafür brauchst du den »zeige LED«-Befehl aus der Befehlsgruppe »Grundlagen«. Ziehe ihn in deine »beim Start«-Klammer und klicke alle LEDs an, damit sie alle rot leuchten.

Abb. 5–19 Die digitale Sanduhr ist startklar.

5.3.3 Eine einzelne LED ausschalten

Für deine digitale Sanduhr musst du Befehle benutzen, mit denen es möglich ist, jede der 25 roten LEDs einzeln zu steuern, das heißt ein- und auszuschalten. Dafür gibt es die Befehlsgruppe »LED«. Wenn alle 25 LEDs beim Start rot leuchten, brauchst du einen Befehl, der die LEDs nacheinander wieder ausschaltet. Der PXT-Editor bezeichnet die LEDs als Pixel, und der Befehl »schalte Pixel x 0 y 0« meint: Schalte die LED an der Stelle x 0 und y 0 ab.

Abb. 5–20 Befehl zum (Ab)schalten einzelner Pixel

Bei den Zahlen hinter x und y handelt es sich um die Angabe der Position der LED. Die Zahl hinter dem x steht für die Spalte, die Zahl hinter dem y steht für die Zeile oder Reihe, in der sich die LED, also das Pixel befindet. Wenn da »x 0« und »y 0« steht, dann ist damit die LED in der oberen linken Ecke gemeint, also die allererste LED, wenn du die LEDs von oben nach unten und von links nach rechts »lesen« würdest. In der Informatik beginnen aber viele Aufzählungen und Listen mit der Zahl 0, also ist mit »x 0« die erste Spalte gemeint und mit »y 4« die unterste, fünfte Reihe. Die LED an der Stelle »x 1 y 2« zeigt dir die folgende Abbildung, damit du es noch einmal besser verstehst.

Abb. 5–21 Positionsangaben für die LEDs

Um diesen »schalte Pixel«-Befehl zu aktivieren, musst du ihn in eine passende Klammer einfügen, damit der Befehl ausgeführt wird, wenn du auf die Taste A drückst. Du findest diesen »wenn Knopf »A« gedrückt«-Befehl wie immer in der Befehlsgruppe »Eingabe«. Wähle ihn aus und verbinde die beiden Befehle miteinander. Du kannst nun eine Zahl von 0 bis 4 hinter x und y selbst eintragen und im Simulator ausprobieren, an welcher Stelle diese LED ist, wenn du Knopf »A« klickst.

Nun erinnere dich an die Platzhalter, die du am Anfang dieses Projekts erstellt hast. Einer der Platzhalter heißt »spalte« und ein anderer heißt »reihe«. Anstatt die Zahlen für x und y selbst einzutragen, kannst du auch die »Platzhalter«-Blöcke benutzen. Was glaubst du, welche LED ausgeschaltet wird, wenn du nun im Simulator Knopf »A« klickst? Warum ist es genau diese LED?

Abb. 5–22 Schalte diejenige LED ab, die in dieser Spalte und dieser Reihe ist.

Da du diese beiden Platzhalter noch nicht verändert hast, haben sie den Wert 0, weshalb die allererste LED oben links (Position bei »x 0 y 0«) ausgeschaltet wird.

Du kannst nun die Position der einzelnen LED nur noch verändern, indem du den Wert der Spalte und der Reihe änderst. In diese beiden Platzhalterboxen können immer wieder verschiedene Zahlen eingetragen werden.

Hinweis

Probiere aus, was passiert, wenn du einen »ändere Platzhalter um 1«-Befehl vor den »schalte Pixel«-Befehl ziehst. Vergiss dabei nicht, durch Klick auf das kleine Dreieck die richtige Variable (»reihe« oder »spalte«) auszuwählen. Drücke im Simulator mehrmals auf Knopf »A«.

5.3.4 Ganze Reihe mit Knopfdruck ausschalten

Nun möchtest du, dass die Sandkörner-LEDs nacheinander ausgeschaltet werden – und zwar automatisch nacheinander, sobald du nur ein einziges Mal auf Knopf »A« drückst. Dafür musst du etwas programmieren, bei dem du zuerst mit einer Reihe anfängst, dort nacheinander alle LEDs spaltenweise durchgehst, und dann zur nächsten Reihe gehst und so weiter – so, als würdest du einen Text Wort für Wort lesen. Du wirst gleich sehen, dass du bei solch einer Wiederholung nicht viel rechnen musst, wenn du es einmal verstanden hast. Natürlich kannst du die Reihenfolge ändern, in der die einzelnen LEDs verschwinden, aber dazu erst später mehr.

Es gibt verschiedene Möglichkeiten, wie du diese Wiederholung programmieren kannst. Computerprogramme verwenden dafür sogenannte »Schleifen«. Im PXT-Editor findest du eine Befehlsgruppe, die auch »Schleifen« heißt.

Abb. 5–23 Befehlsgruppe »Schleifen«

Die einfachste Möglichkeit, einen oder mehrere Befehle mehrmals nacheinander zu wiederholen, ist der oberste Programmierbefehl »4-mal wiederholen, mache«. Zieh diesen Befehl in die »wenn Knopf »A« gedrückt«-Klammer und ändere die Zahl auf 5, weil es 5 LEDs in jeder Reihe gibt. Verschiebe den »schalte Pixel«-Befehl aus dem letzten Schritt in die neue grüne Klammer und füge einen »ändere spalte um 1«-Befehl hinzu, wenn du dies im letzten Schritt noch nicht ausprobiert hast.

Abb. 5–24 Wiederholung der Befehle für eine ganze Reihe

Was genau bedeutet diese Wiederholung nun? Stell dir vor, du könntest auf einem sehr großen Calliope »maxi« mit deinem Finger jede LED durch Antippen einfach ausschalten. Du beginnst in der 1. Spalte und in der 1. Reihe und tippst die 1. LED an. Sie geht aus. Dann gehst du mit deinem Finger zur nächsten 2. Spalte, also einmal nach rechts. Diese LED tippst du wieder an. Die Reihe wird dabei nicht verändert, du bleibst nur in der 1. Reihe. Du machst weiter: 3. Spalte – antippen – 4. Spalte – antippen – 5. Spalte – antippen – 6. Spalte. Hm, da ist zwar keine LED mehr, aber das macht auch nichts, denn du musst gar nichts mehr antippen, weil die Wiederholungsklammer zu Ende ist.

Probier das Programm nun im Simulator aus. Was passiert? Wenn du alles richtig gemacht hast, dann müsste – nachdem du Knopf »A« gedrückt hast – die oberste Reihe der LEDs ausgeschaltet, also weiß sein. Doch wie lange – oder besser gesagt kurz – hat das gedauert? Das ging schon fast zu schnell, um es überhaupt richtig sehen zu können, oder? Aber du willst ja eigentlich ein Programm, das die LEDs deutlich sichtbar nacheinander ausschaltet. Dafür musst du eine kleine Pause einbauen. Du findest den »pausiere«-Befehl in der Befehlsgruppe »Grundlagen«, und du solltest ihn gleich oben in deiner »Wiederhole«-Klammer einfügen. In diesen Befehl musst du wieder eine Zahl eintragen, die anzeigt, wie viele Millisekunden (ms) die Pause dauern soll. Jetzt brauchst du den »durch25«-Platzhalter. Füge ihn aus der Befehlsgruppe »Platzhalter« als Dauer für den »pausiere«-Befehl ein.

Abb. 5–25 Füge eine Pause hinzu.

Wenn du diesen Code mit der Pause nun im Simulator ausprobierst, siehst du, dass es nun viel länger dauert, bis die letzte LED in der obersten Reihe ausgeschaltet wird. Wie kannst du nun einstellen, dass die LEDs schneller oder langsamer nacheinander ausgeschaltet werden? Du kannst die Dauer der Pause ändern, wenn du den Wert des »Startzeit«-Platzhalters in der »beim Start«-Klammer veränderst. Je größer die Startzeit, desto größer ist auch das Ergebnis von Startzeit geteilt durch 25.

5.3.5 Jede Reihe nacheinander ausschalten

Für eine richtige digitale Sanduhr reicht es aber noch nicht, wenn nur die oberste Reihe ausgeschaltet wird. Du möchtest danach in der 2. Reihe weitermachen und wieder von links alle LEDs ausschalten, dann mit der 3. Reihe und so weiter. Du willst die Befehle aus dem letzten Schritt für jede Reihe wiederholen. Kannst du dir schon vorstellen, was du dafür brauchst? Richtig: eine neue »Wiederholen«-Klammer.

Diese neue Klammer musst du so einfügen, dass die alte Klammer von der neuen Klammer eingeschlossen wird. Dafür musst du die Blöcke im Editor etwas herumschieben, aber dann sollte es so aussehen wie auf dem nächsten Bild. Du hast nun eine äußere Klammer (die neue) und eine innere Klammer (die alte).

Hinweis

Programmierer nennen solche Codes mit mehreren Schleifen-Klammern ineinander auch »verschachtelte Schleifen«. Die Befehle, die in der inneren Klammer stehen, werden so oft ausgeführt, wie die Anzahl der Wiederholungen miteinander multipliziert wird. In diesem Projekt werden die drei Befehle (»pausiere«, »schalte«, »ändere spalte«) 5 x 5 Mal, also 25 Mal ausgeführt. Sehr gut, immerhin sind es ja auch 25 LEDs.

Abb. 5–26 Innere und äußere »Wiederholen«-Klammern

Ist dir der »ändere reihe um 1«-Befehl unten in der Klammer aufgefallen? Stell dir wieder einen großen Calliope maxi vor: Du brauchst diesen Programmierbefehl, damit du mit deinem Finger auf die nächste Reihe zeigen kannst. Und zwar darfst du erst dann in die nächste Reihe gehen, wenn du vorher fünfmal eine LED angetippt und eine Spalte weiter nach rechts gegangen bist. Dann wurde die innere Schleife 5-mal ausgeführt und das Programm macht mit den Befehlen der äußeren Schleife weiter.

Hinweis

Achte beim Einfügen dieses Befehls darauf, dass du ihn genau zwischen dem Ende der inneren Klammer und vor dem Ende der äußeren Klammer einfügst.

Doch was passiert, wenn du das Programm im Simulator mit Knopf »A« startest? Werden mehr LEDs ausgeschaltet als die in der ersten Reihe? Hm, wahrscheinlich nicht. Woran liegt das? Wenn du mit deinem Finger am Ende der 1. Reihe angekommen bist, darfst du mit deinem Finger in die 2. Reihe gehen. Und in welche Spalte? Richtig: in die 6. Dann in die 7. und in die 8. Spalte und so weiter. Doch auf der LED-Matrix gibt es nur 5 Spalten, also was solltest du eigentlich machen? Du solltest mit deinem Finger in der 2. Reihe wieder die 1. LED ganz links antippen. Das heißt, dass du zurück zur 1. Spalte musst. Welchen Befehl brauchst du dafür und an welcher Stelle musst du den Befehl einfügen? Die Auflösung findest du, wenn du dir das nächste Bild genauer anschaust, doch überlege zuerst selbst, wie du es zurück zur 1. Spalte schaffen könntest.

Hinweis

Vergiss nicht, dass Computerprogramme oft bei 0 anfangen zu zählen!

Abb. 5–27 Zurückspringen zur ersten Spalte

Hinweis

Dein Programm funktioniert auch, wenn du den »spalte«-Platzhalter vor dem Beginn der inneren »Wiederholen«-Klammer auf 0 änderst.

5.3.6 Musik abspielen

Wie du schon weißt, kann der Calliope mini auch Musik abspielen. Wenn du möchtest, dass bei deiner Sanduhr nach der abgelaufenen Zeit nicht nur alle LEDs aus sind (keine Sandkörner mehr), sondern auch noch deutlich zu hören ist, dass die Zeit abgelaufen ist, dann kannst du ein paar »Noten«-Blöcke einfügen. Du findest sie in der Befehlsgruppe »Musik« und kannst zum Beispiel die Tonfolge »G E C« abspielen, nachdem die äußere »Wiederholen«-Klammer beendet ist.

Abb. 5–28 Melodie am Ende des Programms

5.3.7 Sanduhr starten

Deine digitale Sanduhr ist jetzt fertig. Das nächste Bild zeigt dir den gesamten Code deines Programms, wenn du alle Schritte bisher richtig gemacht hast. Beim Starten deiner Sanduhr im Simulator verschwinden die LEDs nun alle nacheinander von links nach rechts und von oben nach unten.

Abb. 5–29 So sieht dein fertiges Programm aus.

Dieses Programm kannst du nun speichern und auf deinen Calliope mini herunterladen und dort benutzen. Wenn du möchtest, kannst du deine Sanduhr im nächsten Schritt noch etwas verändern. Lies weiter, wenn du dich schon gefragt hast, ob und wie es möglich ist, die Reihenfolge zu ändern, in der die einzelnen LEDs ausgeschaltet werden.

5.3.8 Reihenfolge verändern

Die Reihenfolge hängt davon ab, ob du in der inneren »Wiederholen«-Klammer die »reihe« oder »spalte« erhöhst und was du in der äußeren Klammer erhöhst und auf 0 änderst. Probier es aus und wähle in allen drei »ändere«-Blöcken das Gegenteil von dem aus, was gerade verändert wird. Also klicke auf das kleine Dreieck neben »spalte« und wähle »reihe« aus und umgekehrt. Klicke dann auf Knopf »A« im Simulator.

Abb. 5–30 Veränderte Reihenfolge beim Ausschalten der LEDs

Zuerst verschwindet nun die ganze linke Spalte, dann die zweite Spalte – und zwar immer von oben nach unten jede LED nacheinander. Du kannst dir natürlich die Reihenfolge für deine eigene Sanduhr selbst aussuchen.

Etwas schwieriger ist es aber, wenn du möchtest, dass die Sandkörner-LEDs rechts unten als erste ausgehen. Wenn du wieder an deinen Finger und das große Calliope maxi denkst, wirst du ja erst in der letzten Spalte und in der letzten Reihe anfangen, um dort die LED ganz rechts unten zuerst anzutippen. Weil du inzwischen weißt, dass Programmierer mit dem Zählen bei 0 anfangen und dass die ganz linke LED-Spalte bei x 0 liegt, weißt du natürlich auch, dass die ganz rechte LED-Spalte bei »x 4« liegt. Das Gleiche gilt für die LED-Reihe und y: Die unterste Reihe liegt bei »y 4«. Da deine Platzhalter »spalte« und »reihe« bei 0 anfangen, kannst du sie von der 4 subtrahieren (-) und erhältst beim ersten Durchlauf der »Wiederholen«-Klammer (4 – 0) als Ergebnis 0. Dafür brauchst du den »0 – 0«-Befehl aus der Befehlsgruppe »Mathematik«, den du so verwendest, wie er auf der nächsten Abbildung dargestellt ist.

Abb. 5–31 So wird als erstes die LED unten rechts abgeschaltet.

Probier es im Simulator aus. Gefällt dir diese Reihenfolge besser? Oder möchtest du wieder erst die untere Reihe komplett ausschalten? Na, zum Glück weißt du auch noch, wie das geht!

Du kannst das Programm nun auf deinen Calliope mini herunterladen und dort starten. Wenn die Sanduhr abgelaufen ist, kannst du mit dem »Reset«-Knopf immer wieder zum Anfang zurück und die Sanduhr mit Knopf »A« neu starten. Aber wenn du möchtest, kannst du deinen Code auch noch so verändern, dass die Sanduhr bei jedem Knopfdruck auf B wieder von vorne beginnt oder zumindest startklar ist, bis sie beim Drücken auf Knopf »A« wieder losgeht. Was musst du dafür noch ergänzen in deinem Code? Denk daran, dass du »reihe« und »spalte« dann auch erst auf 0 setzen musst, wenn du auf den Knopf »B« drückst.

5.4 Das Metronom

Auf den Takt kommt es an! Das ist das Motto heute, denn du baust mit dem Calliope ein Metronom. Das kennst du vielleicht aus dem Musikunterricht. Falls nicht, macht es auch nichts aus, wir erklären es dir kurz. Ein Metronom hilft Musikern, den richtigen Takt zu halten. Dazu gibt es in einem gleichmäßigen Tempo einen Ton von sich. Dieses Tempo wird vom Musiker vorher eingestellt und variiert je nach Musikstück. Du kennst sicherlich viele Lieder mit unterschiedlichem Tempo, manche sind langsam, andere sehr schnell.

Abb. 5–32 Der Calliope mini kommt als Metronom zum Einsatz.

Genau so ein Gerät kannst du mit dem Calliope mini nachbauen. Die Idee ist, dass du über zweimaliges Drücken von Knopf »A« den Takt vorgeben kannst. Dazu wird der Abstand zwischen diesen beiden Klicks gemessen und dann in einem Platzhalter abgespeichert. Folgenden Ablauf soll das Programm haben:

1.Knopf »A« wird gedrückt, du speicherst die aktuelle Laufzeit in einem Platzhalter ab.

2.Knopf »A« wird ein zweites Mal gedrückt. Du ziehst von der aktuellen Laufzeit die vorher im Platzhalter gespeicherte Laufzeit ab und speicherst das Ergebnis in einem neuen Platzhalter.

3.Der Calliope mini soll nun in diesem Tempo einen Ton abspielen.

Was ist Laufzeit?

Das ist ein Begriff, den du in der Informatik noch sehr oft hören wirst. Die Laufzeit ist eine Zahl, die ununterbrochen mit jeder Millisekunde um 1 hochgezählt wird. Wenn du den Calliope mini einschaltest, ist die Laufzeit ganz kurz auf 0 und eine Sekunde später auf 1000, also 1 Sekunde in Millisekunden. Das Tolle an der Laufzeit ist, dass du damit rechnen kannst. Wenn du also den Abstand zwischen zwei Ereignissen messen willst, kannst du dazu die Laufzeit verwenden. Das kannst du auch für dein Metronom verwenden.

Beim PXT-Editor findest du die Laufzeit unter »Eingabe«, »Mehr«.

Abb. 5–33 Laufzeit im PXT-Editor

Los geht es mit dem Programmieren! Du beginnst damit, den Knopf »A« zu programmieren. Er soll beim ersten Drücken die aktuelle Laufzeit abspeichern, dazu verwendest du einen neuen Platzhalter »Start«.

Abb. 5–34 Der Platzhalter »Start« wird eingefügt

Diesen Block kannst du nun schon einmal austesten. Lass dir dazu den Platzhalter »Start« auf den LEDs ausgeben. Dafür kannst du den Block »zeige Nummer« verwenden. Dieser Block soll dauerhaft ausgeführt werden, da du immer den aktuellen Wert des Platzhalters ausgegeben haben möchtest.

Abb. 5–35 Der Platzhalter »Start« soll auf den LEDs dargestellt werden.

Wenn du das Calliope-Board nun startest, sollte auf den LEDs erst einmal die Zahl 0 zu sehen sein. Das liegt daran, dass der Platzhalter »Start« noch nicht gesetzt wurde. Wenn du nun den Knopf »A« drückst, sollte auf den LEDs die aktuelle Laufzeit angezeigt werden, da du sie immer im Platzhalter »Start« abspeicherst. Teste es einmal aus: Bei jedem Druck von Knopf »A« sollte sich die Zahl erhöhen, da die Laufzeit nie rückwärts laufen kann.

Nun soll irgendwie der zweite Druck auf Knopf »A« erkannt werden. Aus dem vorherigen Experiment weißt du, dass der Platzhalter »Start« den Wert 0 hat, wenn der Knopf noch nicht gedrückt wurde. Das kannst du verwenden, um zu erkennen, ob Knopf »A« schon gedrückt wurde oder eben nicht. Verwende dazu eine Verzweigung, die du schon zu Beginn von Kapitel 3 kennengelernt hast. In der Verzweigung prüfst du, ob der Platzhalter »Start« nicht 0 ist. Sobald der Knopf »A« zum ersten Mal gedrückt wird, speicherst du im Platzhalter »Start« die Laufzeit. Das ist reichlich kompliziert, daher solltest du erst einmal testen, ob dies so funktioniert. Versuche beim zweiten Druck auf den Knopf »A«, die LED rot leuchten zu lassen. Dann weißt du, dass das zweite Drücken richtig erkannt wurde.

Abb. 5–36 Eine Verzweigung kommt hinzu

Kopiere das Programm auf den Calliope mini und teste es. Beim ersten Druck auf den Knopf »A« sollte noch nichts Sichtbares passieren, da du nur die Laufzeit in »Start« abspeicherst. Beim zweiten Druck allerdings sollte die LED anfangen, rot zu leuchten.

Nun weißt du, dass die Erkennung des zweiten Knopfdrucks funktioniert, und kannst das Programm weiterentwickeln. Der nächste Schritt besteht darin, den Abstand zwischen dem ersten und zweiten Druck zu erkennen. Dazu kannst du – wie vorher schon erklärt – die aktuelle und die in »Start« abgespeicherte Laufzeit verwenden. Die Minus-Rechnung dieser beiden Werte ergibt dabei den Abstand zwischen ihnen in Millisekunden. Den Abstand solltest du in einem neuen Platzhalter »Abstand« abspeichern, sodass du ihn später verwenden kannst.

Abb. 5–37 Der Abstand wird im Platzhalter »Abstand« gespeichert

Jetzt kannst du prüfen, ob im Platzhalter »Abstand« auch tatsächlich der Abstand zwischen zweimaligem Drücken auf Knopf »A« gespeichert wird. Verwende dazu wieder den Block »zeige Nummer«, nur wird dieses Mal nicht der Wert von »Start«, sondern von »Abstand« angezeigt.

Abb. 5–38 Der Platzhalter »Abstand« soll getestet werden

Kopiere das Programm auf den Calliope mini. Drücke zweimal hintereinander Knopf »A«, und es sollte eine Zahl auf den LEDs angezeigt werden. Diese Zahl ist der Abstand zwischen dem ersten und dem zweiten Druck auf Knopf »A« in Millisekunden. Probiere es ein paar Mal in verschiedenen Geschwindigkeiten aus. Je nach Geschwindigkeit sollte die Zahl entsprechend niedrig oder hoch sein. Um die Zeit zu überprüfen, kannst du dir als Hilfe auch eine Uhr mit Sekundenzeiger nehmen. Drücke Knopf »A«, wenn der Sekundenzeiger auf 0 ist, und drücke ihn ein zweites Mal, wenn er auf 30 Sekunden ist. Auf den LEDs sollte jetzt ungefähr 30000 angezeigt werden, das entspricht den 30 Sekunden, die du gewartet hast.

Nun soll mit Hilfe der in »Abstand« gespeicherten Zeit ein Ton abgespielt werden. Du beginnst am besten mit dem Abspielen eines Tons und lässt das Programm dann eine Sekunde warten. Diese Wartezeit wird später durch die vorher im Platzhalter »Abstand« gespeicherte Zeit ersetzen.

Abb. 5–39 Ein erster Versuch

Sobald das Programm auf dem Calliope mini läuft, sollte mit dem Abstand von einer Sekunde die Note C für einen Takt abgespielt werden.

Das Programm benötigt nun noch ein paar Verbesserungen, bis es das macht, was du mit dem Metronom vorhast. Als Erstes soll es, statt 1 Sekunde zu warten, den von dir vorher ermittelten Abstand warten. Außerdem ist der eine Takt noch zu lang. Ändere dies und gib dem Programm eine zweite Chance.

Abb. 5–40 Der nächste Versuch

Jetzt ist etwas ganz merkwürdig, denn nach dem Einschalten des Calliope mini mit diesem Programm spielt es ohne Unterbrechung sehr schnell hintereinander den Ton ab. Woran liegt das? Beim Start deines Programms ist der Platzhalter »Abstand« noch nicht definiert. Für den »pausiere«-Block bedeutet dies, einfach gar keine Pause einzulegen. So wird der Ton immer wieder abgespielt. Du musst also auch hier noch mit Hilfe einer Verzweigung prüfen, ob »Abstand« schon gesetzt ist. Nur wenn das der Fall ist, soll der Ton abgespielt werden.

Erweitere das Programm so, dass der Ton nur abgespielt wird, wenn »Abstand« nicht 0 ist.

Abb. 5–41 Nun wird der Ton nur abgespielt, wenn »Abstand« gesetzt ist

Durch die Überprüfung, ob »Abstand« gesetzt ist, sollte erst einmal gar kein Ton aus dem Calliope mini kommen. Drücke jetzt zweimal hintereinander Knopf »A«, und das Calliope-Board sollte in diesem Takt den Ton abspielen.

Am besten testest du nun dein Programm mit ein wenig Musik aus. Versuche dazu, den Takt der Musik zu finden und dann Knopf »A« passend zu drücken. Wenn alles gut geht, sollte dein Calliope mini mit dem Takt den Ton abspielen.