8 Mapping – so hinein und anders wieder hinaus

In diesem Kapitel geht es um Mapping. Das ist ein wichtiges Thema, wenn du Projekte mit Sensoren und Aktoren umsetzen willst.

Die Einführung zu diesem Kapitel stammt von Thiemo Leonhardt, ebenso wie die Projekte »Farbverlauf«, »Luftgitarre« und »Fang den Dot«.

8.1 Mapping verstehen

In diesem Kapitel wirst du das Informatik-Prinzip »Mapping« kennenlernen, das es dir ermöglicht, noch mehr tolle Projekte mit den Sensoren und Aktoren des Calliope mini umzusetzen. Auf den folgenden Seiten warten folgende drei Projekte zum Thema »Mapping« auf dich: der Farbverlauf (eigene Lichterketten programmieren), die Luftgitarre mit echten Tönen (eigene Instrumente herstellen) und das Spiel »Fang den Dot« (eigene Spiele verbessern).

8.1.1 Worum geht es hier?

Schön, dass du dich mit Mapping beschäftigen möchtest. Mapping ist ein sehr wichtiges Thema, wenn du Projekte mit Sensoren und Aktoren umsetzen willst. Wie du in den vorangegangenen Kapiteln und Projekten, z. B. beim Farbthermometer in Absschnitt 4.4, schon gesehen hast, kannst du eine Eingabe wie die Temperaturdaten des Temperatursensors durch ein eigenes Programm in eine Ausgabe wie zum Beispiel eine Farbe umleiten.

Abb. 8–1 Eingabe eines Sensorwertes umwandeln in die Ausgabe einer Lampe

Auf diese Weise kannst du zum Beispiel jemanden warnen, wenn eine Herdplatte so heiß wird, dass es für unsere Haut gefährlich wird (ab ca. 45 Grad), indem dann eine Warnlampe angeht. Damit du weißt, wie heiß es ist, kannst du den Block »Temperatur« benutzen.

Abb. 8–2 »Temperatur«-Block

Die Frage ist jetzt aber, wie du die eine Lampe nicht nur bei einem bestimmten Temperaturwert aufleuchten lässt, sondern zum Beispiel die Helligkeit der roten Lampe so steuerst, dass die rote Lampe umso heller leuchtet, je höher die Temperatur ist. Schau dir dazu einmal dieses vereinfachte Beispiel an.

Abb. 8–3 Beispiel des Mappings der Sensorwerte von 0 bis 30 auf Temperaturwerte von 30 bis 40

Der Temperatursensor gibt dir Zahlenwerte von 0 bis 30 als Eingabe in deinen Platzhalter. Der Hersteller der Lampe sagt dir, dass 30 die kleinste Helligkeit und 40 die größte Helligkeit ist, mit der die Lampe leuchten kann.

Dein Temperatursensor gibt dir im Programm eine 15 aus. Die 15 halbiert genau den Abstand zwischen der 0 und der 30. Damit du nun den entsprechenden Temperaturwert herausbekommst, halbierst du den Abstand zwischen 30 und 40 der Temperaturwerte. Den Abstand berechnest du indem du von 40 die 30 abziehst.

Rechentipp

Abstand = großer Wert minus kleiner Wert

Damit du die passende Helligkeit herausbekommst, musst du den Abstand der Helligkeitswerte der Lampe halbieren – genauso, wie du es auch bei den Zahlenwerten des Temperatursensors gemacht hast.

Du rechnest also 40 minus 30. Das ergibt 10. Dann teilst du 10 durch 2, um den Abstand zu halbieren. Dies ergibt 5. Das bedeutet jetzt aber noch nicht, dass die 15 als Zahlenwert auch 5 bei der Helligkeit der Lampe bedeuten. Du weiß ja, dass deine Lampe 30 als kleinsten Helligkeitswert anzeigen kann.

Damit deine Rechnung stimmt, schaust du dir noch kurz den Wert 0 des Temperatursensors an. Er entspricht 30 an Helligkeit bei der Lampe. 15 mehr bei den Temperatursensorwerten bedeuten damit 5 mehr Helligkeit bei der Lampe. Also rechnest du zu der kleinsten Helligkeit von 30 die 5 der errechneten Helligkeit für die 15 der Temperatursensorwerte und bekommst eine Helligkeit von 35 bei der Lampe. Wie du schon oben lesen konntest, ist das eine vereinfachte Rechnung. Für die drei Projekte in diesem Kapitel reicht dieses Verständnis völlig aus. Sensoren geben ihre Werte in der Realität nicht immer so gleichmäßig aus, sodass zum Beispiel bei der Messung der ein kleiner Unterschied weniger Temperaturveränderung bei niedrigen Temperaturen verursacht als bei hohen Temperaturen. Genauso verhält es sich auch mit der Helligkeit von Lampen. Doppelter Helligkeitswert bedeutet nicht automatisch, dass die Lampe doppelt so hell wird. Hier ist dein eigenes Austesten gefragt.

Rechnung (kurzgefasst)

Der Temperatursensor zeigt 15 an. Die Temperatursensorwerte reichen von 0 bis 30 und die Lampe kann eine Helligkeit zwischen 30 und 40 anzeigen.

15 in der Messung entspricht dann der Umrechnung (40 -30) / 2 + 30 = 35 als Helligkeit der Lampe.

Das bedeutet aber auch, dass es zu mehreren Sensorwerten des Temperatursensors die gleiche Helligkeitsstufe der Lampe geben muss, da es mehr Werte auf Seiten des Sensors als auf Seiten der Helligkeit der Lampe gibt. Genau kannst du dir das noch einmal in folgender Tabelle ansehen:

Temperatursensorwert Helligkeitswert der Lampe
0–2 30
3–5 31
6–8 32
9–11 33
12–14 34
15–17 35
18–20 36
21–23 37
24–26 38
27–29 39
30 40

Tab. 8–1 Beispiel Umrechnung: Temperaturwerte in Helligkeitswerte

Die ganzen Berechnungen musst du nicht für jeden Sensor durchführen, da dies die Programmierbefehle schon für dich übernehmen.

