TI Coding mit TI-Nspire™ Technologie und TI-Innovator™ Hub

In der ersten Übung dieser Lektion wirst du lernen, wie man im Programmeditor ein Programm schreibt, das ein Lämpchen am TI-Innovator™ Hub steuert.

Lernziele:

• Den TI-Nspire™ Programmeditor verwenden
• Mit dem Send-Befehl ein Licht am TI-Innovator™ Hub steuern
• Einführung der Wait-Anweisung
• Zeitkontrolle am TI-Innovator™ Hub und im Calculator

Verbinde den TI-Innovator Hub mit TI-Nspire™ CX. Der Rechner kommt gleich dran. Am TI-Innovator Hub leuchtet ein grünes LED-Licht. Es zeigt uns an, dass der TI-Innovator™ Hub mit Strom versorgt und bereit ist.

Wenn du lernst, einen Rechner mit dem TI-Innovator™ Hub zu programmieren, wirst du auch lernen, in zwei separierten, aber doch verbundenen Welten zu programmieren: Rechner und TI-Innovator™ Hub.

Für das Programmieren am Rechner werden wir den Programmeditor verwenden, der sich im menu des Calculators findet. Mit dem Send-Befehl werden Anweisungen zum TI-Innovator™ Hub geschickt, die eine physikalische Reaktion erzeugen (ein Licht leuchtet auf, ein Ton erklingt, ein Motor wird gestartet, etc.).

Die TI-Innovator™ Hub Befehle findet man im Menü des Programmeditors im Hub-Untermenü.

Unser erstes Programm soll den TI-Innovator™ Hub anweisen, ein rotes Lämpchen (LED) fünf Sekunden aufleuchten zu lassen.

1. Um ein neues Programm im Calculator zu schreiben, drücke menu > Funktionen und Programme > Programmeditor > Neu.
2. Wähle einen Programmnamen (wir nehmen licht1) und drücke [enter].

Dein Programm besteht aus einer einzigen Programmzeile:

Send(“SET LIGHT ON TIME 5”)

LIGHT ist die Bezeichnung für die rote LED (light-emitting diode).

Um diese Anweisung zu erzeugen, gehe folgendermaßen vor:

3. Drücke die menu-Taste und wähle das Hub-Menü.
4. Wähle nun Send “SET… aus
5. Dann wähle das LIGHT-Menü.

Das Hub-Untermenü beinhaltet Anweisungen, die dem Programmieren des TI-Innovator™ Hub dienen. Diese Anweisungen können eingegeben werden, aber es ist im Allgemeinen einfacher, sie aus dem Menü zu beziehen.

Wenn du Send “SET gewählt hast, findest du im nächsten Untermenü den Menüpunkt LIGHT. Im Untermenü Settings findest du ON und TIME.

6. Vervollständige damit die Anweisung zu:
   Send(“SET LIGHT ON TIME 5”)

7. Hole ON und TIME aus menu > Hub > Settings.

Rechts kannst du das vollständige Programm sehen.

Die Send-Anweisung sendet den String (Zeichenkette in Anführungszeichen) zum TI-Innovator™ Hub.

Führe jetzt das Programm aus:

1. Drücke [ctrl] [B] für ‘Syntax überprüfen und Speichern’.
2. Wechsle in den Calculator.
3. Drücke [var] und wähle das Programm aus der Liste. Damit wird der Programmname in den Home Screen kopiert.
4. Überprüfe, ob dein TI-InnovatorTM Hub mit dem Rechner verbunden ist.
5. Mit [enter] startest du das Programm.

Wenn alles richtig geschrieben wurde, dann wird das LIGHT (die rote LED) fünf Sekunden lang aufleuchten. Bei einem Fehler leuchtet die Diode kurz auf und ein Piepston ertönt.

Der Rechner zeigt Fertig, wenn das Programm beendet ist. Du wirst bemerken, dass das Programm beendet wird, bevor das Licht verlischt. Um das Programm gleichzeitig mit dem Aufleuchten zu beenden, müssen wir dem Rechner mitteilen, dass er so lange warten soll wie die Diode aufleuchtet.

Um eine weitere Anweisung ins Programm aufzunehmen, müssen wir es editieren:

1. Wechsle in den Programmeditor.
2. Füge eine Leerzeile ein, indem du den Cursor ans Ende der Send-Anweisung platzierst und drücke [enter].
3. Wait findest du im Hub-Menü.
4. Füge die Anweisung Wait 5 unmittelbar vor EndPrgm ein.

Speichere das Programm, schließe den Editor und führe das Programm aus.

Wenn das Programm die letzte Eintragung im Calculator ist, dann drücke einfach [enter] für einen neuerlichen Durchlauf. Das Programm wird ziemlich gleichzeitig mit dem Erlöschen des roten Lichts beendet werden.

Wir können TIME aus der Send-Anweisung entfernen und die Zeitsteuerung im Rechner über die Wait-Anweisung durchführen.

Erweiterungen

• Um das Licht auszuschalten verwende die Anweisung
  Send(“SET LIGHT OFF”)
• Füge weitere Anweisungen ein, um die LED öfters blinken zu lassen.

In der zweiten Übung von Lektion1 wirst du lernen, wie man die FARBEN LED am TI-Innovator™ Hub in einem Programm anspricht und steuert.

Lernziele:

• Argumente in einem Programm verwenden
• Kontrolle der COLOR (FARBEN) LED

Die COLOR LED (light emitting diode) hat drei Farbkanäle: rot, grün und blau. Man spricht daher auch von einer RGB LED.

Jede spezielle Farbe kann über eine geeignete Mischung der Anteile von rot, grün und blau erzeugt werden.

Wir wollen zuerst die COLOR LED direkt aus der Calculator App ansprechen:

1. Über menu > Funktionen und Programme > E/A wähle den Befehl Send.

2. Füge nach Send An- und Ausführungszeichen an. ([ctrl] [x] = [" "]).
3. Schreibe zwischen die Anführungszeichen den Text
   SET COLOR
   gefolgt von drei durch eine Leerstelle getrennten numerischen Werten, die die Anteile von rot, grün und blau angeben, die gemeinsam leuchten sollen.
   • Diese Zahlenwerte können zwischen 0 und 255 liegen. Je höher die Zahl, desto intensiver ist der Farbwert. Rechts gibt es ein paar Beispiele.

Beachte, dass die LED so lange aufleuchtet, bis du die Eingabe änderst. Ein Programm kann helfen, die LED vorher auszuschalten.

Im Programm wirst du mit der COLOR LED experimentieren. Die Farbwerte werden als Argumente eingesetzt und die LED wird in der von dir gewünschten Farbe ein paar Sekunden aufleuchten und dann wieder verlöschen.

1. Wir beginnen ein neues Programm aus dem Calculator über
   menu > Funktionen und Programme > Programmeditor > Neu….
2. Das Programm soll die Bezeichnung farbe01 erhalten.

3. Schreibe zwischen die Klammern nach dem Programmnamen drei Buchstaben, durch Kommas getrennt für die Farbwerte für rot, grün und blau.
   • Dies sind die ‚Programmargumente’ und sie senden die drei Farbwerte an den Hub.
   • Wir wählen die Buchstaben (Variablen) r,g,b.

Argumente sind ‚Platzhalter‘ für die Werte, die wir für einen Programmlauf annehmen. Das sind Variable, die das Programm für deine aktuellen Werte verwendet. Sie bestehen nur für dieses Programm und sind nicht für andere Apps verfügbar. Daher werden sie wie ‚lokale‘ Variable behandelt.

Das komplette „Farbprogramm“

4. Wähle menu > Hub > Send “SET…>COLOR und füge damit den ersten Teil der Anweisung ins Programm ein.

Die Erklärung von eval( )

Du kannst die Variablen R G B nicht als Farbwerte in der Send-Anweisung senden, da die Buchstaben R, G und B und nicht die Werte der Variablen zum TI-Innovator™ Hub geschickt werden.

Wir müssen die spezielle Funktion eval( ) aus dem Hub-Menü verwenden, die den numerischen Wert des Rechners in eine Zeichenkette umwandelt, die dann der TI-Innovator™ Hub verarbeiten kann.

Ergänzung der Send-Anweisung:

5. Füge die eval( )-Funktion über menu > Hub > eval( an.
6. Schreibe den Buchstaben r zwischen die Klammern.
7. Hänge ein Leerzeichen dran.
8. Wiederhole die eval( )-Funktion zwei weitere Male für die Variablen g und b. Vergiss die Leerzeichen nicht. Die komplette Send-Anweisung sollte dann so aussehen wie rechts abgebildet.

9. Füge eine Wait-Anweisung nach der Send-Anweisung für ein paar Sekunden Pause an. Vergiss nicht, die Anzahl der Sekunden anzugeben.

10. Hänge zum Schluss eine weitere Send “SET COLOR …-Anweisung an, um die Farb-LED wieder abzuschalten.
    • Nimm drei Nullen. Damit werden alle drei Farben abgeschaltet.
11. Mit [ctrl] [B] wird das Programm auf syntaktische Richtigkeit geprüft und gespeichert.

Programmausführung:

12. Verbinde den TI-Innovator™ Hub mit dem Rechner, drücke [var] im Calculator und wähle das Programm (oder tippe einfach den Programmnamen mit einem Klammernpaar ein).
13. Schreibe der Farbwerte für rot, grün und blau, die gemischt werden sollen, in die Klammern und drücke [enter].

• Die Farb-LED wird so viele Sekunden aufleuchten, wie du in der Wait-Anweisung angegeben hast, dann wird das Lämpchen verlöschen.

Um das Programm nochmals mit anderen Argumenten auszuführen, drücke zweimal die Pfeil-Hoch-Taste um den Programmnamen zu aktivieren, drücke [enter], ändere die Farbwerte nach deinen Wünschen und drücke wieder [enter].

In der dritten Übung der ersten Lektion wirst du eine weitere Methode lernen, Daten für ein Programm einzugeben und wie man den Ton (SOUND) am TI-Innovator™ Hub steuert.

Lernziele:

• Die Request-Anweisung anwenden
• Steuerung von Frequenz und Dauer des Lautsprechers (SOUND)

Der TI-Innovator™ Hub hat einen Lautsprecher (genannt SOUND) eingebaut.

Du steuerst den aus dem Lautsprecher tönenden Ton indem du einen Wert für seine Frequenz sendest. Die Frequenz wird in Hertz (Hz) oder in Schwingungen pro Sekunde gemessen.

Die Request-Anweisung findet man im E/A-Menü. Sie wird verwendet um eine Eingabe vom Anwender zu erhalten und gibt dem Programmierer die Möglichkeit, dem Anwender eine sinnvolle Information zur Eingabe anzubieten.

Die Syntax der Anweisung ist: Request <Zeichenkette> , <Variable>

In unserem Tonprogramm werden wir die Request-Anweisung einsetzen.

Wir beginnen mit unserem TON-Programm

1. Beginne ein neues Programm und nenne es ton1.
2. Füge die Request-Anweisung aus dem E/A-Menü ein.
3. Schreibe die Eingabeaufforderung “Frequenz? ” und ein Komma nach dem reservierten Wort Request.
4. Tippe dann die Variablenbezeichnung für die Frequenz ein, wie z.B. freq.
5. Füge eine weitere Request-Anweisung hinzu, dass der Anwender auch die dauer eingeben kann, wie lange der Ton erklingen soll.

So wie beim Farbprogramm in der vorherigen Übung müssen wir mit Hilfe der Funktion eval( ) die Variablenwerte für freq und dauer konvertieren.

Wir schreiben beenden das Programm zu Ende

6. Wähle Send “SET… mit SOUND über menu > Hub > Send “SET… > SOUND.
7. Wähle eval( über menu > Hub > eval().
8. Füge die Variablenbezeichnung freq zwischen den Klammern ein.
9. Nach einem Zwischenraum füge eine weitere eval()-Funktion für die Variable dauer hinzu.
10. Speichere das Programm mit [ctrl] [B].

Programmausführung:

Nach Start des Programms erscheint ein Kasten als Ergebnis der Request-Anweisung.

1. Gib zuerst für die Frequenz 440 und im nächsten Kasten für die Dauer 5 ein.
   • Dies lässt den Ton von 440 Hz für 5 Sekunden ertönen. Das heißt, dass der Lautsprecher fünf Sekunden lang 440 mal pro Sekunde vibriert.
   • In einer lauten Umgebung musst du eventuell den Hub nahe zum Ohr halten, dass du den Ton auch gut hören kannst.
2. Drücke [enter], um das Programm nochmals mit anderen Eingaben laufen zu lassen.
3. Probiere auch andere Frequenzen.

Ein Programm zur Simulation einer Verkehrsampel schreiben.

Lernziele:

• Steuerung der COLOR LED zur Simulation einer Verkehrsampel mit nur einer Lampe
• Erzeugung einer Abfolge von Anweisungen mit genauen Zeitangaben

Deine Aufgabe ist, ein Programm zur Steuerung einer Verkehrsampel zu schreiben. Die Lampe wird durch die COLOR LED am TI-Innovator™ Hub simuliert.

Die COLOR LED soll von grün über gelb nach rot UND von rot über gelb wieder auf grün schalten. Die zeitliche Steuerung ist dir überlassen.

Dein Programm wird eine Anweisungsfolge beinhalten, die den Wechsel von ROT zu GRÜN und GELB und wieder zu ROT simuliert. Eine Folgenstruktur in einem Programm ist ein Paket von Anweisungen, die hintereinander vom Anfang bis zum Ende ohne Unterbrechung ausgeführt werden.

Verwende Text für eine Unterbrechung

Die Disp-Anweisung gibt eine Nachricht am HOME Screen des Rechners aus. Mit ihr kann man den Wert einer Variablen oder einen String ausgeben (z.B. Disp x). Aber die Programmausführung wird dabei nicht unterbrochen.

Die The Text-Anweisung im E/A-Menü öffnet einen Dialog-Box und wartet bis der Anwender entweder [enter] drückt oder auf die OK-Schaltfläche klickt. Dann wird das Programm weiter ausgeführt.

Einrichtung des Eröffnungsschirms

1. Beginne ein neues Programm und nenne es anwendung1.
2. Hole die Anweisung Text aus dem E/A-Menü.
3. Schreibe in Anführungszeichen die Nachricht “Verkehrsampel [enter] Drücke Enter…” wie rechts abgebildet.
   Funktioniert so nur bis Version 4.4. Ab Version 4.5 musst du eingeben “Verkehrsampel“&chr(10)&“Drücke Enter…”.
   (10 ist der ASCII-Code für LF = line feed = Zeilenvorschub.)

Setzen der Farben

Zuerst setzen wir die Farbe ROT, indem wir die RGB-Werte 255 0 0 senden.

Im Beispiel rechts verwenden wir die Wait-Anweisung, um dem Rechner zu sagen, dass er 5 Sekunden warten soll, bis er den nächsten Befehl zum TI-Innovator™ Hub schickt. Das rote Licht bleibt so lange an.

Deine Aufgabe ist es nun, weitere Anweisungen hinzuzufügen, um die LED grün, dann gelb und schließlich wieder rot aufleuchten zu lassen.

Aufgabe: Füge Töne (SOUNDs) hinzu, so dass eine blinde Person (natürlich nur ein Fußgänger) erkennen kann, welche Farbe die Ampel anzeigt.

In der ersten Übung zu Lektion2 wirst du die For…Endfor-Schleife im Rechner an Hand eines Programms erlernen, das die LED blinken lässt und gleichzeitig eine Information am Display gezeigt wird.

Lernziele:

• Die For…EndFor-Schleife kennenlernen
• Die LED blinken lassen
• Die Disp-Anweisung für Text und Variable verwenden

Wir wollen ein Programm schreiben, das die LED eine bestimmte Anzahl von Malen aufleuchten lässt. Mit weiteren Eingaben (oder Argumenten) lässt sich steuern wie lange wie das Licht ein- bzw. ausgeschaltet bleibt.

Dieses Programm stellt dir die For…EndFor-Schleife vor.

Der Beginn des Programms:

1. Beginne mit einem neuen Programm und nenne es licht2.
2. Füge eine Disp-Anweisung über das menu > E/A hinzu.
3. Schreibe zwischen die Anführungszeichen “Es blinkt!” wie abgebildet.
4. Füge eine Request-Anweisung über das menu > E/A hinzu.
5. Schreibe den Text „Wie oft?“ zwischen die Anführungszeichen wie abgebildet.
6. Füge ein Komma und die Variable n hinzu.

Hinzufügen der For-Schleife:

7. Füge die For -Struktur ein über menu >Steuerung > For…EndFor.
   • Beide Teile der Konstruktion - For , , und EndFor werden mit einer Leerzeile – für den Schleifenkörper - zwischen ihnen ins Programm eingefügt.
8. Ergänze die Anweisung mit i,1,n zwischen vorbereiteten Kommata.
   • Das bedeutet: „Für i von 1 bis n in Einerschritten.”

9. Drücke [enter] einige Mal im Schleifenkörper, um Leerzeilen zu erzeugen, die mit Text gefüllt werden.
   • Es macht nichts aus, wie viele Zeilen du erzeugst. Du kannst immer noch weitere Zeilen hinzufügen und leere Zeilen haben keinen Einfluss auf das Programm.
   • Die Anweisungen zwischen For und EndFor heißen gemeinsam „Schleifenkörper“. Dieser Teil des Programmcodes wird n mal durchlaufen. Das ist die Aufgabe der For-Schleife.

Wir wollen, dass die LED n mal EIN- und wieder AUS-geschaltet wird. Außerdem soll uns der Rechner zeigen, wie oft schon geblinkt worden ist.

So beginnen wir im Schleifenkörper mit Disp i. i ist die Schleifenvariable.

Jetzt folgen Anweisungen, die die LED auf ON und OFF stellen:

10. Füge Send “SET LIGHT aus dem Hub-Menü ein.
11. Setze das Wörtchen ON aus dem Hub > Settings-Menü dran (oder tippe es).
12. Aus dem Hub-Menü wird Wait (in Sekunden) angehängt. Damit wartet der Rechner bis er den nächsten Befehl senden darf.
    • In unserem Programm nehmen wir eine Sekunde. Du kannst andere Werte, auch Dezimalzahlen, verwenden.
13. Mit einer weiteren Send-Anweisung schalten wir die LED wieder OFF und verbinden dies mit noch einer Wait-Anweisung.
14. Speichere das Programm ([ctrl] [B]) und rufe das Programm im Calculator auf.

Beachte die Einrückungen im Programmcode. Das macht das Programm leichter lesbar und hat keinerlei Einfluss auf das Programm.

Hier kommt noch eine Aufgabe: Ergänze das Programm am Anfang (vor der For-Schleife) um weitere Anweisungen für die Eingabe der Zeitangaben für die beiden Wait-Anweisungen. Verwende dann diese Variablen anstelle der Zahlen in den Anweisungen.

Speichere das Programm und lasse es nochmals laufen. Beobachte das Blinken und die gleichzeitige Anzeige am Schirm des Rechners.

In der zweiten Übung dieser Lektion wirst du lernen, wie man die Intensität der drei Farben der COLOR LED am TI-Innovator™ Hub steuern kann.

Lernziele:

• Mit For-Schleifen alle drei Farbkanäle der COLOR LED steuern

Die Farbwerte für rot, grün und blau (von 0 bis 255), die an die COLOR LED geschickt werden, bestimmen die Helligkeit jeder Farbe. Dieses Programm demonstriert den Übergang zwischen den über 16 Millionen (256³) möglichen Farben, indem es die Farbwerte schrittweise verändert. Du wirst wieder einige For-Schleifen im Programm einsetzen.

Wir erzeugen ein Farbwechselprogramm

1. Beginne ein neues Programm und nenne es farbe02
2. Setze eine Disp-Anweisung mit einem Programmtitel wie rechts gezeigt.
3. Füge ein Request mit dem Text (in Anführungszeichen) „Dauer?“ hinzu.
4. Hänge ein Komma und die Variable d dran.
   • Diese Variable werden wir in der Wait-Anweisung verwenden: je kleiner die Dauer, desto schneller wird die jeweils nächste Anweisung im Programm ausgeführt werden.
5. Frage auch, wie rechts gezeigt, nach einer Schrittweite s, welche die Abarbeitung der For-Schleife ein wenig beschleunigt.

Beachte: Local i verhindert die Erzeugung der Variablen i im Problem (außerhalb des Programms). Das Symbol für einen Kommentar © erhält man über menu > Aktionen > Kommentar einfügen.

Unser Programm wird stufenweise (abhängig von den Variablen d und s) die Intensität für ROT erhöhen, dann GRÜN dazu mischen, weiters ROT wieder wegnehmen und anschließend die Intensität von BLAU erhöhen und GRÜN wieder wegnehmen. Dann wird ROT wieder zu BLAU gemischt. Abschließend wird zuerst BLAU und dann ROT wieder entfernt. Das ist ein ziemlich langes Programm. Du kannst es nach dem Einbau jeder For-Schleife testen.

Es erweist sich als nützlich, dass der Editor zu jedem For automatisch auch das zugehörige EndFor erzeugt. So kann man später nicht darauf vergessen, die Schleife zu schließen.

6. Füge nach den beiden Request-Anweisungen aus dem Steuerungsmenü eine For…EndFor Schleife an.

Vervollständigen der ersten Schleife

7. Komplettiere die For-Anweisung so, dass die Schleifenvariable i von 0 bis 255 mit der Schrittweite s läuft.
8. Füge Send “SET COLOR … aus dem Hub-Menü hinzu.
9. Verwende die eval( )-Funktion aus dem Hub-Menü, um mit der Variablen i den roten Farbkanal zu steuern. Setze die Kanäle für Grün und Blau auf 0.
10. Schließe die Anführungszeichen und die Klammern.
11. Schließe die Wait-Anweisung an die Send-Anweisung an. Verwende die Variable d aus der ersten Request-Anweisung.

12. Nach der ersten For-Schleife hilft eine Text-Anweisung mit einer kurzen Nachricht, das strahlende ROT der LED zu bewundern.

Es folgt die Schleife für das grüne Licht

Jetzt bilden wir eine neue For-Schleife um zusätzlich GRÜN auf die LED zu bringen. Wir wollen nur den GRÜN-Kanal ansprechen und die Farbe ROT unverändert lassen. Das können wir auf zwei Arten erreichen:

Send “SET COLOR 255 eval(i) 0”
(d.h., dass ROT immer voll eingeschaltet und BLAU ganz ausgeschaltet ist)

oder durch

Send “SET COLOR.GREEN eval(i)”

Die zweite Anweisung betrifft nur den Grünkanal und beeinflusst weder ROT noch BLAU. Für beide Varianten können wir wieder die Variable i der ersten For-Schleife verwenden.

In der Abbildung rechts arbeiten wir mit der ersten Methode.

1. Nimm die Wait-Anweisung im Schleifenkörper mit der Variablen d auf.
2. Füge die Text-Anweisung nach dem Ende der Schleife wieder hinzu, um die neue Farbe besser zu betrachten. Welche Farbe ist das jetzt?

Jetzt werden wir stufenweise den Rotanteil vermindern, so dass nur mehr GRÜN verbleibt.

Um in einer For-Schleife den Wert der Laufvariablen herabzusetzen, müssen wir mit dem größten Wert beginnen und mit einer negativen Schrittweite zum kleinesten Wert gelangen.

For i, 255, 0, -s

beginnt mit 255 und subtrahiert nach jedem Durchlauf s bis die Variable i kleiner als Null geworden ist. Achte darauf, dass du die [ ( - ) ] „Negativtaste“ und nicht die Subtraktionstaste ( [ - ]) nimmst. Das führt zu einem Fehler.

Wir wollen nur den roten Farbkanal verändern, daher verwenden wir COLOR.RED in der Send-Anweisung.

Der Rest der Schleife ist ähnlich zu den beiden, die wir schon gebildet haben. Im rechten Bild sind nur die Anweisungen ohne weitere Argumente zu sehen.

Kannst du diese Anweisungen vervollständigen? Wenn nicht, dann findest du die Information am Beginn des nächsten Absatzes.

Hier ist der komplette Abschnitt, der ROT schrittweise wegnimmt. Nach Durchlauf der Schleife solltest du ein leuchtendes GRÜN sehen:

3. Hänge nun eine Schleife dran, die BLAU hinzufügt.
4. Mit einer nächsten Schleife nimm GRÜN wieder weg.
5. Dann mische wieder ROT dazu.
   • Welche Farbe erkennst du am Ende dieser Schleifen?
6. Nimm BLAU wieder in einer Schleife weg.
7. In der letzten Schleife reduziere auch ROT wieder auf 0.
   • Welche Farbe zeigt die LED am Ende des Programms?
   • Was passiert, wenn alle Farbkanäle auf 0 stehen?

In der dritten Übung der zweiten Lektion wirst du vom Zusammenhang zwischen den Frequenzen der Notenskala in der Musik lernen. Du wirst ein Programm schreiben, mit dem du diese Noten spielen kannst, die die Musiker seit Jahrhunderten verwenden.

Lernziele:

• Die “Zwölfte Wurzel aus Zwei”-Beziehung in der Notenskala erklären
• Ein Programm schreiben, das eine Tonleiter abspielen lässt

Ein wenig Musiktheorie

Musiknoten werden durch die Frequenz eines vibrierenden Objekts wie z.B. eines Lautsprechers, eines Trommelfells oder einer Saite (Geige, Gitarre, Klavier) bestimmt. Die Noten einer Tonleiter haben einen besonderen mathematischen Zusammenhang. In einer Oktave gelangt man in 12 Schritten von einer Note zur selben Note in der nächsten Oktave. Hat eine Note die Frequenz F, dann hat die darauffolgende Note die Frequenz F x ¹²√2.

Wenn man eine Notenfrequenz 12 mal hintereinander mit ¹²√2 oder 2^1/12 (die zwölfte Wurzel aus 2) multipliziert, hat man die Ausgangsfrequenz genau verdoppelt. So hat die erste Note der nächsten Oktave hat die Frequenz F x (2^(1/12))¹² = 2 x F Wenn z. B. eine Note die Frequenz 440 Hz hat, dann hat die um eine Oktave höhere Note die Frequenz 880 Hz und die, um eine Oktave niedrigere die Frequenz 220 Hz.

Das menschliche Ohr neigt dazu, zwei Noten, die um eine Oktave getrennt sind wegen der nahe verwandten Obertöne als im Wesentlichen „gleich“ zu hören. Aus diesem Grund tragen im westlichen System der Musiknotation Noten, die jeweils eine Oktave voneinander entfernt sind, gleiche Bezeichnungen. Eine Note, die eine Oktave höher ist als ein C ist wieder ein C. Die Intervalle zwischen den Tönen werden „Halbtöne“ genannt.

In diesem Projekt werden wir das 2^1/12-Prinzip nutzen, um die 12 Töne einer Oktave zu erzeugen.

Das „eingestrichene C“ (c¹) hat die Frequenz 262,64 Hz. Eine Oktave darüber liegt das „zweigestrichen C“ (c²) mit 2 x 261,64 Hz = 523,28 Hz. Es gibt 12 Schritte (Halbtöne) zwischen diesen beiden Noten und jeder Schritt ist das 21/12 -fache der vorigen Note.

Rechts haben wir 261,64 in den Calculator eingegeben und mit 21/12 multipliziert.

Wir geben am Anfang [ans] vor (hier nicht zu sehen), da das Multiplikationszeichen eine Eingabe vor ihm benötigt. Dann genügt fortwährendes Drücken der [enter]-Taste und die Folge der Frequenzen wird erzeugt, wie daneben gezeigt.

Dieses Wiederholungsprinzip werden wir ins Programm übernehmen. Die zwölfte. Antwort der obigen Rechnung ist 523,28, genau das Doppelte des Anfangswerts.

Beginn des Programms:

1. Beginne mit einem neuen Programm. Nenne es ton2.
2. Füge Disp mit dem Text „Tonleiter“ zwischen Anführungszeichen an.
3. Weise der Variablen f die Ausgangsfrequenz 261,64 zu.
4. Diese Variable wird alle Töne in der Tonleiter repräsentieren.

Einführung der For-Schleife:

5. Setze fort mit einer For-Schleife, die von 1 bis 12 läuft (für die 12 Noten).
6. Fahre fort mit einer “SET SOUND-Anweisung aus dem Hub-Menü.
7. Ergänze mit eval( ) für die Variable f wie gezeigt.

Berechnung der Frequenzen:

8. Multipliziere f mit 2^1/12 und speichere das Ergebnis wieder unter f.
   f := f * 2^(1/12)
   Diese Anweisung berechnet die Frequenz der jeweils nächsthöheren Note auf der Tonleiter.
9. Speichere ([ctrl] [B]) und führe das Programm im Calculator aus.

Eine Programmverbesserung:

Versuche, den TIME-Parameter in die Send “SET SOUND-Anweisung einzubauen und vergiss nicht, eine entsprechende Wait-Anweisung vorzusehen, sodass jede Note bis zu ihrem Ende ausgespielt wird.

Wenn der TI-Innovator™ Hub einen neuen Befehl erhält, bevor der letzte ausgeführt wurde, dann wird das Gerät den neuen Befehl ausführen und den letzten nicht zu Ende bringen.

Du wirst den Zufallsgenerator des TI-Nspire™ CX verwenden und ein Stück „Computermusik komponieren”.

Lernziele:

• Mit einer For-Schleife die Zahl der Noten steuern
• Mit dem Zufallsgenerator zufällige Musiknoten erzeugen und spielen

Du hast die Aufgabe, ein Programm zu schreiben, das zuerst um die Anzahl zu spielenden Musiknote fragt und dann mit einer For-Schleife diese Zahl von „Zufallsnoten“ abspielt. Wenn die Note gespielt wird, soll die entsprechende Frequenz mittels einer Disp-Anweisung am Rechner angezeigt werden.

In dieser Anwendung werden wir die randInt()-Funktion des TI-Nspire™ CX verwenden, um eine zufällige Note auf der Tonleiter zu erzeugen.

1. Hole im Calculator randInt( ) über
   menu > Wahrscheinlichkeit > Zufallszahl > Ganzzahl.
   • Diese Funktion benötigt zwei (drei) Argumente.
2. Gib einen unteren und einen oberen Wert, durch ein Komma, ein und drücke [enter].
3. Gehe nur mit Pfeil-hoch zum vorigen Befehl, drücke · und führe ihn nochmals aus. Editiere die beiden Argumente und beobachte den erzeugten Funktionswert.

Du wirst diese randInt( )-Funktion mit der Formel für die Musiknoten kombinieren, um ein Programm zu erhalten, das eine Zufallsmelodie erzeugt, die auf der Beziehung zwischen den Noten beruht..

Der wichtige neue Teil des Programmcodes ist:

Wie du aus der Tabelle entnehmen kannst, ist die Frequenz der Note A in der ersten Oktave 55 Hz. Der Bereich 0 bis 59 für n kann die 60 Noten der Tabelle erzeugen. Beachte den Gebrauch von n in 2^(n/12), um die n^te Note von A1 weg zu definieren. Für n = 0 ergibt sich die Frequenz 55 Hz, da ja 2⁰ = 1.

In dieser Übung untersuchen wir den eingebauten Lichtsensor BRIGHTNESS und verwenden die Disp-Anweisung um die Messwerte des Sensors anzuzeigen.

Lernziele:

• Die Messwerte des BRIGHTNESS-Sensors ablesen
• Die While-Schleife kennen lernen

In den vorigen Übungen haben wir Befehle an den TI-Innovator™ Hub gesendet, die seine eingebauten Geräte (LIGHT, COLOR und SOUND) ansprechen.

Jetzt werden wir mit dem eingebauten Lichtsensor arbeiten und die Werte unseres Programms verwenden um einen „Helligkeitsmesser“ zu erzeugen. Dieser Sensor erzeugt Werte in Dezimalform zwischen 0 und 100.

Den Helligkeitswert vom TI-Innovator™ erhalten wir über ZWEI Anweisungen:

• Send “READ BRIGHTNESS”
• Get <Variable>

Der Beginn des Programms:

1. Beginne ein neues Programm mit dem Namen hell1.
2. In der Variablen b werden wir die BRIGHTNESS-(Helligkeits-)Werte speichern. Wir deklarieren b mit Local als lokale Variable. (Das ist optional).
3. Wähle menu > Hub > Send “READ… > BRIGHTNESS. Drücke [enter].

4. Wähle nun menu > Hub > Get.
5. Tippe den Variablennamen b (hier ohne Klammern).

Wie das funktioniert:

• READ BRIGHTNESS sagt dem TI-Innovator™ Hub, dass er den Helligkeitswert messen und diesen Wert in einem eingebauten Pufferspeicher speichern soll.
• Mit der Anweisung Get b holt man den Wert aus dem Pufferspeicher des TI-Innovator™ Hub und überträgt ihn auf die Variable b des TI-Nspire™ CX. Dazu kann jeder legale Variablenname verwendet werden.

Die While-Schleife:

Mit der While…EndWhile-Schleife (menu > Steuerung >) wird ein Block von Anweisungen so lange ausgeführt wie eine Bedingung wahr ist. Eine Bedingung ist ein logischer Ausdruck, der den Wert wahr oder falsch annehmen kann. Die Relationszeichen und die logischen Operatoren finden sich über die [ | ≠ ≤ → ] -Taste ([ctrl] [ = ]).

Die Relationszeichen sind =, ≠ <, >, ≤, and ≥. Die logischen Operatoren sind: and, or, not, and xor.

Damit können Bedingungen zusammengesetzt werden wie z.B.: x>0 and y>0.

Wir werden eine einfache While-Schleife verwenden, die anhält, sobald der Helligkeitswert kleiner als 1 ist. Für den Abbruch des Programms muss man dann nur den Sensor am Ende des TI-Innovator™ Hub mit der Hand abdecken.

Einbau der While-Schleife:

6. Füge vor der Send-Anweisung die beiden folgenden Anweisungen ein:
   
   • b:=2
   • While b>1 (mit [ctrl] [ = ] kommst du zum >-Zeichen)
     Diese Anweisungen initialisieren die Schleife. So lange als b>1 wahr ist, wird in der Schleife die Helligkeit über den Sensor gemessen. Sobald die Bedingung nicht erfüllt ist – also wenn kein Licht mehr auf den Sensor fällt, da er mit der Hand bedeckt wird – wird die Schleife und damit das Programm beendet.

Wenn du While…EndWhile über das Steuerungsmenü einfügst, dann wird das EndWhile in deinem Code an der falschen Stelle stehen!

Es gehört hinter die Get-Anweisung wie oben gezeigt. Du kannst sie aktivieren, ausschneiden ([ctrl] [X]) und an der richtigen Stelle einfügen ([ctrl] [V]), oder auch löschen und an der richtigen Stelle hinschreiben.

Das EndWhile der While-Schleife muss auch eingegeben werden. Füge das nach der Get-Anweisung als Ende der While-Schleife ein.

7. Füge die Disp-Anweisung nach dem Get aber vor dem EndWhile über menu > E/A > Disp ein.
8. Damit wird der Wert der Variablen b auf den Schirm des Calculators gebracht.

9. Speichere das Programm ([ctrl] [B]) und führe es im Calculator mit angeschlossenem TI-Innovator™ Hub.
   • Du solltest eine Folge von Werten im Calculator entstehen sehen, die sich abhängig von der Helligkeit, die am Sensor empfangen wird, ändert.
10. Um die Schleife (und damit auch das Programm) zu beenden, decke den Lichtsensor auf der Seite des TI-Innovator™ Hub zu, so dass der angezeigte Helligkeitswert unter 1 liegt.

In dieser Übung werden wir einen automatischen Lichtschalter entwickeln, der auf das Umgebungslicht reagiert. Das Licht wird ausgeschaltet, wenn es dunkel wird und wieder eingeschaltet wenn es hell wird.

Lernziele:

• READ BRIGHTNESS
• Eine While-Schleife verwenden
• If…Then…Else…End einsetzen, um die LED abhängig von der Helligkeit ein- oder auszuschalten

Wir werden ein Programm schreiben, das den BRIGHTNESS-Wert misst und ein Licht einschaltet, wenn es „dunkel“ wird. Bei steigender Raumbeleuchtung geht das Licht wieder aus. Genau so arbeiten viele automatische Lichtschalter und Nachtbeleuchtungen.

Unser Programm wird den Lichtsensor des TI-Innovator™ Hub auslesen und das eingebaute Licht einschalten (LIGHT ON), wenn die Helligkeit unter einen bestimmten Wert fällt und wieder ausschalten, wenn sie über diesem Wert ist.

Der Beginn des Programms:

1. Beginne mit einem neuen Programm und nenne es hell2.
2. Füge Disp mit dem Text „Auto-Licht“ in Anführungszeichen an
3. Gib der lokalen Variablen b den Anfangswert 2 mit b:=2.
4. Füge eine While…EndWhile-Schleife mit der Bedingung b>1 an. (Der Helligkeitswert liegt über „sehr niedrig“).

Zur Beendigung der Schleife und des Programms ist der Sensor abzudecken.

5. Trage in den Körper der While-Schleife Send “READ BRIGHTNESS” und Get b aus dem Hub-Menü ein, wie rechts gezeigt.
6. Schreibe noch Disp b dazu. Dann kannst du auch die Messwerte im Calculator ablesen.

If-Anweisungen

Unsere If-Anweisung wird zwei Anweisungsblöcke haben: einen für den Fall, dass die Bedingung wahr ist und einen für den anderen Fall.

Die Struktur dieser mehrzeiligen Anweisung ist:

If <Bedingung> Then
<mache dies, wenn Bedingung wahr (erfüllt) ist>
Else
<mache dies, wenn Bedingung falsch (nicht erfüllt) ist>
EndIf

Nun legen wir die Bedingung fest …

Der Helligkeitswert wird in der Variablen b gespeichert und liegt zwischen 0 und 100.

Was ist ein guter Wert für „dunkel“? Wir wählen 25, aber du kannst jeden Wert zwischen 0 und 100 wählen.

Du kannst das Programm verbessern, indem du diesen „Einschaltwert“ über eine Request-Anweisung ermittelst. Request aber muss vor der While-Schleife stehen.

Hole das ‘<’ (kleiner)-Zeichen über die [ctrl] [=] Tasten.

7. Dann schalte LIGHT ON oder OFF in den Then und Else-Teilen wie gezeigt.
8. Speichere mit [ctrl] [B] das Programm.
9. Verbinde den TI-Innovator™ Hub mit dem Rechner und starte das Programm.
10. Verändere das Licht, das auf den Sensor fällt und beobachte, wie sich das LIGHT (die rote LED am Hub) ein- und ausschaltet.

Es könnte hilfreich sein, die Anweisung Disp b nach dem Get b ins Programm aufzunehmen um den Wert von b im Calculator zu zeigen und zusätzliche Disp-Anweisungen in die Then und Else-Blöcke einzubauen, um anzuzeigen, ob die LED „ON” oder „OFF” ist.

Um den Schleifendurchlauf (und das Programm) zu beenden muss man den Sensor ganz abdecken, so dass der Messwert unter 1 fällt.

In dieser Übung werden wir mit den BRIGHTNESS-Werten die COLOR LED steuern.

Lernziele:

• Den Lichtsensor ablesen und entweder die Helligkeit der COLOR LED oder den Lautsprecherton steuern
• Mit Formeln die BRIGHTNESS-Werte in COLOR -Werte umwandeln

Wir werden ein Programm schreiben, das auf die Helligkeit im Raum reagiert. Je heller es im Raum ist, desto heller soll die rote LED leuchten. Der Trick besteht hier darin, die BRIGHTNESS- (Helligkeits-)Werte in entsprechende COLOR-(Farb-)Werte umzuwandeln.

BRIGHTNESS (Helligkeit) B reicht von 0 bis 100.
COLOR (Farbe) C (in allen drei Kanälen) variiert von 0 bis 255.
Wie können wir B-Werte in C-Werte konvertieren?

Der Beginn des Programms:

1. Beginne ein neues Programm und nenne es hell3.
2. Füge ein Disp, und den Text „HELL zu FARBE“ zwischen Anführungszeichen an.
3. Deklariere b und c als lokale Variable wie gezeigt.
4. Füge ein While…EndWhile-Schleife zum Ablesen der Helligkeit an mit: Send “READ BRIGHTNESS” und speichere die Variable mit Get b.

Die Umwandlung der Werte heben wir uns auf.

5. Verwende die Variable c, um den Farb-(COLOR-)Wert zu repräsentieren, den wir dann an alle drei Farbkanäle der COLOR LED senden. Der Umrechnungsfaktor ist 2,55, daher: c:=2.55*b.
6. Überprüfe diese Formel mit den beiden gegebenen Wertepaaren: für b=0 wird c=2.55*0=0; und für b=100 ergibt sich c=2.55*100=255.
7. Füge eine Send “SET COLOR-Anweisung vor dem End der Schleife ein. Diese Anweisung wird die Helligkeit der COLOR LED regeln.

8. Zum Abschluss vervollständige die SET COLOR-Anweisung mit dreimaligem eval(c) (je einmal für die drei Farbkanäle).
   • Wenn drei Farbkanäle den gleichen Wert haben, dann leuchtet die LED in Weiß und die Helligkeit der LED hängt von diesem Wert ab.
9. Schließe den TI-Innovator™ Hub an und führe das Programm aus.
10. Ändere Umgebungshelligkeit indem du den Sensor an verschiedene Gegenstände führst. Beobachte dabei die Intensität der LED am Hub.

Du möchtest vielleicht weitere Disp-Anweisungen ins Programm einbauen, um die Werte für b und c sichtbar zu machen.

Aber halt! Da stimmt etwas nicht! Es wäre doch sinnvoller, dass bei schwächer werdender Raumbeleuchtung die LED stärker aufleuchtet! Wie kannst Du die Wirkungsweise umkehren?

Eine weitere Herausforderung: Wie kann man das Programm so abändern, dass unterschiedliche Helligkeitswerte der Umgebung unterschiedliche Farben an der LED verursachen?

In dieser Anwendung wirst du ein Programm entwickeln, das dich die aus dem Lautsprecher kommenden Töne über den Lichtsensor steuern lässt, indem du die Hand über ihn bewegst – Handmusik.

Lernziele:

• Helligkeitswerte in Töne konvertieren
• Den „12. Wurzel aus 2“-Zusammenhang zwischen Musiknoten und Frequenzen wiederholen

Schreibe ein Programm, das die BRIGHTNESS des Lichtsensors abliest und einen Ton abhängig vom Helligkeitswert abspielt. Für diesen Ton gibt es zwei Möglichkeiten:

• Spiele eine Frequenz im hörbaren Bereich (etwa 100 Hz bis 1000 Hz).
• Spiele eine Musiknote (einen der harmonischen Töne, die auf einem Musikinstrument gespielt werden).

Bei der ersten Option wirst du nur etwas wie Geräusche oder Lärm erzeugen. Mit der anderen Option wird etwas wie Musik entstehen, aber die Mathematik dahinter ist etwas komplizierter.

Dieses Programm lässt den TI-Innovator™ Hub wie einen Theremin funktionieren.

Wir beginnen:

• Beginne ein neues Programm und nenne es anwendung3.
• Füge ein Disp, und den Text „Handmusik!“ zwischen Anführungszeichen an wie gezeigt.
• Füge ein While…EndWhile-Schleife zum Ablesen der Helligkeit an mit: Send “READ BRIGHTNESS” und speichere die Variable mit Get b.
• Hänge die Anweisung zum Abspielen eines Tons dran.
• Wir verwenden die Variable b für den Helligkeitswert (BRIGHTNESS) und die Variable f für den Ton (SOUND).

Es ist nun deine Aufgabe, den Teil, der den Helligkeitswert in einen hörbaren Ton oder in eine Musiknote umwandelt, einzufügen.

Nimm für den Ton eine Frequenz zwischen 100 Hz und 1000 Hz (oder einen anderen Bereich deiner Wahl).

Für Musiknoten wähle für den Bereich den Startwert A1 (55 Hz) und gehe 50 Noten weiter. (Beziehe dich auf das Programm ton2 in Lektion 2, Übung 3, das 12 Noten einer Oktave abspielen lässt.)

Für die Musiknoten musst du deinen Wert in eine ganze Zahl umwandeln, so dass die „Notennummer“ richtig ausgedrückt wird. Dazu kannst du entweder die int( )-Funktion oder die round( ,0)-Funktion verwenden.

In der ersten Übung dieser Lektion wirst du lernen, wie du im Programmeditor ein Programm schreibst, das den Rover in Bewegung setzt.

Lernziele:

• Den TI-Nspire CX Programm Editor verwenden
• Die Rover- (RV-) Untermenüs ansprechen
• Mit dem Send-Befehl den TI-Innovator Rover mit dem TI-Innovator™ Hub verbinden (CONNECT)
• Den TI-Innovator Rover vorwärts, rückwärts, nach links und nach rechts bewegen

Für den Start:

• Die Rover-Befehle finden wir über menu > Hub > Rover (RV).
• Einige Teile des endgültigen Befehls wie numerische Werte und optionale Parameter müssen über die Tastatur oder andere RV-Menüs eingegeben werden.
• Die meisten Rover-Befehle lassen den Cursor innerhalb der Anführungs-zeichen. Das zeigt an, dass es weitere Optionen zum Befehl gibt. Der TI-Nspire™ CX verlangt die Anführungszeichen immer paarweise.

Deine erste Rover-Anweisung stellt die Verbindung zwischen dem TI-Innovator™ Hub und dem Rover her (RV ist die Bezeichnung für den Rover):

Send “CONNECT RV”

Dazu gehe folgendermaßen vor:

1. Drücke die menu-Taste und wähle das HUB-Menü.
2. Wähle dann das Rover (RV)-Untermenü.
3. Wähle die Anweisung Send “CONNECT RV” im unteren Teil des Menüs.

Nun folgt die Text-Anweisung über menu > E/A. Damit hält das Programm an und wartet bis der Anwender die enter-Taste drückt.

4. Drücke die menu-Taste und wähle das E/A-Menü.
5. Wähle die Option Text.

6. Füge nach der Text-Anweisung eine passende Meldung ein:
   Text “Zum Start drücke enter!”

Wenn das Programm gestartet wird und du hörst vor (oder auch während) der Anzei-ge der Meldung einen Piepston, dann bedeutet das, dass CONNECT RV nicht erfolgreich ausgeführt werden konnte. Überprüfe, ob der Rover eingeschaltet ist.

Den Rover lenken

7. Drücke enter nach der Text-Anweisung, um den nächsten Befehl anzufügen, der den Rover vorwärts bewegen lässt.
8. Drücke menu > Hub > Rover (RV) und wähle das Drive RV-Menü wie rechts gezeigt wird.

9. Wähle aus diesem Menü die Option FORWARD.

Beachte, dass die so eingefügte FORWARD-Anweisung die Schreibmarke innerhalb der Anführungszeichen mit einer vorangestellten Leerstelle anzeigt. Da können optionale Parameter hinzugefügt werden.

10. Wir hängen die Zahl 1 an. Damit ergibt sich:
    Send “RV FORWARD 1”

11. Drücke nun im Programmeditor Strg+R (im Untermenü Syntax überprüfen & speichern). Damit wird das Programm auf syntaktische Richtigkeit überprüft und der Programmaufruf in die Eingabezeile der Calculator-App übertragen. Weitere benötigte Argumente können eingetragen werden. Mit enter wird das Programm gestartet. Vor dem Rover sollten ca. 30cm freier Platz vorhanden sein.

Die Text-Anweisung zeigt die Meldung und wenn enter ein weiteres Mal gedrückt wird, sollte sich der Rover vorwärts bewegen. Aber wie weit? Beobachte sorgfältig die Bewegung und stelle fest, was FORWARD 1 bedeutet.

Der Calculator zeigt ‘Fertig’ wenn das Programm endet. Beachte, dass diese Anzeige noch während der Bewegung des Rovers erscheint, da Rechner und TI-Innovator™ Hub mit unterschiedlichen Geschwindigkeiten arbeiten.

Rückwärts fahren

12. Editiere das Programm und füge die Anweisung Send “RV BACKWARD 1” unter der FORWARD-Anweisung über menu > Hub > Rover > Drive RV > BACKWARD ein.
13. Hänge die Zahl 1 an die Zeichenkette an.

14. Lass das Programm nochmals laufen (Strg+R).

Jetzt sollte sich der Rover ein Stück nach vor und dann wieder zurück in seine Ausgangsposition bewegen. Glückwunsch, wenn das auch so passiert! Du hast den Rover in Bewegung gebracht.

Seitwärts wenden

Die beiden nächsten Anweisungen im Drive RV-Menü sind LEFT und RIGHT.

15. Erweitere dein Programm um diese beiden Befehle und starte es nochmals.
    Send “RV LEFT ”
    Send “RV RIGHT ”

Was bewirken diese Anweisungen?

Wir schicken den Rover auf die Reise

Studiere das rechts stehende Programm und überlege, wie sich der Rover bewegen wird, und wo er sich bei Programmende befinden wird.

16. Ergänze dein Programm um diese Anweisungen und führe es aus.

Erfüllt der Rover deine Erwartungen? Kannst du ein Programm für den Rover mit nur diesen Anweisungen schreiben, so dass er sich längs eines Rechtecks bewegt?

In dieser Übung wirst du einige der optionalen Möglichkeiten untersuchen, wie der Rover gesteuert werden kann. Alle vier Steuerkommandos aus Übung 1 lassen hinter der Anweisung innerhalb der Anführungszeichen eine Leerstelle, nach der zusätzliche Optionen eingefügt werden können. Hier werden diese besprochen.

Lernziele:

• Die Lenkmöglichkeiten des Rovers erweitern
• Die Optionen RIGHT und LEFT einsetzen

Parameter für FORWARD und BACKWARD

Für diese Steueranweisungen gibt es drei optionale Parameter:

• SPEED
• TIME
• DISTANCE

Sie befinden sich im menu > Hub > Rover (RV) > RV Settings (teilweise rechts abgebildet). Die Geschwindigkeit (UNIT/S und M/S) kann auch in diesem Menü festgelegt werden.

Anwendung von DISTANCE, SPEED und TIME

Einige Beispiele von verschiedenen Implementationen der FORWARD-Anweisung:

• FORWARD DISTANCE # ist dasselbe wie FORWARD #
• FORWARD DISTANCE # M bewegt den Rover # Meter
• FORWARD # SPEED # mit einer Geschwindigkeit zwischen 1.4 und 2.3.
  • Werte außerhalb führen zu einem TI-Innovator™ Hub-Fehler.
• FORWARD TIME #

Du kannst beliebige zwei dieser drei Optionen in der FORWARD- und BACKWARD-Anweisung angeben.

Du kannst auch eval() verwenden, wenn der gewünschte Wert in einer Variablen im Rechner gespeichert ist, oder er das Ergebnis einer Rechnung ist.

Ein SPEED und TIME Programm

1. Das rechts gezeigte Programm hat eine Anweisung, die den Rover eine bestimmte Zeit (TIME) mit der Geschwindigkeit (SPEED) vorwärts (FORWARD) bewegt: Send “RV FORWARD SPEED 2.3 TIME 2”
2. Vervollständige das Programm mit der richtigen Zeit (TIME), so dass der Rover zu seiner Ausgangsposition zurückkehrt:
   Send “RV BACKWARD SPEED 1.4 TIME ?”

Hilfe: Weg = Zeit * Geschwindigkeit (DISTANCE = SPEED * TIME)

Parameter für RIGHT und LEFT

Diese Anweisungen lassen den Rover um 90° nach rechts oder links drehen. Du kannst aber jeden Winkel (zwischen -360° und +360°) anfügen. Auch negative Werte sind zugelassen. Daher ergibt LEFT -90 die gleiche Drehung wie RIGHT 90.

3. Füge die Anweisung hinzu, die den Rover um 135° nach rechts dreht. Dazu musst du 135 in die Zeichenkette hineinschreiben. Das Wort DEGREES ist nicht notwendig, ist aber in den RV Settings zur Deutlichkeit verfügbar.

Du kannst Winkel in RADIANS (Bogenmaß) oder GRADS (Neugrad) angeben. Diese Einheiten findest du auch im RV Settings-Menü (müssen angegeben werden).

Einige Beispiele stehen rechts. In welche Richtung schaut der Rover nach der Ausführung dieser drei Anweisungen?

Schreibe ein Programm, das den Rover längs eines gleichseitigen Dreiecks bewegt.

Beginne mit:
    Send “CONNECT RV”
    Send “RV FORWARD ?”
    Send “RV LEFT ?”

Oder, verwende eine Schleife.

In der dritten Übung dieser Lektion wirst du lernen, wie man den Rover in eine bestimmte Richtung dreht, wie man den zeitlichen Ablauf steuert und wie man mit der COLOR LED-am Rover arbeitet.

Lernziele:

• Die TO ANGLE-Anweisung verwenden
• Die RV.COLOR LED am Rover einsetzen
• Den zeitlichen Ablauf am Rechner und am Rover kontrollieren

Diese Übung spricht drei weitere Möglichkeiten des Arbeitens mit dem Rover an:

• Einsatz der TO ANGLE-Anweisung (die sich von LEFT und RIGHT unterscheidet)
• Einschalten der RV.COLOR LED am Rover (bezeichnet mit ‘Color’ an der linken oberen Ecke neben der Anzeige der Batterieladung)
• Synchronisierung des Programms mit den Bewegungen des Rovers mit Wait

TO ANGLE

Die Anweisung Send “RV TO ANGLE <Zahl>” wird verwendet, um den Rover in eine bestimmte Richtung zu drehen. Wenn du mit einem Befehl zum Rover verbindest, dann ist seine Richtung auf 0° eingestellt. Das ist in der „Mathematikwelt” in Richtung Osten (positive Richtung der x-Achse). Nord, West und Süd sind in dieser „Welt” 90°, 180° und 270°. Vergleiche mit dem rechts abgebildeten Diagramm.

Unabhängig von seiner momentanen Richtung bringt die Anweisung Send “RV TO ANGLE 0” den Rover wieder in seine Ausgangsrichtung, die er beim Start mit “CONNECT RV” eingenommen hat.

Das Standardmaß für den Winkel ist DEGREES, aber du kannst es auf RADIANS oder GRADS (auszuwählen über das RV Settings-Menü) abändern.

Versuche dies:

    Send “RV TO ANGLE 90”
    Wait 2
    Send “RV TO ANGLE 180”
    Wait 2
    Send “RV TO ANGLE 270”
    Wait 2
    Send “RV TO ANGLE 360”

Hat sich der Rover so verhalten, wie du es erwartet hast?

Synchronisierung des Programms mit dem Rover

Programme am Rechner sind schon “fertig”, wenn sich der Rover noch bewegt. Das rührt daher, dass die Steuerkommandos im TI-Innovator™ Hub schneller gespeichert werden als sie der Rover ausführen kann. Die Steuerkommandos werden in einer „Warteschlange“ gereiht und ausgeführt sobald der Rover dazu bereit ist.

Jetzt werden wir ein Programm schreiben, das den Rover auf einem Zufallsweg bewegt und dabei die RV.COLOR LED aufleuchten lässt. Wir werden auch die TO ANGLE-Anweisung gemeinsam mit eval() verwenden, um den Rover in die entsprechenden Richtungen zu drehen.

Der Beginn des Programms:

1. Starte das Programm mit CONNECT RV.
2. Fahre fort mit einer For-Schleife (menu > Control > For…EndFor), um das Zufallsmuster für den Weg des Rovers zu erzeugen. In der Schleife kannst du immer weitere benötigte Zeilen hinzufügen. (Hier werden h und i als lokale Variable eingeführt, um den Speicher „sauber“ zu halten.)

3. Schreibe FORWARD in den Schleifenkörper für eine Vorwärtsbewegung.
   Send “RV FORWARD 1”
4. Um dem Rover eine Zufallsrichtung zu geben, nimm die Anweisung:
   h:=randInt(0,360)
5. Füge eine TO ANGLE-Anweisung an, um in die Richtung h zu drehen:
   Send “RV TO ANGLE eval(h)”
6. Starte nun das Programm und du wirst sehen, dass
   • sich der Rover in einem Zufallsmuster (Irrweg) bewegt,
   • und das Programm fast sofort beendet ist, sich der Rover aber weiterhin bewegt.

RV.COLOR

Da die Farb-LED des TI-Innovator™ Hub im Rover verborgen ist, haben wir eine andere Farb-LED am Dach des Rovers angebracht. Der Name dieser LED ist RV.COLOR und sie wird wie die LED am TI-InnovatorTM Hub gesteuert. Du kannst jede der vier Anweisungen aus dem menu > Hub > Rover(RV) > RV Color verwenden, das rechts gezeigt wird.

Send “SET RV.COLOR 255 255 255” erzeugt weißes Licht.

Einbau von RV.COLOR in dein Programm

7. Setze die RV.COLOR-Anweisung an den Beginn der Schleife unmittelbar vor die FORWARD 1-Anweisung. Die Farbwerte sind dir überlassen.
8. Starte das Programm nochmals und beobachte, was geschieht. Beachte, dass die LED fast unmittelbar aufleuchtet und weiter leuchtet.

Wir wollen versuchen, dass die LED nur während der Vorwärtsfahrt des Rovers aufleuchtet. Dazu müssen wir den Rechner immer warten (Wait) lassen, bis eine Wegstrecke erledigt ist und dann während der Wendung die LED ausschalten.

Wir müssen eine Wait-Anweisung zur Steuerung des Ein- und Ausschaltens der LED einfügen.

9. Wie lange braucht der Rover für FORWARD 1? Etwa eine Sekunde? Schreibe Wait 1 nach der FORWARD 1-Anweisung ins Programm. Du kannst den Wert anpassen, wenn er in Deiner Umgebung nicht passt. Denk daran, dass du Wait im menu > Hub Menü findest.
10. Führe das Programm aus und teste es.

Beachte, dass die LED eingeschaltet bleibt. Wir müssen sie noch ausschalten, sobald der Rover seine Fahrt beendet hat.

11. Wie lange braucht der Rover für eine Wendung? Etwa eine Sekunde? Füge eine weitere Wait 1-Anweisung hinzu.
12. Nach der Wait 1-Anweisung kannst du die LED abschalten, indem du den Befehl Send “SET RV.COLOR 0 0 0” anfügst.
13. Teste dein Programm. Hat sich das Licht zur richtigen Zeit ausgeschaltet?

Wir müssen auch warten während sich der Rover in eine neue Richtung dreht, um sicher zu sein, dass das Licht ausgeschaltet ist.

14. Schreibe ein Wait hinter die TO ANGLE-Anweisung. Dieses Wait sollte lange genug dauern, um jede Drehung zwischen 0 und 360 Grad zu ermöglichen.

Erweiterung

Kannst Du an jeder Ecke eine andere Farbe leuchten lassen? Tipp: Verwende eval(frei gewählt) und berücksichtige diesen Wert für h, beachte aber den dafür zulässigen Wertebereich.

Eine zusätzliche Herausforderung:

Definiere die Wartezeit für die Drehung als eine Funktion des Drehwinkels, der in der TO ANGLE-Anweisung festgelegt wird.

In der Anwendung dieser Lektion wird der Rover so programmiert, dass er seinen Weg längs eines Polygons nimmt. Der Anwender gibt die Seitenlänge des Polygons (in „Rovereinheiten”) und die Zahl der Ecken ein

Lernziele:

• Eingabe von Daten
• Anwendung von eval() in Anweisungen für den Rover
• Die Grundlagen eines Polygons verstehen
• Mit Farben (COLOR) und Zeitkontrolle (Wait) arbeiten

Erinnere dich daran, dass der Zweck von eval() darin liegt, den Wert einer Rechnervariablen oder eines Ausdrucks in eine Zeichenkette zu konvertieren und so zum TI-Innovator™ Hub zu senden. Im rechts abgebildeten Tonprogramm wird die Variable freq verwendet. Die Funktion eval(freq) wandelt diese Zahl in eine Zeichenkette um, die der TI-Innovator™ Hub verarbeiten kann.

Schreibe ein Programm, das nach der Anzahl der Ecken und der Seitenlänge eines Polygons abfragt und dann den Rover dieses Polygon abfahren lässt. Du kannst am Rover einen Stift anbringen und das Polygon auf Papier zeichnen lassen. Eine Einheit entspricht 10 cm!

Optional: Lass die COLOR LED in den Ecken des Polygons aufleuchten.

Einige hilfreiche Anweisungen:
    Request “Länge einer Seite?”,s
    Request “Anzahl der Ecken?”,n
    For i,1,n
    Send “RV FORWARD eval(s)”
    Send “RV RIGHT <something>”
    EndFor

In dieser ersten Übung von Lektion 5 wirst du etwas über den Ultraschallsensor des Rovers und das Vermögen, damit seine Bewegung zu kontrollieren, erfahren.

Lernziele:

• Die READ RV.RANGER-Anweisung zur Entfernungsmessung verwenden
• Mit dieser Anweisung die Bewegung des Rovers ändern

An der Front des TI-Innovator™ Rover befindet sich der Ultrasonic (Ultraschall) Ranger. Er misst die Entfernung eines Objekts von der Front des Rovers. Damit lässt sich die Bewegung des Rovers kontrollieren. Der Rover kann so programmiert werden, dass er einem Objekt ausweicht und einen Zusammenstoß vermeidet.

Zuerst schreiben wir ein Programm um zu sehen, wie der Ranger arbeitet. Dann nützen wir in Übung2 diese Information, um die Fahrt des Rovers zu kontrollieren.

Das Programm liest der Wert des Rangers und zeigt ihn am Schirm des Rechners an. Dabei wird der Rover nicht fahren. Du wirst deine Hand vor dem Rover bewegen, oder ihn in der Hand halten und ihn gegen verschiedene Gegenstände richten, und dabei die sich ändernden Abstände beobachten.

Starte das Test Programm

1. Beginne mit Send “CONNECT RV” aus dem menu > Hub > Rover (RV)-Menü.

Die Hauptschleife

Wir werden das Programm mit einer While-Schleife steuern. Sobald die Entfernung kleiner als ein bestimmter Wert wird, soll das Programm enden. Dazu verwenden wir die Variable entf, um die gemessene Entfernung aufzuzeichnen.

2. Setze den Anfangswert der Variablen entf auf 1 (entf:=1).
3. Wähle While…EndWhile aus dem menu > Steuerung-Menü. Bleibe solange in der While-Schleife wie entf größer als 0,1 ist.

Der Schleifenkörper

4. Die Anweisung READ RV.RANGER findet sich in
   menu > Hub > Rover (RV) > Read RV Sensors.
5. Wähle daraus Send “READ RV.RANGER”.

6. Füge die folgenden Anweisungen:
       Get dist
       Wait 0.25
   1n den Schleifenkörper ein.

Um einen Wert vom Sensor zu erhalten sind zwei Anweisungen notwendig: zuerst Send “READ RV…” um den Wert vom Sensor zum TI-InnovatorTM Hub und dann Get, um ihn weiter in den Rechner zu übertragen. Die Anweisung Wait 0.25 verlangsamt die Operation, dass die Werte leichter gelesen und verstanden werden können.

Anzeige des Werts

7. Wähle DispAt aus dem menu > E/A-Menü. Diese Anweisung zeigt den Wert der Variablen entf an einer festen Position in der Calculator App des Rechners an.
8. Die DispAt-Anweisung verlangt (zumindest) zwei Argumente: eine Zeilennummer von 1 bis 8 und eine Variable oder einen Wert, der angezeigt werden soll. Für eine Anzeige weiter in der Schirmmitte kannst du an die Variable, bzw. den Wert Leerstellen anfügen wie z.B. DispAt 1, entf, “          “.

Programmdurchführung

9. Speichere und starte das Programm mit ctrl+R. Während das Programm läuft wird im Calculator eine Zahl angezeigt. Bewege deine Hand vor dem Rover (oder bewege den Rover) so, dass der Ranger verschiedene Entfernungen messen kann. In welchen Einheiten werden die Entfernungen gemessen? Wann endet das Programm?
   
   Antwort: Die Einheit ist Meter, und das Programm bricht ab, sobald die Entfernung 10 cm oder kleiner wird.

In der ersten Übung dieser Lektion hast du den Ranger des Rovers getestet, um zu sehen, wie man den Sensor einsetzt und einen Wert anzeigen lässt. Jetzt werden wir diesen Test weiterführen, indem wir die Fahrt des Rovers kontrollieren.

Lernziele:

• Die READ RV.RANGER-Anweisung verwenden, um die Entfernung von einem Hindernis festzustellen
• Die Fahrt des Rovers steuern, wenn er zu nahe an ein Hindernis gerät
• Den zeitlichen Ablauf der Roverfahrt im Rahmen des Programms steuern

Wir wollen en Programm schreiben, das den Rover zwischen zwei Wänden nach vorwärts und rückwärts fahren lässt. Wir beginnen mit der Vorwärtsbewegung (FORWARD), lesen den Sensor des Rangers ab, und sobald der Rover zu nahe an die Wand gerät, bleibt der Rover stehen, kehrt um und bewegt sich wieder nach (FORWARD).

Das ist die große Idee:

Beginne eine For-Schleife (die am Ende der Fahrt verlassen wird)
    Starte mit der Vorwärtsbewegung des Rovers (FORWARD)
    Solange der Abstand größer ist als etwa 25 cm
        beobachte weiterhin den Sensor des Rangers
    Verlasse die While-Schleife
    STOP, drehe den Rover um 180° nach rechts
Beende die For-Schleife

1. Beginne das Programm in der üblichen Weise.
2. Füge eine For-Schleife ein, die zehn Mal durchlaufen wird.
3. Fahre fort mit der FORWARD 100 UNITS-Anweisung für eine Vorwärtsbewegung um 10 Meter (100 * 0,1m pro Einheit).

Wie in der vorigen Übung verwenden wir die Variable entf, um die Entfernung des Rovers vom Hindernis zu messen.

4. Setze entf auf 1 und füge eine While entf > 0.25-Schleife an.

Beachte die beiden End-Anweisungen im Programm: ein EndFor und ein EndWhile. Das wird als eine „geschachtelte Schleife“ bezeichnet.

5. Dann schreiben wir den Programmcode in den Körper der While-Schleife.
6. Zuerst die Anweisung Send “READ RV.RANGER”
7. Und dann die Get-Anweisung, um den Wert in der Variablen entf zu speichern.

Damit ist die While-Schleife vollständig. Der Rover bewegt sich 10 m vorwärts und die While-Schleife überwacht den Abstand. Wenn gewünscht, kannst du mit einer DispAt-Anweisung in der Schleife den aktuellen Abstand anzeigen lassen, um sicher zu gehen, dass alles richtig abläuft.

Wenn die While-Schleife endet, dann bedeutet dies, dass der Rover dem Hindernis zu nahe gekommen ist. Wir sagen STOP mit der Vorwärtsbewegung und lassen ihn umkehren. Wir müssen aber nicht wieder befehlen, vorwärts zu fahren.

8. Nach dem End While aber noch vor dem End For, werden die RV STOP- und die RV RIGHT 180-Anweisung eingefügt.
9. Nimm die Wait 2-Anweisung und gib damit dem Rover ausreichend Zeit für das Umkehren, bevor er sich wieder nach vorwärts bewegt. (Erinnere dich, dass die FORWARD-Anweisung schon am Beginn der For-Schleife steht.)
10. Teste nun dein Programm. Wenn der Rover nahe beim Hindernis angelangt ist, soll er umkehren und in die Gegenrichtung fahren. Passe allfällig die Werte für den Minimalabstand und Wait an deine Fahrunterlage an. Wenn der Rover zu nahe an die Wand gerät, könnte sein Heck beim Umdrehen an die Wand stoßen.

In der dritten Übung dieser Lektion stellen wir den COLORINPUT-Sensor vor und zeigen wie er für einen Richtungswechsel des Rovers eingesetzt werden kann.

Lernziele:

• READ COLORINPUT kennen lernen
• Über den Farbwert die Richtung des Rovers ändern

Der Rover hat einen Farberkennungssensor am Boden. Das auf den Boden leuchtende Licht dient ihm zum besseren „Sehen“. Wir werden ein Programm schreiben, das den Rover bei jedem Farbwechsel die Richtung ändern lässt. Die vom Sensor „gesehene“ Farbe wird durch den TI-InnovatorTM Hub in einen von neun möglichen Farbwerten umgewandelt.

1 = Rot
2 = Grün
3 = Blau
4 = Cyan (Blaugrün)
5 = Magenta (Violett, Purpur)
6 = Gelb
7 = Schwarz
8 = Weiß
9 = Grau

1. Beginne das Programm auf die schon bekannte Weise.

2. Wir werden über eine For-Schleife den Rover viermal fahren und wenden lassen.

3. Bevor wir in einer While-Schleife auf einen Farbwechsel achten, müssen wir wissen, welche Farbe der Rover zu Beginn „sieht“. Wir lesen diesen Farbwert über READ RV.COLORINPUT ein und übertragen ihn mit Get in die Variable boden_farbe des Rechners.

4. Dann initialisieren wir eine neue Variable, farbe, mit der die While-Schleife starten soll. Sie hält die Farbe, die der Rover während seiner Fahrt sieht. farbe wird zu Beginn mit boden_farbe belegt. Dann bewegt sich der Rover nach vorwärts.

5. Wir programmieren die While-Schleife um farbe mit boden_farbe zu vergleichen, denn wir achten in der Schleife auf einen Wechsel des Werts für farbe.
6. Vergiss nicht auf die EndWhile-Anweisung am Ende der While-Schleife.

7. In der While-Schleife überwachen wir den Farbsensor solange sich der Rover bewegt. Den Farbwert speichern wir in der Variablen farbe. Die Schleife wird verlassen, sobald farbe (die aktuelle Farbe) sich von boden_farbe (der ursprünglichen Farbe) unterscheidet.

8. Am Ende der While-Schleife befehlen wir dem Rover anzuhalten und sich nach rechts zu drehen. Beachte, dass beide Anweisungen zwischen EndWhile und Endfor stehen. So veranlasst das Programm, dass sich der Rover viermal nach rechts dreht, wenn er einen Farbwechsel in der Bodenfarbe entdeckt.

Bemerkung: “RV STOP” bricht alle Fahrkommandos ab.

9. Füge eine FORWARD 1- und eine Wait 1-Anweisung hinzu, damit sich der Rover aus dem farbigen Bereich wegbewegt, bevor er über die Schleife die ursprüngliche Farbe (boden_farbe) wieder aufnimmt.
10. Teste dein Programm auf einem Untergrund mit gleichmäßiger Farbe (weiß). Lege einen etwa 5x5 cm großen Fleck in einer Kontrastfarbe (schwarz) auf den Weg des Rovers, sodass der COLORINPUT-Sensor ihn erkennen muss. Wenn der Rover über den Fleck fährt sollte er stehen bleiben, wenden und weiterfahren. Nimm den Farbfleck und lege ihn wieder in den Weg des Rovers. Das sollte viermal möglich sein bevor das Programm endet.

In der Anwendung zur Lektion 5 wirst du ein Programm schreiben, das den Rover längs eines Weges auf einem Blatt Papier führt.

Lernziele:

• COLORINPUT verwenden, um einen Weg auf einem Blatt Papier zu erkennen und diesem zu folgen
• Nimm einen Beispielpfad auf Papier (siehe auch die pdf-Datei der Testseiten)

Schreibe ein Programm, das den Rover dank des Farbsensors einen kurvigen Weg auf einem Blatt Papier fahren lässt. Der Weg wird durch zwei unterschiedliche Farben beschrieben, wie etwa so:

Der Rover wird am linken Seitenrand starten und längs des gekrümmten Weges zum rechten Rand fahren. Wenn der Rover ROT sieht, wird er sich ein Stückchen nach links drehen und nach vorne fahren bis er wieder WEISZ sieht, sich dann ein Stückchen nach rechts drehen und ein kleines Wegstück nach vor fahren usw.

Experimentiere mit dem Drehwinkel und der Fahrstrecke um zu sehen, wie der Rover auf die unterschiedlichen Farben reagiert. Wenn deine Unterlage wie in der Abbildung rot und weiß ist, kannst du READ COLORINPUT.RED einsetzen, dass du die Werte auf jeder Seite sehen kannst. Bei einer anderen Farbe, wie z.B. Schwarz, kannst Du READ COLORINPUT.GRAY (oder .GREEN oder .BLUE) nehmen.

Hier ist ein Programm farbtest(), das du zum Testen des Farbsensors des Rovers verwenden kannst. Beachte, welche Werte du in deinem Programm verwendest:

Define farbtest()=
Prgm
Send "CONNECT RV"
While getKey(0)=" "
    DispAt 1,"Ende mit beliebiger Taste."
    Send "READ RV.COLORINPUT.RED"
    Get r
    DispAt 2,"Farbwert: ", r
EndWhile
EndPrgm

Beachte, dass sich der Rover in diesem Programm nicht bewegt. Verwende es, um festzustellen, was der Rover an jeder Seite der Kurve „sieht“, indem du die angezeigten Werte für r abliest. Nütze diese Information für dein Programm und teste es dann. Setz den Rover mit dem Farbsensor nahe der Grenzlinie an den linken Seitenrand. Versichere dich, dass der Farbsensor über dem Papier liegt. Das Programm sollte unabhängig von der Ausgangsposition des Rovers funktionieren.