Wenn du also Daten von einem Sensor bekommst und diese zum Beispiel in die Helligkeit der Lampe umrechnen möchtest, wird dies nicht vom Calliope mini vorgegeben, sondern das musst du als Programmierer selbst festlegen.

Damit dies aber nicht mit großen Tabellen und »wenn-dann«-Programmierblöcken gemacht werden muss, gibt es den »verteile«-Programmierbefehl des Calliope mini.

Abb. 8–4 »verteile«-Programmierbefehl

Der »verteile«-Befehl hat fünf Möglichkeiten, andere Programmierbefehle oder Blöcke anzudocken.

Wenn du den »verteile«-Befehl aus dem Untermenü »Pins« aus dem Menü »Fortgeschritten« auswählst, ist eine Verteilung standardmäßig schon angegeben, die du selbst verändern kannst. Wie das genau geht, lernst du in den drei Projekten in diesem Kapitel. Die Verteilung ähnelt dann der im obigen Beispiel und wird in der folgenden Skizze verdeutlicht.

Abb. 8–5 Skizze der Standardumrechnung des »verteile«-Programmierbefehls

8.1.2 Berechnung des »verteile«-Programmierbefehl

Der »verteile«-Programmierbefehl rechnet anhand der Eingabewerte und der gewünschten Ausgabewerte die Bereiche selbst aus, so dass du dich darum nicht mehr kümmern musst. Für den Fall, dass es dich aber trotzdem interessiert, wie der Calliope mini dies berechnet, kannst du dir folgende Rechnung anschauen.

Nimm einmal an, du benutzt den »verteile«-Befehl in der Standardumrechnung wie oben gezeigt und der Sensor gibt den Wert 256 an den Calliope mini zurück. Dann sind die Werte folgendermaßen vorhanden:

Andockmöglichkeit im »verteile«-Programmierbefehl Werte
verteile 256
von niedrig 0
von hoch 1023
bis niedrig 0
bis hoch 4

Tab. 8–2 Beispielrechnung Mapping durch den »verteile«-Programmierbefehl

Der Calliope mini berechnet jetzt die Formel:

(verteile-Wert – von niedrig) × (von hoch – bis niedrig) ÷ (von hoch – von niedrig) + bis niedrig = Ergebnis

In dem Beispiel also

(256 – 0) × (4 – 0) ÷ (1023 – 0) + 0 = 1024 ÷ 1023 = 1,0009775

Da die Zahl über 1 ist, schneidet der Calliope mini alle Ziffern hinter der 1 ab und gibt die 1 weiter an das Programm.

8.1.3 Sensoren und ihre Werte

In der folgenden Tabelle findest du eine Übersicht über die Sensoren des Calliope mini und ihre Wertebereiche sowie die Ausgabemöglichkeiten.

Sensor (Eingabe) Niedrigster Zahlenwert Höchster Zahlenwert
Beschleunigung -1023 1023
Lichtstärke 0 255
Temperatur -5 50

Tab. 8–3 Übersicht Wertebereiche der Sensoren (Eingabe)

Sensor (Eingabe) Niedrigster Zahlenwert Höchster Zahlenwert
Lautsprecher (Hz)1 20 20000
LED-Helligkeit 0 255

Tab. 8–4 Übersicht Wertebereiche der Ausgabe

Der Lautsprecher kann auch noch niedrigere und höhere Frequenzen abspielen, aber das menschliche Ohr kann diese nicht hören.

8.2 Projekt »Farbverlauf«

8.2.1 Farbverlauf – Sensoren durch Farben sichtbar machen

Wie du im »Mapping«-Kapitel schon lesen konntest, wirst du in diesem Projekt die Veränderung der Temperatur durch Farben sichtbar machen. Bisher konntest du dies nur in kleinen Stufen machen, die du selbst festlegen musstest. Das Mapping ermöglicht es dir nun, die Veränderungen, die ein Sensor misst, direkt auf zum Beispiel einer LED sichtbar zu machen. Je wärmer es wird, desto heller wird die LED rot leuchten.

Abb. 8–6 Calliope mini – mal kalt, mal warm

8.2.2 Was brauchst du für dieses Projekt?

Das Projekt »Farbverlauf« kannst du auch ohne diese Materialien durchführen. Da du mit Temperatur experimentieren wirst, kannst du mit etwas Kaltem (z. B. einem Kühl-Akku) schneller die Effekte sehen. Alternativ kannst du auch einen Ventilator benutzen oder einfach selbst pusten.

Wie viele? Was Anmerkung
1 Handtuch Nicht zu groß und ruhig ein altes Handtuch
1 Kühlpack Findest du normalerweise im Eisfach des Kühlschranks.

Tab. 8–5 Materialien für das Projekt »Farbverlauf«

8.2.3 Alles noch einmal überprüfen, bevor es losgeht!

Dies ist das erste Projekt zum Thema »Mapping«. Es schließt direkt an die Erklärungen am Anfang des Kapitels »Mapping« an. Lies dir dies am besten jetzt durch, wenn du es noch nicht gemacht hast. Du solltest dir folgende Dinge ebenfalls schon angeschaut haben:

8.2.4 Es geht los

Abb. 8–7 »dauerhaft«-Schleife

Als Erstes brauchst du die »dauerhaft«-Schleife, da der Farbverlauf die ganze Zeit angezeigt werden soll.

Wähle die »dauerhaft«-Schleife aus den Grundlagen und ziehe sie in die Programmierfläche.

Wie du in den vorherigen Projekten schon gelernt hast, brauchst du zur Speicherung der Daten, die du vom Sensor bekommst, einen Platzhalter. Im Menü »Platzhalter« kannst du dir einen neuen Platzhalter anlegen und zu deinem Programm hinzufügen.

Lege einen neuen Platzhalter mit dem Namen »helligkeit« an. Der neue Platzhalter wird dann im Menü »Platzhalter« sichtbar.

Abb. 8–8 Platzhalter zur Speicherung der Daten anlegen

Damit du etwas in dem Platzhalter speichern kannst, brauchst du den Programmierbefehl, der den Wert eines Platzhalters auf einen neuen Eingabewert ändert.

Zieh den Programmierbefehl »ändere Platzhalter auf« in die »dauerhaft«­-Schleife deines Programms.

Abb. 8–9 Platzhalter in »dauerhaft«-Schleife eingefügt

Da du den neuen Platzhalter »helligkeit« angelegt hast, kannst du ihn jetzt im »ändere Platzhalter auf«-Programmierbefehl auswählen.

Abb. 8–10 Platzhalter umgestellt auf »helligkeit«

Klicke auf Platzhalter und ändere den zu ändernden Platzhalter auf »helligkeit«.

Nachdem du deinen Platzhalter jetzt im Programm untergebracht hast, kannst du Werte in ihm speichern. Da du die Werte durch das Mapping in Werte für die Helligkeit der roten LED umrechnen willst, brauchst du den neuen Programmierbefehl »verteile«.

Du findest ihn im Menü »Fortgeschritten«, wenn du das Untermenü »Pins« anwählst.

Was meint Mapping?

Der Begriff »Mapping« kommt wie fast alle Programmierbegriffe aus der englischen Sprache und kann auf Deutsch mit »Verteilung« übersetzt werden. Die Sensordaten des Temperatursensors werden umgerechnet und so auf die Eingabewerte der Helligkeit der RGB-LED verteilt.

Abb. 8–11 Untermenü »Pins« des Menüs »Fortgeschritten«

Klicke auf »Fortgeschritten« im Menü. Anschließend klicke auf »Pins« und zieh den Programmierbefehl »verteile« auf die Programmierfläche.

Abb. 8–12 »verteile«-Programmierbefehl

Setz den »verteile«-Befehl an den »ändere helligkeit auf«-Befehl heran.

Die Daten können jetzt durch den »verteile«-Befehl umgerechnet und dann im Platzhalter gespeichert werden. Jetzt musst du den »verteile«-Befehl so anpassen, dass er die richtigen Daten bekommt und dann weiß, wie die Daten umgerechnet werden sollen. Da du die Daten des Temperatursensors umrechnen willst, muss er zuerst an den »verteile«-Befehl ganz oben angehängt werden.

Klicke in dem Menü »Eingabe« auf den Block »Temperatur (°C)« und zieh ihn in die Programmierfläche.

Abb. 8–13 Temperatursensor auswählen

Häng den Block »Temperatur (°C)« an den »verteile«-Befehl an.

Abb. 8–14 Mapping der Temperaturdaten auf den Platzhalter »helligkeit«

Die Daten des Temperatursensors, die dir durch den Befehl »Temperatur (°C)« in Grad Celsius zur Verfügung stehen, werden jetzt an den »verteile«-Befehl übergeben. Dieser Befehl rechnet die Daten um. Im Anschluss werden sie dann im Platzhalter »helligkeit« gespeichert. Dies wird immer wieder wiederholt, da sich dein Programmcode in einer »dauerhaft«-Schleife befindet.

Die Standardwerte für die Umrechnung sind »von niedrig« 0 und »von hoch« 1023 auf »bis niedrig« 0 und »bis hoch« 4. Das bedeutet, dass alle Werte des Sensors, die zwischen 0 und 1023 liegen, jetzt auf die Werte von 0 bis 4 aufgeteilt werden. Wie das genau aussieht, kannst du dir noch einmal am Anfang des »Mapping«-Kapitels durchlesen, wenn du dir unsicher bist.

Abb. 8–15 Mapping Temperaturanpassung

Temperaturen von 1023 Grad sind viel zu hoch und würden dich und den Calliope mini gefährden. Damit du schnell Änderungen in der Temperatur siehst, wählst du am besten eine Temperatur zwischen 28° Celsius und 35° Celsius, da der Calliope mini in einem normal beheizten Raum in etwa diese Temperatur annimmt.

Ändere die 0 bei »von niedrig« auf 28 und danach die 1023 bei »von hoch« auf 35.

Super, dein Calliope mini wird jetzt Temperaturen von 28° Celsius bis 35° Celsius umrechnen. Jetzt musst du dich noch um die Helligkeit der LED kümmern.

Werte unter- und oberhalb

Alle Zahlen über 35 und unter 28 werden weiter umgerechnet nach der Formel. Willst du also keine höheren oder niedrigeren Temperaturen messen, musst du dies selbst vor dem »verteile«-Programmierbefehl verhindern. Ansonsten kann dein Programm sich in den Bereichen, an die du nicht gedacht hast, anders verhalten, als du es erwartest.

Wie du bereits gelernt hast, können die Farben der LED auf eine Helligkeit von 0 (LED aus) bis 255 (LED volle Helligkeit) eingestellt werden. Da du möglichst viele Veränderungen in der Helligkeit sehen möchtest, nutzt du am besten die volle Skala aus.

Ändere die 4 bei »bis hoch« auf die volle Helligkeit, also 255.

Abb. 8–16 Menü »Grundlagen« – LED-Farbe einstellen

Prima. Die »Mapping«-Funktion hast du so eingestellt, dass die Temperatur, die der Temperatursensor misst, in die Werte der Helligkeit umgerechnet wird. Anschließend wird der errechnete Wert automatisch in den Platzhalter »helligkeit« gespeichert.

Jetzt muss dein Platzhalter nur noch die Helligkeit der LED steuern. Dafür brauchst du als Erstes den »LED«-Befehl aus dem Menü »Grundlagen«.

Zieh aus dem Menü »Grundlagen« den Programmierbefehl »setze LED-Farbe auf Rot« in der Programmierfläche.

Abb. 8–17 Eingesetzter »LED«-Programmierbaustein

Setz den Befehl als letzten Block in die »dauerhaft«-Schleife ein.

Die LED-Farbe wird jetzt in deinem Programm auf Rot gesetzt. Da du aber die Helligkeit der LED verändern willst, brauchst du noch einen weiteren Programmierbefehl, bei dem du die Helligkeit aller Farben direkt angeben kannst.

Abb. 8–18 »Farb-LED«-Programmierbefehl

Geh in das Menü »Grundlagen« und zieh den »Farb-LED«-Programmierbefehl in den Programmierbereich.

Da du die LED-Farbe durch den Platzhalter »helligkeit« verändern willst, musst du das »Rot« durch den neuen Programmierbefehl ersetzen.

Abb. 8–19 Eingesetzter »Farb-LED«-Programmierbefehl

Zieh den »Farb-LED«-Programmierbefehl an die Stelle der Farbe »Rot«.

Was dir jetzt noch fehlt, ist der Platzhalter »helligkeit«, damit du die Helligkeit der roten LED auf die Werte einstellen kannst, die durch die »Mapping«-Funktion schon im Platzhalter »helligkeit« gespeichert wurden.

Abb. 8–20 Platzhalter »helligkeit«

Zieh aus dem Menü »Platzhalter« den Platzhalter »helligkeit« in die Programmierfläche.

Abb. 8–21 Eingesetzter Platzhalter »helligkeit«

Zieh den Platzhalter »helligkeit« an die Farbe »Rot«. Ändere den Wert von »Grün« auf 0 und den Wert von »Blau« auf 100.

Toll, du hast das Projekt »Farbverlauf« richtig programmiert. Den Wert bei »Blau« benutzt du nur für den schöneren Farbton, da du in »Rot« noch »Blau« hinzufügst.

8.2.5 Testen

Macht dein Programm das, was es soll? Teste dein Programm beispielsweise, indem du den Calliope mini in die Hand nimmst oder einmal nah an die Heizung hältst. Steigt die Temperatur, sollte die rote LED heller werden, sinkt die Temperatur des Calliope mini wieder, indem du zum Beispiel pustest, sollte die rote LED immer dunkler werden.

Wenn etwas nicht funktionieren sollte, dann vergleich deinen Programmcode noch einmal Schritt für Schritt mit der Anleitung. Manchmal schleichen sich kleine Fehler ein.

8.2.6 Experimentieren

Jetzt geht es ans Experimentieren. Wenn du ein Handtuch und ein Kühlpack aus dem Gefrierfach hast, kannst du das Kühlpack in das Handtuch einwickeln und so den Calliope mini schneller abkühlen. Wenn du den Calliope mini in die Sonne legst, sollte die Temperatur auch schnell ansteigen. Aber Vorsicht: Wasser und große Hitze beschädigen den Calliope mini. Überleg dir einmal, was du noch alles messen könntest und an welchen Stellen eine Temperaturmessung mit dem Calliope mini helfen kann.

Abb. 8–22 Der Calliope mini wird gekühlt

8.2.7 Da geht noch mehr?! – Optimiere dein Projekt

Hier findest du weitere Ideen, wie du dein Projekt noch verbessern kannst. Das Projekt »Farbverlauf« kannst du noch zu einem tollen Thermometer weiterentwickeln.

8.3 Projekt »Luftgitarre«

8.3.1 Luftgitarre – Bewegung und Musik verbinden

Du kennst Luftgitarren wahrscheinlich schon. Wenn du eine tolle Musik hörst und eine Gitarre in dem Lied vorkommt, macht es Spaß, die Gitarre in der Luft nachzuspielen, während die Musik spielt. Dazu kannst du dir auch eine Gitarre basteln, dann macht es noch mehr Spaß.

Aber was hat das mit einem Mikrocontroller und speziell mit dem Calliope mini zu tun? Tja, du wirst deine Luftgitarre so verändern, dass deine Gitarre bei jeder Bewegung Töne von sich geben wird. Dadurch kannst du nicht nur zur Musik mit der Luftgitarre spielen, sondern auch allein mit der Luftgitarre Musik erzeugen.

Wie wird deine Luftgitarre funktionieren, wenn du sie fertig gebastelt und programmiert hast? Du wirst den Beschleunigungssensor des Calliope mini zusammen mit der »Mapping«-Funktion und der Möglichkeit des Calliope mini, auch Töne ausgeben zu können, kombinieren. Hältst du deine Luftgitarre und bewegst dich mit dem Oberkörper nach vorne und hinten, wird deine Luftgitarre einen anderen Ton abspielen. Ziehst du die Gitarre mit dem Griff nach oben, wird der Calliope mini die Töne umso schneller abspielen, je höher du den Griff hältst.

Abb. 8–23 Die Luftgitarre

8.3.2 Was brauchst du für dieses Projekt?

Das Projekt »Luftgitarre« kannst du auch ohne diese Materialien durchführen, aber mit ein wenig Bastelgeschick fühlt sich die Luftgitarre fast wie eine echte Gitarre an.

Wie viele? Was Anmerkung
1 Papprolle Zum Beispiel aus einer Geschenkpapierrolle
1 Pappteller Du kannst dir hier aber auch ewas aus einem Stück Papier rund ausschneiden.
1 Kleber oder Tesafilm Achte nur darauf, dass der Kleber auch für Papier und Pappe geeignet ist.

Tab. 8–6 Materialien für das Projekt »Luftgitarre«

8.3.3 Alles noch einmal überprüfen, bevor es losgeht!

Mapping ist nicht einfach zu verstehen. Du kannst das folgende Projekt auch anhand der Beschreibungen Schritt für Schritt nachvollziehen, um deine Luftgitarre zu basteln. Besser ist es aber, wenn du dir den Abschnitt 8.1 zu »Mapping« vorher durchliest, dann kannst du dein Projekt noch weiter verbessern. Du solltest dir folgende Dinge schon angeschaut haben:

Als Erstes brauchst du die »dauerhaft«-Schleife. Deine Luftgitarre soll nicht irgendwann mittendrin aufhören, Musik zu spielen.

  1. Wähle die »dauerhaft«-Schleife aus den »Grundlagen« und zieh sie in die Programmierfläche.

    Abb. 8–24 »dauerhaft«-Schleife

    Als Nächstes beschäftigst du dich mit dem Menü »Musik«. Hier findest du alle Programmierbefehle, die mit der Musikfunktion des Calliope mini zu tun haben. Du kannst einzelne Noten abspielen lassen, einen Klingelton erzeugen oder die Geschwindigkeit der Töne verändern.

  2. Klicke auf »Musik«, und das Musikmenü geht auf, das dir alle zugehörigen Programmierbefehle zeigt.

    Abb. 8–25 Musikfunktionen des Calliope mini

    Der für dich interessante Programmierbefehl ist »spiele Note«. Wie du siehst, hat »spiele Note« zwei Möglichkeiten, Blöcke einzuhängen: zuerst die Note und als Zweites den Takt.

  3. Ziehe den Programmierbefehl »spiele Note« in die »dauerhaft«-Schleife.

    Abb. 8–26 Der Programmierbefehl »spiele Note«

    Wenn du auf das C drückst, bekommst du alle vorgegebenen Noten als Auswahl. Die niedrigste Note ist das C und die höchste auswählbare Note ist das B5. Dies kennst du aus dem Musikunterricht, ansonsten probier die verschiedenen Noten einfach vorher einmal aus.

    In der zweiten Stelle kannst du den Takt einstellen. Je kleiner der Takt, desto kleiner ist auch die Pause zwischen zwei Noten. Vielleicht hast du die Musikfähigkeiten des Calliope mini auch schon in einem anderen Projekt umgesetzt.

    Die Idee hinter deiner Luftgitarre ist, dass du die Bewegung der Luftgitarre auf die Noten und die Geschwindigkeit, in der sie abgespielt werden, umrechnest. Dazu brauchst du zuerst den »verteile«-Befehl und danach den richtigen Sensor.

    Abb. 8–27 »Fortgeschritten«-Menü

    Den »verteile«-Befehl findest du, wenn du auf das »Fortgeschritten«-Menü klickst und danach auf das Untermenü »Pins«.

  4. Finde den »verteile«-Befehl und zieh ihn in die Programmierfläche.

    Abb. 8–28 Programmierbefehl »verteile«

    Der »verteile«-Befehl hat fünf Möglichkeiten andere Programmierbefehle oder Blöcke anzudocken.

    • »verteile«: Hier gibst du an, welche Daten du in einen anderen Wertebereich umrechnen möchtest. Das können ein Platzhalter oder auch direkte Sensordaten sein.
    • »von niedrig«: die kleinste Zahl vor dem Umrechnen
    • »von hoch«: die größte Zahl vor dem Umrechnen
    • »bis niedrig«: die kleinste Zahl nach dem Umrechnen
    • »bis hoch«: die größte Zahl nach dem Umrechnen

    Schau dir dazu auch noch einmal die Wertebereiche der Sensoren am Ende des »Mapping«-Kapitels an.

  5. Ersetze die Note C durch den »verteile«-Befehl.

    Abb. 8–29 Eingesetzter »verteile«-Befehl

    Da deine Luftgitarre nicht nur Musik abspielen, sondern auch verändern kann, wenn du die Luftgitarre bewegst, brauchst du einen Sensor, der Bewegungen wahrnehmen kann. Der Calliope mini hat dafür zum Glück schon einen passenden Sensor eingebaut: den Beschleunigungssensor. Der Beschleunigungssensor kann auf drei Achsen die Bewegung messen.

    Abb. 8–30 »Beschleunigungssensor«-Block

    Hinweis

    Wenn du dir unsicher bist, wie der Beschleunigungssensor genau funktioniert und welche Achsen genau welche Drehung bedeuten, dann schau noch einmal im Abschnitt 4.1.2 nach.

  6. Zieh den »Beschleunigungssensor«-Block in den »verteile«-Befehl an die Stelle »verteile«.

    Abb. 8–31 Eingesetzter Beschleunigungssensorwert

    Der Beschleunigungssensor gibt dir die Daten wieder, die er misst, wenn der Calliope mini über die x-Achse gedreht wird. Da du den Calliope mini bei der Luftgitarre auf dem Pappteller befestigen willst und die Töne sich ändern sollen, wenn du die Luftgitarre nach vorne und nach hinten bewegst, lässt du die schon ausgewählte x-Achse stehen.

    Jetzt musst du den Wertebereich des Beschleunigungssensors eingeben, damit jede Bewegung der Luftgitarre auch einem Ton zugeordnet werden kann. Der Beschleunigungssensor hat einen Wertebereich von -1023 bis 1023. Wenn du den Calliope mini flach mit der Beschriftung nach oben auf den Tisch legst, gibt der Sensor mit dem Programmierblock »Beschleunigung (mg) x« eine 0 zurück. Kippst du den Calliope mini von dir weg, wird der gemessene Wert immer kleiner bis zum Wert -1023, wenn der Calliope mini senkrecht steht. Kippst du den Calliope mini stattdessen zu dir hin, dann erhöhen sich die Werte immer weiter bis 1023.

    Achtung

    Drehst du den Calliope mini weiter, dann wechselt er direkt von 1023 auf -1023 oder andersherum.

  7. Gib beim »verteile«-Befehl bei »von niedrig« -1023 ein und bei »von hoch« 1023.

    Abb. 8–32 »verteile«-Programmierbefehl mit Sensor-Wertebereich

    Du hast den Wertebereich des Beschleunigungssensors gesetzt. Jetzt fehlt noch der neue Wertebereich, in den du die Daten des Beschleunigungssensors umrechnen willst. Da du verschiedene Musiktöne machen willst, musst du die Töne in der zugehörigen Frequenz angeben. In der Tabelle findest du zu bestimmten Noten die passende Frequenz.

    Note Frequenz
    C 262
    D 294
    Eb 311
    E 330
    F 349
    FSharp 370
    G 392
    GSharp 415
    A 440
    Bb 466
    B 494
    C5 523
    B5 989

    Tab. 8–7 Töne und Frequenzen

    Link

    Eine Liste der Frequenzen und den zugeordneten Tönen findest du hier:
    http://pianotip.de/frequenz.html

    Damit du die ganze Bandbreite der Töne abdecken kannst, solltest du den tiefsten Ton als niedrigsten Wert für die Frequenz wählen und den höchsten Ton als höchsten Wert der Frequenz.

    Abb. 8–33 »Mapping«-Programmierbefehl mit vollständigen Werten.

  8. Trag bei »bis niedrig« 262 für den Ton C und bei »bis hoch« 989 für den Ton B5 ein.

    Teste diesen Zwischenstand jetzt ruhig einmal aus. Du kannst später hier auch andere Werte ausprobieren und sehen, wie sich die Musik deiner Luftgitarre verändert.

    Als nächsten Schritt beschäftigst du dich mit dem Takt. Da du eine Luftgitarre programmierst, soll die Musik schnell genug sein. Du musst also die Pausen zwischen den Tönen möglichst kurz stellen.

  9. Stell bei Takt von 1 auf 1/16 um. Dadurch werden die Pausen zwischen den Tönen sehr kurz.

    Abb. 8–34 Mapping vollständig für die Tonwiedergabe

  10. Super! Du kannst das Programm jetzt schon einmal austesten. Überspiele dein Programm auf den Calliope mini und teste es aus.

    Werden Töne gespielt, wenn du den Calliope mini bewegst? Du kannst auch die Wertebereiche anpassen, bis dir die Töne am besten gefallen.

    Jetzt kann deine Luftgitarre schon Töne spielen, wenn sie nach vorne oder hinten geneigt wird. Was jetzt noch fehlt, ist, dass die Musik schneller wird, je mehr du die Luftgitarre nach oben hältst. Dazu wirst du wieder den Beschleunigungssensor benutzen, um eine andere Achse auszulesen, und den »Mapping«-Programmierbefehl, um die Sensorwerte auf die Geschwindigkeit der Musik umzurechnen. Zu allererst brauchst du dazu einen neuen Platzhalter, den du »bpm« nennst.

    BPM

    BPMBPM steht für Beats per Minute. Das heißt übersetzt »Schläge pro Minute« und beschreibt die Geschwindigkeit, in der ein Lied abgespielt wird. Elektronische Musik in der Disco oder auch bestimmte Bereiche der Metal Music können eine Geschwindigkeit von über 200 BPM haben. Normalerweise haben Lieder unter 120 BPM.

  11. Leg einen neuen Platzhalter an und nenn ihn »bpm«.

  12. Aus dem Menü »Platzhalter« wählst du den Programmierbefehl »ändere Platzhalter auf« und fügst ihn an als letzten Befehl in die »dauerhaft«-Schleife ein.

  13. Ändere den Platzhalter auf »bpm«.

    Abb. 8–35 BPM-Mapping

    Jetzt hast du den Platzhalter hinzugefügt, in dem du die Werte, die der Sensor dir geben wird, speichern kannst. Da der Sensor andere Sensordaten zurückgibt, als du für die Geschwindigkeit der Musik benutzen kannst, musst du die Werte umrechnen. Dazu kannst du wieder den »verteile«-Programmierbefehl nehmen.

  14. Füge dem »ändere bpm auf«-Befehl den »verteile«-Programmierbefehl aus dem »Fortgeschritten«-Menü des Untermenüs »Pins« an.

    Genauso wie beim Mapping weiter oben brauchst du den Beschleunigungssensor und seinen Wertebereich. Diesmal benutzt du aber nicht die x-Achse zur Messung, sondern die y-Achse.

  15. Setz den Beschleunigungssensor aus dem Menü »Eingabe« an die Stelle »verteile« und ändere die Achse von »x« auf »y«.

  16. Jetzt passt du den Wertebereich genauso wie vorher an den Beschleunigungssensor an.

    Abb. 8–36 Mapping mit der y-Achse des Beschleunigungssensors

    Den Wertebereich der Musiknoten hattest du aus den Frequenzen der Töne herausgearbeitet, für den Platzhalter »bpm« musst du nun einen neuen Wertebereich bestimmen. Wie du schon in diesem Projekt gelesen hast, können sehr schnelle Musikstücke über 200 BPM schnell sein. Daher setzt du »bis hoch« am besten auf 200 und »bis niedrig« auf 1.

    Für die Sensordaten des Beschleunigungssensors auf der y-Achse gibt der Sensor Werte von -1023 bis 1023 wieder. Wenn du den Calliope mini mit der flachen Seite gegen deinen Bauch mit dem USB-Anschluss nach rechts hältst und nun die linke Seite des Calliope mini nach oben neigst, dann gibt der Sensor dir immer höhere Werte, je stärker du den Calliope mini nach oben neigst. Genau andersherum verändern sich die Werte in die andere Richtung, sodass die Werte immer kleiner werden.

    Der »Mapping«-Programmierbefehl rechnet also den Wertebereich von -1023 bis 1023 auf den neuen Wertebereich von 1 bis 200 für dich um.

  17. Verändere »bis niedrig« auf 1 und »bis hoch« auf 200.

    Du hast den Platzhalter »bpm« jetzt auf die passenden Werte der Musikgeschwindigkeit umgerechnet. Jetzt musst du noch die Geschwindigkeit der Musik auf den errechneten BMP-Wert setzen. Dazu findest du im Menü »Musik« den Programmierbefehl »ändere die Geschwindigkeit auf (bpm)«. Der Befehl ändert die Geschwindigkeit der aktuell gespielten Musik auf die angegebene Zahl. Da du die Musikgeschwindigkeit auf den Platzhalter »bpm« setzen willst, muss er dort angedockt werden.

  18. Füge den Programmierbefehl »ändere Geschwindigkeit auf (bmp)« aus dem Menü »Musik« als letzten Befehl in die »dauerhaft«-Schleife ein.

  19. Ersetze die angegebenen 120 BPM durch deinen Platzhalter »bpm«.

    Abb. 8–37 »Luftgitarre«-Programmierung komplett

    Riesig! Dein Programm zur Luftgitarre ist fertig. Jetzt kannst du die Luftgitarre austesten. Rock' los!

8.3.5 Testen

Macht dein Programm das, was es soll? Teste dein Programm, indem du den Calliope mini über die x-Achse und y-Achse kippst. Du solltest die Musik nun in der Geschwindigkeit und den Tönen ändern können.

Wenn etwas nicht funktionieren sollte, vergleich deinen Programmcode noch einmal. Manchmal schleichen sich kleine Fehler ein.

8.3.6 Basteln

Jetzt geht es ans Basteln, damit das Projekt noch mehr Spaß macht. Deine Luftgitarre kann jetzt schon vollständig benutzt werden. Was jetzt noch fehlt, ist eine Hülle, damit sich die Luftgitarre nachher fast wie eine echte Gitarre anfühlt. Dazu brauchst du ein längeres Stück Pappe, zum Beispiel eine Papprolle, die bei Geschenkpapier übrigbleibt, und eine größere Fläche, auf der du den Calliope mini befestigen kannst – zum Beispiel einen Pappteller.

Klebe den Pappteller auf das untere Ende der Papprolle. Befestige danach den Calliope mini auf dem Pappteller mit ein paar Gummis. Du kannst die gebastelte Luftgitarre jetzt noch anpassen, indem du sie anmalst.

Abb. 8–38 Voila – die fertige Luftgitarre

8.3.7 Da geht noch mehr?! – Optimiere dein Projekt

Hier findest du weitere Ideen, wie du dein Projekt noch verbessern kannst. Es liegt an dir, die beste Calliope mini-Luftgitarre zu programmieren.

8.4 Projekt »Fang den Dot«

8.4.1 »Fang den Dot« – Ein Geschicklichkeitsspiel

In diesem Profiprojekt wirst du ein Geschicklichkeitsspiel mit dem Calliope mini programmieren. In dem Spiel steuerst du einen kleinen Punkt mit dem Namen »Dot«. Den Dot kannst du steuern, indem du den Calliope mini über die x-Achse und y-Achse kippst. Auf diese Weise kann sich der Dot auf dem ganzen Display hin und her bewegen.

Das ist ja schon einmal ganz toll. Aber auf Dauer bekommt der Dot Langeweile und sucht sich einen zweiten Dot zum spielen. Das Spiel geht so, dass der erste Dot den zweiten Dot, der in seiner Umgebung erscheint, fangen muss. Der Spieler, der dein Spiel spielt, soll also möglichst schnell mit dem steuerbaren Dot den automatischen Dot fangen.

Abb. 8–39 Fang den Dot!

8.4.2 Text noch einmal überprüfen, bevor es losgeht!

Du bist beim letzten Projekt des »Mapping«-Kapitels angelangt und bist jetzt schon ein Profi, was Mapping anbelangt. Damit du dieses Projekt gut umsetzen kannst, solltest du folgende Calliope mini-Funktionen schon beherrschen:

8.4.3 Es geht los

Da dein Spiel dauerhaft funktionieren soll, brauchst du die »dauerhaft«-Schleife. Als Erstes beschäftigst du dich mit einer der Achsen des Calliope mini. In diesem Projekt benutzt du zuerst die x-Achse. Beim Kippen der x-Achse soll der Dot sich auf dem Display genau dann nach links bewegen, wenn der Calliope mini nach links gekippt wird. Für die rechte Seite willst du das genauso realisieren. Dazu brauchst du den »verteile«-Programmierbefehl, einen neuen Platzhalter »rX«, der das Ergebnis speichert, und die Daten des Beschleunigungssensors für die x-Achse.

  1. Lege einen neuen Platzhalter »rX« an und ändere den Wert des Platzhalters auf die verteilten Werte des Beschleunigungssensors der x-Achse.

    Abb. 8–40 Mapping der x-Achse

    Der Beschleunigungssensor misst von -1023 bis 1023. Das LED-Display hat in jede Richtung fünf Lampen.

  2. Mappe die Daten des Beschleunigungssensors der x-Achse auf die Anzahl der Lampen von links nach rechts auf dem LED-Display.

    Hinweis

    Denk daran, dass man in der Informatik mit der 0 zu zählen anfängt und dass deshalb die erste Lampe des LED-Displays immer die Zahl 0 hat und nicht 1.

    Da du aber in dem Spiel den Dot nicht nur in eine Richtung (von rechts nach links) steuern möchtest, sondern auch von oben nach unten, brauchst du eine zweite Achse. Wie du schon in den vorangegangenen Kapiteln lernen konntest, kann der Calliope mini über den Beschleunigungssensor drei Achsen auslesen. Über die y-Achse kann der Calliope mini ein Kippen nach vorne und nach hinten messen.

  3. Lege einen neuen Platzhalter für die y-Achse an und nenne ihn »rY«.

    Wenn du dir den letzten Programmblock mit dem Mapping der x-Achse ansiehst, kannst du erkennen, dass sich sehr viel mit dem Verhalten des Spiels auf der y-Achse ähnelt. Die Unterschiede sind zum einen der Platzhalter »rY« statt »rX« und zum anderen, dass der Beschleunigungssensor nicht die Daten der x-Achse, sondern die Daten der y-Achse herausgeben soll.

    Da sich der Programmcode so stark ähnelt, kannst du ihn einfach duplizieren und dann anpassen.

  4. Klicke mit der rechten Maustaste auf den »ändere rX auf«-Befehl und klicke anschließend in dem Menü, das nun auftaucht, auf »Duplizieren«.

    Abb. 8–41 Duplizieren des ersten Programmblocks zum Mapping der x-Achse

  5. Pass den zweiten Programmblock für die y-Achse an und setz ihn unterhalb des Programmblocks für die x-Achse.

    Abb. 8–42 Mapping der x-Achse und der y-Achse

    Wenn du den Calliope mini jetzt in die verschiedenen Richtungen kippst, werden die Werte des Beschleunigungssensors von der x-Achse und der y-Achse auf die Ziffern 0 bis 4 verteilt. Jetzt musst du die Anzeige des Dots und die Bewegung des Dots daran anpassen.

    Den Dot lässt du erscheinen, indem du den »Zeichne x y»-Befehl benutzt, der sich immer entsprechend der aktuellen Lage deines Calliope mini bewegt.

  6. Zieh den »Zeichne x y«-Befehl unter den y-Achse-Programmblockund zieh für den x-Wert den Platzhalter »rX« sowie für den y-Wert den Platzhalter »rY« in den »Zeichne«-Programmierbefehl.

    Abb. 8–43 Dot auf dem Display laufen lassen

    Sehr gut! Dein Dot bewegt sich jetzt auf dem Display in alle Richtungen. Aber wie du beim Testen merkst, sind schnell alle Lampen des Displays an und du kannst nicht mehr sehen, wo der Dot sich gerade befindet.

    Der Grund ist folgender: Nachdem der Dot auf einem Platz war und dort die Lampe angegangen ist, wird die Lampe nicht mehr ausgeschaltet, wenn der Dot sich in eine andere Richtung bewegt.

    Das Ausschalten der Lampe kannst du über den Programmierbefehl »schalte Pixel x y« erreichen. Dieser Befehl schaltet eine Lampe des Displays (wird auch Pixel genannt) an einer bestimmten Stelle aus.

  7. Zieh den »schalte Pixel«-Befehl an den Anfang der »dauerhaft«-Schleife und ergänze die »x«- und »y«-Stelle durch deine beiden Platzhalter für die beiden Achsen.

    Abb. 8–44 Dot allein auf dem Display

    Jetzt läuft dein Dot schon allein über das Display. Toll, damit hast du schon einen Großteil der Spielfunktionen umgesetzt. Jetzt brauchst du noch einen zweiten Dot auf dem Display, damit dein Dot zu diesem Punkt gehen kann, um dort den anderen Dot zu fangen. Dieser zweite Dot soll direkt beim Start des Programms sichtbar sein und an einer zufälligen Stelle auf dem Display auftauchen.

    Abb. 8–45 Beim Start wird eine zufällige x-Position gewählt.

  8. Benutze den »beim Start«-Programmblock und ändere einen neuen Platzhalter mit dem Namen »infoDotX« auf eine zufällige Zahl zwischen 0 und 4.

    Genauso, wie du den Programmblock eben duplizieren konntest, kannst du dies auch an dieser Stelle für den y-Wert tun.

  9. Leg einen neuen Platzhalter »infoDotY« an. Dupliziere dann den ersten Programmblock und ändere den Platzhalter auf »infoDotY«.

    Abb. 8–46 Zeichne einen zweiten Dot an einer zufälligen Position beim Start

    Jetzt fehlt nur noch das Zeichnen des neuen Dots an der zufälligen Stelle. Dies kannst du genauso wie beim ersten Dot machen.

  10. Benutz den »Zeichne x y«-Befehl, um den neuen Dot an der zufälligen Position anzuzeigen.

    Gut, du hast nun einen zufälligen Dot auf dem Display beim Start und kannst dich mit dem ersten Dot auf dem Display bewegen. Jetzt muss nur noch etwas passieren, wenn der erste Dot den zweiten Dot fängt. Dazu musst du wieder in die »dauerhaft«-Schleife deines Programms schauen.

    Da du nur etwas machen willst, wenn der erste Dot den zweiten Dot erreicht, kannst du den »wenn-dann«-Programmblock benutzen.

  11. Zieh den »wenn-dann«-Programmierblock unterhalb des »Zeichne x y«-Befehls in die »dauerhaft«-Schleife.

    Abb. 8–47 »wenn-dann«-Programmierblock in der »dauerhaft«-Schleife

    Die spannende Frage ist nun, wann du weißt, dass sich der erste Dot und der zweite Dot auf der gleichen Stelle des Displays befinden. Dies ist dann der Fall, wenn der x-Wert des ersten Dots und der x-Wert des zweiten Dots gleich sind und gleichzeitig der y-Wert des ersten Dots und der y-Wert des zweiten Dots gleich sind.

    Genauso kannst du dies jetzt auch in deinem Programmcode ausdrücken. Als Erstes brauchst du den »und«-Block, indem danach die x-Werte und y-Werte verglichen werden.

    Abb. 8–48 »und«-Programmblock im »wenn-dann«-Programmblock

  12. Zieh einen »und«-Block an das »wenn« des »wenn-dann«-Blocks.

    Jetzt willst du die x-Werte und y-Werte der beiden Dots vergleichen. Dazu brauchst du zwei »gleich«-Programmierbefehle.

    Abb. 8–49  Zwei »gleich«-Programmierbefehle

  13. Zieh zwei »gleich«-Programmierblöcke hinter und vor das »und« im »und«-Block.

    Jetzt brauchst du noch zwei Platzhalter für die x-Werte sowie die beiden Platzhalter für die y-Werte. Dann kannst du die x-Werte miteinander vergleichen und genauso auch die y-Werte. Wenn beide gleich sind, sind beide Dots auf derselben Position auf dem Display.

  14. Vergleiche als Erstes die x-Werte der beiden Dots »rX« und »infoDotX«. Anschließend machst du das Gleiche für die y-Werte.

    Abb. 8–50 Vergleich der Positionen der beiden Dots

    Jetzt musst du den »dann«-Block noch füllen. Wenn der erste Dot auf der Position des zweiten Dots angelangt ist, soll der zweite Dot sich eine neue zufällige Position suchen. Erinnerst du dich, wo du diesen Block schon einmal programmiert hast? Genau! Im »beim-Start«-Programmblock.

    Du musst also die Programmblöcke im »beim-Start«-Programmblock nur duplizieren und in den »dann«-Teil des »wenn-dann«-Programmblocks einfügen.

  15. Dupliziere alle Programmblöcke aus dem »beim-Start«-Programmblock, sodass sich der zweite Dot eine neue Position sucht, wenn der erste Dot den zweiten Dot erreicht hat.

    Abb. 8–51 Der zweite Dot wird gefangen und sucht sich ein neues Versteck.

    Super! Das Spiel funktioniert jetzt schon. Du kannst das Spiel jetzt noch auf viele Arten erweitern. Schau dazu am Ende des Kapitels nach oder setz eigene Ideen um.

8.4.4 Testen

Macht dein Spiel genau das, was es soll? Teste es erst einmal ausgiebig und pass die Werte für den Bewegungssensor so an, dass beim Kippen des Calliope mini der Dot sich gut bewegen kann und es dein Spiel nicht stört, wenn du den Calliope mini zu viel kippen musst.

Denk immer daran: Kleine Fehler schleichen sich immer mal wieder ein. Wenn dein Spiel sich nicht so verhält, wie du es willst, schau dir die einzelnen Programmblöcke in diesem Buch noch einmal an und vergleich sie mit deinen Programmblöcken.

8.4.5 Da geht noch mehr?! – Optimiere dein Projekt

Hier findest du weitere Ideen, wie du dein Projekt verbessern kannst. Das Spiel bietet noch sehr viele Erweiterungsmöglichkeiten.