TI Coding mit TI-84 Plus CE-T und TI-Innovator™ Hub

In dieser ersten Einheit von Lektion 1 soll der Programm-Editor verwendet werden, um ein Programm zu schreiben, das eine Lichtquelle auf dem TI-Innovator™ Hub steuert.

Lernziele:

• Verwendung des TI-84 Plus CE-T Programm-Editors.
• Nutzung des Befehls Send(, um eine Lichtquelle auf dem TI-Innovator™ Hub anzusteuern.
• Einführung in den Befehl Wait.
• Einsatz von Verweilzeiten auf dem TI-Innovator™ Hub und auf dem Taschenrechner.

Sobald man den TI-Innovator™ Hub mit dem TI-84 Plus CE-T verbindet, schaltet sich der Taschenrechner ein. Auf dem TI-Innovator™ Hub leuchtet eine grüne LED auf und zeigt an, dass der TI-Innovator™ Hub betriebsbereit ist.

Schreibt man ein Programm auf dem Taschenrechner, so kopiert man mit der Taste [prgm] Befehle in das Programm. Die Hub - Befehle stehen in einem besonderen HUB-Menü ganz rechts in der Kopfzeile. Sie bilden einen besonderen Bereich innerhalb der übrigen Befehle des TI-Basic. Mit dem Befehl Send( aus dem HUB-Menü werden Befehle an den TI-Innovator™ Hub gesendet, die eine physikalische Reaktion hervorrufen wie z.B. das Aufleuchten einer LED, die Erzeugung eines Tones, das Anlaufen eines Motors, usw.

“Mein erstes Programm” soll den TI-Innovator™ Hub veranlassen für 5 s das rote LIGHT (LED) einzuschalten.

Ein neues Programm wird angelegt, indem die Taste [prgm] gedrückt und anschließend in der Kopfzeile NEU gewählt wird. Dann muss man einen Namen eingeben (im Beispiel LICHT1) und auf [enter] drücken.

Das Programm enthält nur eine Befehlszeile:

Send(“SET LIGHT ON TIME 5”)

LIGHT ist die Bezeichnung der roten LED.

Diese Befehlszeile erhält man, indem man

1. die Taste [prgm] drückt und das HUB – Menü auswählt
2. dann 1:Send(“SET… auswählt
3. und im anschließenden Menü LIGHT auswählt.

Das Programm sieht nun so aus wie rechts abgebildet. Die Befehlszeile muss noch vervollständigt werden:

     Send(“SET LIGHT ON TIME 5”)

Die Worte ON und TIME erhält man auch über das Menü HUB:

1. man muss die Taste [prgm] drücken und das Menü HUB auswählen und
2. 3:Settings wählen.

Die Anführungszeichen ([alpha] [+] ) und die Klammer am Ende des Befehls dürfen nicht vergessen werden. Das Leerzeichen erhält man über [alpha] 0.

Das nunmehr vollständige Programm ist rechts abgebildet.

Der Befehl Send( ) schickt den durch die Anführungszeichen begrenzten String an den TI-Innovator™ Hub, wenn das Programm gestartet wird.

Die Programmausführung:

1. Der Editor wird verlassen durch die Taste [quit] (2^nd [MODE]).
2. Man drückt nun [prgm] und wählt den Programmnamen aus dem Menü AUSFÜRG. Dadurch wird der Name auf den Startbildschirm übertragen.
3. Der TI-Innovator™ Hub muss mit dem Taschenrechner verbunden sein.
4. Die Taste [enter] startet das Programm.

Ist der Befehl richtig geschrieben, so wird die rote LED für 5 s aufleuchten. Bei einem Fehler hingegen blitzt die rote LED einmal auf und ein kurzer Ton ist zu hören.

Ist das Programm beendet, so erscheint „Done“ auf dem Display. Das Programm endet, noch bevor die rote LED erlischt!

Soll das Programm ebenso lange laufen wie die LED leuchtet, so muss man einen weiteren Befehl hinzufügen. Dazu muss das Programm editiert werden:

1. Man drückt [prgm] und wählt BEARBEITEN.
2. Man wählt den Programmnamen aus der Liste.
3. Man scrollt mit dem Steuerkreuz zum Ende des Programmes.
4. Mit [enter] wird eine neue Zeile hinzugefügt.
5. Der Befehl Wait 5 wird hinzugefügt, indem man [prgm] drückt und aus dem HUB-Menü 4:Wait auswählt und schließlich noch 5 hinzufügt.

Um das Programm erneut laufen zu lassen, muss der Editor verlassen werden. Wenn das Programm die letzte Aktion auf dem Startbildschirm war, so kann über [enter] der Neustart durchgeführt werden. Das Programm endet nun genau dann, wenn die LED erlischt.

Man kann den Zusatz TIME im Befehl Send( weglassen und stattdessen den Befehl Wait verwenden. Allerdings muss man jetzt die LED noch ausschalten:

     Send(“SET LIGHT OFF”)

Aufgabe: Die Befehlsfolge im Bild rechts soll so fortgesetzt werden, dass man ein Blinklicht erhält!

In der zweiten Einheit von Lektion 1 geht es um Programmeingaben und die Steuerung der COLOR LED auf dem TI-Innovator™ Hub.

Lernziele:

• Verwendung der Befehle Prompt und Input.
• Steuerung der COLOR LED.

Die COLOR LED (light emitting diode) hat die drei Farb”kanäle” rot, grün und blau und wird deshalb oft auch als “RGB LED” bezeichnet.

Um eine bestimmte Farbe zu erzeugen, muss man die drei Farben im richtigen Verhältnis miteinander mischen.

In diesem Programm soll mit der COLOR LED experimentiert werden. Es werden numerische Werte für die drei Farben in das Programm eingegeben, um die LED in der gewünschten Farbe leuchten zu lassen.

Dabeig wird der erste Programmierbefehl verwendet, der eine Eingabe durch den Benutzer ermöglicht, während das Programm läuft: Prompt.

Der Befehl Prompt erlaubt dem Benutzer für eine Variable einen Wert im laufenden Programm einzugeben. Er heißt Prompt, weil er eine Anzeige erzeugt (der Name der Variablen, gefolgt von einem Fragezeichen) sobald er ausgeführt wird. Als Antwort wird vom Benutzer ein Wert für die Variable eingegeben.

Befehlssyntax:

• Prompt <Variable>
• Prompt <Variable1>,<Variable2>,<Variable3>,…

Im TI-84 Plus CE-T sind als numerische Variablen die Buchstaben A..Z und Ɵ (Theta) erlaubt. Dezimale oder komplexe Zahlen können auf ihnen abgespeichert werden.

In diesem Programm wird Prompt verwendet, um für die Farben rot, grün und blau numerische Werte (0-255) einzugeben und sie zur COLOR LED zu senden. Dabei wird für die drei Werte nur ein Prompt-Befehl verwendet.

Nun zum Programm.

1. Über die Taste [prgm] und dann New wird ein neues Programm angelegt (hier FARBE1). Nach Drücken von enter gelangt man in den Editiermodus.
2. Der Befehl ClrHome wird hinzugefügt, indem man ihn über [prgm] und das Menü E/A und 8: ClrHome auswählt.
3. Wieder über [prgm] und E/A wird 2: Prompt hinzugefügt.
4. Die Variable R (rot) wird mit der Tastenfolge [ALPHA] [×] hinzugefügt.
5. Auf gleiche Weise werden die Variablen für grün (G) und blau (B) hinzugefügt, jeweils getrennt durch ein Komma.

Der Befehl Send( wird verwendet, um den TI-Innovator™ Hub zu programmieren.

1. Über die Taste [prgm] wird das HUB – Menü ausgewählt, dann der Befehl
2. 1:Send(“SET… und anschließend COLOR.

Bemerkung:

Man kann nicht die Variablennamen R, G und B als Farbvariablen im Befehl Send( verwenden, den es würden nur die Buchstaben R, G und B gesendet werden, nicht ihre Werte. Man benötigt zusätzlich die spezielle Funktion eval( ), die den Wert eines Ausdrucks im Taschenrechner in eine Zeichenkette (einen String) umwandelt, die der TI-Innovator™ Hub verarbeiten kann.

Nun kann das Programm vervollständigt werden:

1. Die Funktion eval( wird hinzugefügt, indem man die Taste [prgm] drückt, ins HUB Menü wechselt und dort eval( auswählt.
2. Die Funktion wird vervollständigt durch den Buchstaben R und die rechte Klammer.
3. Mit [ALPHA][0] wird ein Leerzeichen eingefügt.
4. Für G und B müssen diese Schritte wiederholt werden. Dabei die Leerzeichen nicht vergessen!

5. Der Send( - Befehl wird vervollständigt durch Anführungszeichen und rechte Klammer.

So sieht der vollständige Befehl aus:

Send(“SET COLOR eval(R) eval(G) eval(B)”)

Ausführen des Programmes:

1. Über [2nd][MODE] ([QUIT]) gelangt man zum Startbildschirm.
2. Über die Taste [PRGM] und das Menü EXEC, wird das Programm FARBE1 ausgewählt.
3. Mit [ENTER] wird das Programm gestartet.
4. Man erhält nacheinander drei Prompts auf dem sonst leeren Bildschirm, eines für R, eines für G und eines für B.
5. Für jede Variable kann eine Zahl zwischen 0 und 255 eingegeben werden.
6. Nachdem der dritte Wert eingegeben wurde, wird von der COLOR LED auf dem TI-Innovator™ Hub die entsprechende Farbe angezeigt.
7. Um andere Werte auszuprobieren, kann man über [ENTER] das Programm neu starten und drei neue Werte eingeben.

In der dritten Einheit von Lektion 1 wird die andere Möglichkeit der Eingabe von Werten in ein laufendes Programm erklärt und angewendet ebenso wie die Steuerung des SOUND auf dem TI-Innovator™ Hub.

Inhalte:

• Verwendung des Befehls Input.
• Steuerung von Frequenz und Betriebszeit des eingebauten Lautsprechers (SOUND).

Der Befehl Input befindet sich wie der Befehl Prompt im Menü [PRGM] E/A. Er wird verwendet, damit der Benutzer wie bei Prompt eine Eingabe während des laufenden Programmes machen kann, aber er enthält noch die Möglichkeit, zusätzlich einen beliebigen Text auf dem Display anzuzeigen.

Befehlssyntax: Input <Zeichenkette>,<Variable>

Im Programm TON1 wird der Befehl Input genutzt.

Das Programm TON1:

1. Zunächst wird ein neues Programm mit dem Namen TON1 angelegt.
2. Die Befehle ClrHome and Input werden aus dem Menü [prgm] E/A eingefügt.
3. Dann fügt man über [A-LOCK] ([2nd][ALPHA]) die Zeichenkette “FREQUENZ?” hinter den Befehl Input ein.
4. Um das Komma einzugeben, muss [A-LOCK] wieder ausgeschaltet werden, indem man einfach die Taste [alpha] drückt.
5. Hinter dem Komma wird die Variable F für die Frequenz eingegeben.
6. Über einen weiteren Input-Befehl wird die Dauer D des Tones eingegeben.

Wie im Programm FARBE1 des vorherigen Abschnittes benötigt man noch die Funktion eval( ), um die nummerischen Werte der Variablen F und D zu übertragen.

Weiter im Programm

1. Über die Taste [PRGM] gelangt man wieder ins Menü HUB.
2. Dort wählt man 1: Send(“SET… und dann 6:SOUND aus.
3. Die Funktion eval( erhält man durch Drücken von [PRGM] im Menü HUB.
4. Die Eingabe wird vervollständigt durch die Variable F, gefolgt von einer rechten Klammer.
5. Nach Einfügen eines Leerzeichens ([ALPHA][0]) wird die Funktion eval( für die Variable D hinzugefügt, wieder gefolgt von einer rechten Klammer.
6. Anführungszeichen und eine rechte Klammer vervollständigen den Befehl Send(.

Ausführung des Programmes:

Nach dem Start kann man z.B. für die Frequenz 440 (Hz) und für die Tondauer 5 (s) eingeben. Dadurch wird der Ton 440 Hz für 5 s erzeugt; der Lautsprecher vibriert also 440 mal die Sekunde für 5 Sekunden.

Sollte das Umgebungsgeräusch sehr laut sein, muss man den TI-Innovator Hub u.U. dicht ans Ohr halten, um den Ton zu hören.

Mit [ENTER] kann man das Programm neu starten, um andere Frequenzen und Zeiten auszuprobieren.

Es soll ein Programm geschrieben werden, das eine Verkehrsampel simuliert.

Lernziele:

• Die COLOR LED verwenden, um eine Verkehrs- ampel mit nur einer Lichtquelle zu simulieren.
• Durch geeignete Befehle eine realistische Schaltfolge simulieren.

Die Aufgabe besteht darin, ein Programm zu schreiben, das unter Verwendung der COLOR LED auf dem TI-Innovator™ Hub eine Verkehrsampel simuliert.

Die COLOR LED soll von grün auf gelb und auf rot umschalten und wieder zurück von rot über gelb auf grün. Die jeweiligen Schaltzeiten sollen selbstständig festgelegt werden.

Das Programm wird eine Folge von Befehlen enthalten, die den Wechsel von RED zu GREEN zu YELLOW zu RED simulieren. Eine solche Steuerung wird in einem Programm durch eine Folge von Befehlen abgebildet, die nacheinander ohne Unterbrechung von Anfang bis Ende abgearbeitet werden.

Verwendung von Disp und Pause

Der Befehl Disp erzeugt eine Anzeige auf dem Home-Bildschirm des Taschen-rechners. Er kann genutzt werden, um wie in Disp X den Wert einer Variablen anzuzeigen oder einen Text (string) wie im mittleren Bild. Man findet den Befehl Disp, indem man [PRGM] drückt und im Menü E/A 3:Disp wählt.

Auch der Befehl Pause erzeugt eine Anzeige, aber er unterbricht gleichzeitig die weitere Ausführung des Programmes, bis der Benutzer die Taste [ENTER] drückt. Pause findet man, indem man [PRGM] drückt und in STRG 8:Pause wählt.

Programmierung des Begrüßungsbildschirmes:

1. Das neue Programm benötigt einen Namen, z.B. AMPEL..
2. Der Befehl ClrHome wird über [PRGM] E/A hinzugefügt.
3. Ebenso wird der Befehl Disp wie oben beschrieben hinzugefügt.
4. Es folgen die Anführungszeichen und der Titel des Programmes.
5. Nun wird der Befehl Pause wie oben beschrieben hinzugefügt.
6. Jetzt fehlt nur noch der Text „WEITER MIT ENTER“ wie dargestellt.

Einstellung der Farben

Aus dem Menü HU wählt man 1:Send(“SET… , dann 2:COLOR. Die Zeile wird wie abgebildet vervollständigt, und man erhält die Farbe rot, da für rot die RGB-Werte 255,0,0 sind.

Der Befehl Wait aus dem Menü HU bewirkt, dass der Taschenrechner in diesem Fall 5 s wartet bis zur Ausführung des nächsten Befehls. Das rote Licht leuchtet also 5 s lang.

Aufgabe: Das Programm soll um die weiteren Farbwechsel wie oben beschrieben ergänzt werden.

In der ersten Einheit von Lektion 2 wird die For – Schleife in einem Programm verwendet, das eine LED blinken lässt und gleichzeitig Text auf dem Display des Taschenrechners anzeigt.

Lernziele:

• Anwendung der For – Schleife.
• Programmierung eines Blinklichtes.
• Verwendung des Befehls Disp zur Anzeige von Text und Variablen.

Es soll nun ein Programm entwickelt werden, das eine LED eine gewisse Zeit lang blinken lässt. Diese Zeitspanne soll durch eine Eingabe steuerbar sein.

Mit diesem Programm wird die For…End – Schleife eingeführt.

Erste Programmschritte:

1. Ein neues Programm wird gestartet und mit LICHT2 bezeichnet.
2. Über die Taste [PRGM] wird ClrHome hinzugefügt, indem man das Menü E/A auswählt und 8:ClrHome anklickt.
3. Auf gleichem Wege wird 3:Disp hinzugefügt.
4. Dahinter kommt in Anführungsstrichen die Überschrift BLINKLICHT.
5. Jetzt wird wieder auf gleichem Wege 1:Input hinzugefügt.
6. Dahinter kommt in Anführungsstrichen WIE OFT? wie dargestellt.
7. Das Komma und die Variable N vervollständigen den Input.

Hinzufügen der For - Schleife:

1. Man drückt [PRGM] und wählt 4:For( im Menü STRG.
2. Dann fügt man die Argumente I,1,N) hinzu. Der Befehl bedeutet nun: “For I gehe von 1 bis N in Einserschritten”.

3. Durch mehrfaches Drücken von e werden ein paar Leerzeilen eingefügt, die später gefüllt werden.
4. Zum Schluss wird noch der Befehl End hinzugefügt.

Die Gruppe von Befehlen zwischen For und End nennt man den „Schleifenkörper“. Dieser Abschnitt des gesamten Programmes ist es, der genau Nmal in der For – Schleife ausgeführt wird.

Um eine Leerzeile in ein Programm einzufügen, bewegt man den Cursor an das Ende einer Zeile und drückt dann [ins]([2nd][del]) und [enter] . Es spielt keine Rolle, wie viele Leerzeilen man zunächst einfügt, denn man kann jederzeit weitere Leerzeilen einfügen. Überzählige Leerzeilen haben keinen Einfluss auf die Ausführung des Programmes.

Die LED soll Nmal an- und wieder ausgehen. Außerdem soll auf dem Taschenrechner die Anzahl der Zyklen angezeigt werden.

Der erste Befehl im Schleifenkörper ist Disp I, die Anzeige der Schleifenvariablen.

Nun folgen die Befehle, mit denen die LED an- und wieder ausgeschaltet wird:

1. Send(“SET LIGHT aus dem [prgm] HUB Menü wird hinzugefügt.
2. Dann das Wort ON aus dem [prgm] HUB SETTINGS Menü.
3. Mit Anführungszeichen und der rechten Klammer wird der Befehl abgeschlossen.
4. Wait (in Sekunden) aus dem [prgm] HUB Menü wird hinzugefügt, damit der Taschenrechner wartet, bevor der nächste Befehl ausgeführt wird.
   • Im Beispielprogramm wird 1 s gewartet, aber man kann auch andere Werte verwenden, auch Dezimalzahlen.
5. Nun kann man den Editor verlassen, das Programm starten und das rhythmische Blinken beobachten.

Statt der fest eingestellten Werte lässt sich der Blinkrhythmus auch durch eine Eingabe steuern:

Aufgabe: Es sollen Input – Befehle am Anfang des Programmes (vor dem Befehl For() eingefügt werden, so dass man die Zeit für die zwei Wait-Befehle eingeben kann anstelle der festen Zahlen im ursprünglichen Programm.

Welche Werte sind sinnvoll, um so eine Art Stroboskop zu erhalten?

In dieser zweiten Einheit von Lektion 2 wird ein Programm entwickelt, mit dem man die Intensität der drei Farben der COLOR LED auf dem TI-Innovator™ Hub steuern kann.

Lernziele:

• Verwendung von For-Schleifen, um die drei Farbkanäle der COLOR LED zu steuern.

Die Werte für rot, grün und blau (von 0 bis 255), die an die COLOR LED gesendet werden, bestimmen die Helligkeit jedes Farbkanals, so dass durch Mischung über 16 Millionen (256³) Farben entstehen. Das Programm demonstriert einige der Farben durch die allmähliche Veränderung einer Farbe bei Beibehaltung der übrigen. Dabei werden mehrere For – Schleifen verwendet.

Das Farbwechsel-Programm – erste Programmzeilen:

1. Das neue Programm bekommt den Namen FARBE2.
2. ClrHome und Disp mit dem Programmtitel werden wie abgebildet hinzugefügt.
3. Ebenso Input mit dem Text WARTEN? in Anführungszeichen, dem Komma und der Variablen W.
   • W wird für den Befehl Wait benötigt. Je kleiner W, desto kürzer ist die Zeit, bis der nächste Befehl ausgeführt wird, desto schneller ist der Farbwechsel.
4. Auch für die Schrittweite STEP der For – Schleife wird eine Variable S angelegt, um den Programmablauf etwas beschleunigen zu können.

Das Programm wird allmählich (abhängig von W und S) die Intensität von rot ansteigen lassen. Dann wird ebenso allmählich grün hinzugefügt und anschließend rot wieder gedimmt. Dann kommt blau hinzu, grün wird gedimmt, rot kommt hinzu, blau wird gedimmt und zum Schluss wird auch noch rot gedimmt. Das ist ein langes Programm, aber man kann es nach jeder vollständigen Schleife ausprobieren bevor man weiter programmiert.

Vervollständigung der ersten Schleife:

1. Der Befehl For( erhält die Schleifenvariable I, den Bereich von 0 bis 255 und die Schrittweite S.
2. Der Befehl Send(“SET COLOR aus dem [prgm] HUB Menü wird hinzugefügt.
3. Die Funktion eval( aus dem [prgm] HUB Menü muss auf I angewendet werden, und die Farbkanäle für Grün und blau werden auf 0 gesetzt.
4. Anführungszeichen und Klammer rechts vervollständigen den Befehl.
5. Der Befehl Wait W schließt sich noch an.

Nach dem Ende der ersten For – Schleife kann man das Programm mit dem Befehl Pause anhalten, während die LED sehr hell rot leuchtet (s. Abbildung rechts).

Jetzt soll mit einer zweiten For – Schleife grün hinzugefügt werden. Allerdings soll nur der grüne Farbkanal gesteuert werden, nicht der rote. Das kann man auf zwei Arten erreichen:

     Send(SET COLOR 255 eval(I) 0”)

     (denn wir wissen, dass RED angeschaltet ist und BLUE ausgeschaltet)

oder

     Send(“SET COLOR.GREEN eval(I)”)

Dieser zweite Befehl steuert nur den grünen Kanal und hat keinen Einfluss auf rot und blau. In beiden Fällen können wir jedoch wieder auf die Schleifenvariable I aus der ersten For – Schleife zurückgreifen:

Wie man in der Abbildung rechts sehen kann, wurde die zweite Variante Send(“SET COLOR.GREEN eval(I)”) gewählt.

Die Befehle Wait und Pause werden wie oben wieder hinzugefügt.

Nun kann man das Programm erneut laufen lassen.

Welche Farbe ist am Ende des Programmes zu sehen?

Nun soll die Intensität von rot wieder abnehmen, so dass zum Schluss nur noch grün übrigbleibt. Um etwas allmählich geringer werden zu lassen, setzt man den Anfangswert der For – Schleife auf den größten Wert, den Endwert auf den kleinsten und die Schrittweite wird negativ:

     For(I, 255, 0, -S)

 beginnt bei 255 und subtrahiert S bei jedem Schleifendurchlauf bis die Schleifenvariable I kleiner als 0 ist. Bei der Eingabe muss man darauf achten, dass man die “negativ”-Taste [(-)] benutzt, da sonst ein Fehler auftreten würde.

Da nur der Kanal rot geändert werden soll, wird der Befehl COLOR.RED im Befehl Send verwendet. Der Rest der Schleife sieht so aus wie die beiden vorhergehenden.

Das rechte Bild zeigt nur die Schlüsselwörter, die noch zu den vollständigen Befehlen ergänzt werden müssen. Lösung auf der nächsten Seite …

So sieht der vollständige Programmteil aus, in dem die Intensität von rot langsam verringert wird. Am Ende der Schleife leuchtet nur noch grün mit maximaler Intensität.

Das Programm ist noch nicht fertig; hier die fehlenden Teile und Aufgaben:

1. Mit einer Schleife soll blau hinzugefügt werden.
2. Dann soll mit einer weiteren Schleife grün entfernt werden.
3. Nun soll wieder rot hinzugefügt werden.
4. Welche Farbe sieht man jetzt?
5. Jetzt wird blau wieder entfernt
6. und zum Schluss auch rot.
7. Welche Farbe sieht man nun?
8. Was passiert, wenn alle drei Farbkanäle den Wert 0 haben?

In der dritten Einheit von Lektion 2 geht es um die Beziehung zwischen den Frequenzen der Tonleiter. Dazu wird ein Programm geschrieben, dass die Noten über den Lautsprecher abspielt, die Musiker schon seit vielen Jahrhunderten benutzen.

Lernziele:

• Erklärung der ¹²√2 - Beziehung
• Entwurf eines Programmes, das nacheinander die Noten der Tonleiter abspielt.

 

Etwas Musiktheorie

Musiknoten sind bestimmt durch die Frequenz eines vibrierenden Objektes, z.B. einer Saite bei einer Gitarre oder einem Klavier, eines Fells bei einer Trommel aber auch der Membran eines Lautsprechers. Die Noten stehen dabei in einer besonderen mathematischen Beziehung. Eine Oktave umfasst 12 Töne. Hat ein Ton die Frequenz f, so hat der darauf folgende Ton die Frequenz f·¹²√2 , der dann folgende die Frequenz f·¹²√2 ·¹²√2 = f·(¹²√2)². Nach genau 12 Tönen hat sich die Frequenz also genau verdoppelt, denn

f·(¹²√2)¹² = f·(2^1/12)¹² = f·2

Gehört zu einer Note z.B. die Frequenz 440 Hz, so zu der Note eine Oktave höher 880 Hz und eine Oktave tiefer 220 Hz. Den Abstand zwischen 2 benachbarten Tönen bezeichnet man als Halbton.

Das menschliche Ohr tendiert dazu zwei Noten, die eine Oktave voneinander entfernt sind, wegen des ähnlichen Klanges als im wesentlichen “gleich” anzusehen. Deshalb gibt man in der westlichen Notation den Noten, die eine Oktave voneinander entfernt sind, dieselbe Bezeichnung. Das C eine Oktave höher heißt also auch C. Dazu kommen noch Hochkommata um die Oktaven zu kennzeichnen.

Im Programm wird die 21/12 – Beziehung ausgenutzt, um die 12 Töne einer Oktave zu erzeugen.

C” hat die Frequenz 261,64Hz. Eine Oktave darüber, also C”’, wäre die Frequenz 2·261,64 Hz = 523,28 Hz. Zwischen diesen beiden Noten gibt es 12 Schritte (Halbtöne), wobei jedes mal die Folgefrequenz das 2^1/12 fache der vorhergehenden Note ist.

Im Bild ist gut zu sehen, dass zunächst 261,64 im Startbildschirm eingegeben wurde. In der nächsten Zeile wird dieser Wert dann mit 2^1/12 multipliziert.

Der Taschenrechner ergänzt die Zeile automatisch mit Antw am Anfang, da bei der Multiplikation erwartet wird, dass am Anfang irgendetwas eingegeben wurde. Drückt man nun wiederholt [ENTER] so erhält man die dargestellte Folge der Antworten.

Nach diesem Prinzip soll auch das Programm aufgebaut werden. Die zwölfte Antwort wird dann 523,28 lauten, denn: 261,64·(2^1/12)¹² = 2·261,64 = 523,28.

Die ersten Programmzeilen:

1. Ein neues Programm mit dem Namen TON2 wird erzeugt.
2. Die Befehle ClrHome und Disp werden eingefügt mit dem Anzeigetext in Anführungszeichen wie auf dem nebenstehenden Bild.
3. Mit der Taste [STO→] wird die Anfangsfrequenz 261,64 der Variablen F zugewiesen.
4. Diese Variable nimmt später nacheinander die 12 Frequenzen der Tonleiter an.

Die For - Schleife:

1. Eine For( - Schleife von 1 bis 12 für die 12 Noten wird hinzugefügt.
2. Aus dem Menü HUB wird der Befehl Send( “SET SOUND hinzugefügt.
3. Dazu kommt noch eval( ür die Variable F wie dargestellt. Auf die Anführungszeichen und Klammern achten!

Berechnung der Frequenzen:

1. F wird mit 2^1/12 multipliziert und das Ergebnis wird wieder in F gespeichert:
   F*2^(1/12)→F
   
   • Durch diesen Befehl wird der aktuelle Wert der Frequenz F in die Frequenz des nächst höheren Tones der Tonleiter verändert.
2. Nach Verlassen des Editors kann das Programm gestartet werden..

Veränderung des Programmes:

Man kann den Parameter TIME dem Befehl SEND( “ SET SOUND noch hinzufügen, wobei man auch noch den passenden Befehl Wait in das Programm einfügen muss, damit das Programm jede Note auch zu Ende spielen lässt.

Wenn der TI-Innovator™ Hub einen neuen Befehl erhält bevor er den letzten abgearbeitet hat, führt er den neuen Befehl aus anstatt den alten zu beenden.

Der Zufallszahlengenerator des TI-84 Plus CE-T wird verwendet, um Computer- “Musik” zu erzeugen.

Lernziele:

• Eine For( - Schleife wird verwendet, um die Anzahl der Noten zu steuern.
• Der Zufallszahlengenerator wird verwendet, um zufällige Musiknoten zu erzeugen.

Die Aufgabe besteht darin, das Programm so zu vervollständigen, das zunächst nach der Anzahl der zu erzeugenden Noten gefragt wird. Dann sollen mit der For( - Schleife diese Noten abgespielt werden, die zufällig erzeugt werden. Wenn eine Note gespielt wird, soll die Frequenz mittels Disp auf dem Display angezeigt werden.

In dieser Anwendung wird die Funktion zufInt( ) des TI-84 Plus CE-T verwendet.

1. Man findet die Funktion zufInt( ausgehend vom Startbildschirm im Menü math>WAHRS. Die Funktion benötigt zwei (oder drei) Argumente, aber es gibt beim Aufrufen im Menü eine Eingabemaske.
2. Man muss einen unteren und einen oberen Wert eingeben, wodurch der Bereich der Zufallszahlen eingeschränkt wird. n: wird leer gelassen. Es wird benötigt, wenn man eine Liste von n Zahlen erzeugen möchte.
3. Mit Einfg wird die Funktion auf den Startbildschirm kopiert und mit [enter] ausgeführt.
4. Scrollt man mit den Pfeiltasten nach oben und drückt wiederum [enter], so kann man die beiden Grenzwerte editieren und die Funktion erneut ausführen.

Kombiniert man die Funktion zufInt( ) mit der Formel für die Noten, so erhält man eine Formel, mit der zufällige Noten auf der Basis der Beziehung 2^1/12 erzeugt werden. Der wichtigste Teil des Programmcodes ist:

 

Wie man der Tabelle entnehmen kann, hat die Note a der ersten Oktave die Frequenz 55 Hz. Mit dem Bereich 0 bis 59 können insgesamt die Frequenzen zu 60 Noten von 5 Oktaven gebildet werden. N wird in der Formel 2^(N/12) verwendet, um die Nte Note ausgehend von a zu bilden. Ist N = 0, so ist die Frequenz 55 Hz, denn 2⁰ = 1.

In der ersten Stunde der Lektion 3 wird der eingebaute Lichtsensor (HELLIGKEIT) untersucht und der Befehl Output( des TI-Basic eingeführt, um eine Technik zu zeigen, mit der man Zahlen verschiedener Länge sehr wirkungsvoll auf dem Display darstellen kann.

Lernziele:

• Auslesen des Helligkeit-Sensors.
• Einführung der While – Schleife.
• Verwendung des Befehls Output(.
• Einführung des Befehls toString( und der Verkettung.

In den vorangegangenen Stunden wurden nur Befehle an den TI-Innovator™ Hub gesendet, die einen Einfluss auf die eingebauten Geräte LIGHT, COLOR und SOUND haben.

In dieser Lektion wird nun der eingebaute Lichtsensor verwendet, und die von ihm gelieferten Werte sollen verwendet werden, um die Helligkeit (in ungeeichten Werten) anzuzeigen. Der Lichtsensor liefert Werte im Bereich von 0 bis 100 in Form von Dezimalzahlen.

Man benötigt ZWEI Befehle, um den Lichtsensor auszulesen:

• Send(“READ BRIGHTNESS”)
• Get(B)

Erste Programmschritte:

1. Man legt ein neues Programm mit dem Namen HELL1 an.
2. Die Befehle ClrHome und Disp werden hinzugefügt, um die Überschrift wie abgebildet zu erzeugen.
3. Über die Taste [prgm] wird das Menü HUB ausgewählt.
4. Es wird erst 2: Send(“READ… und dann 1: BRIGHTNESS ausgewählt.
5. Erneutes Drücken von [prgm] und Wahl des Menüs HUB.
6. Auswahl von 5:Get( und Vervollständigung durch B).

Funktionsweise:

• READ BRIGHTNESS veranlasst den TI-Innovator™ Hub den Wert der Helligkeit zu lesen und in einem eingebauten “Buffer” (Puffer) zu speichern.
• Get(B) ist ein Befehl, mit dem der im Puffer auf dem TI-Innovator™ Hub gespeicherte Wert an den TI-84 Plus CE-T weitergegeben und in einer Variablen gespeichert wird. Zulässig sind die Variablennamen A..Z and Ɵ (Theta); im Beispiel hat die Variable den Namen B.

Die While - Schleife:

Die While…End - Schleife ([prgm] STRG Menü) wird verwendet, um eine Gruppe von Befehlen durchzuführen solange eine Bedingung wahr ist. Eine Bedingung ist ein logischer Ausdruck, der entweder wahr oder falsch ist. Im Menü test (2nd math) findet man die dazu notwendigen relationalen und logischen Operatoren:

• Die relationalen Operatoren sind =, ≠ <, >, ≤, and ≥.
• Die logischen Operatoren sind und, oder, xoder und nicht(.

Die Operatoren können verwendet werden, um z.B. Bedingungen wie x>0 und y>0 zu bilden.

Eine einfache While – Schleife wird im Programm verwendet. Sie bricht ab, sobald der Helligkeitswert kleiner als 1 ist. Man kann damit das Programm beenden, indem man einfach den Helligkeitssensor mit der Hand abdeckt.

Eine andere Möglichkeit, ein laufendes Programm abzubrechen, hat man, indem man die Taste ON drückt. Dann wird eine Fehlermeldung ausgegeben: Fehler: Abbruch mit den Optionen 1:Abbruch und zurück zum Startbildschirm oder 2:Gehezu der Anweisung im Programmeditor, wo die Taste ON das Programm beendet hat. Das ist ein bequemer Weg, um Fehler aufzuspüren und das Programm weiter zu editieren.

Hinzufügen von While – Schleife und Output(:

1. Vor dem Befehl Send( werden die folgenden zwei Befehle eingefügt:
   :2→B
   :While B>1    [ > aus dem Menü test ]
   • Solange die Bedingung B > 1 wahr ist, wird der Lichtsensor fortlaufend ausgelesen. Wird sie falsch, wenn nicht mehr genug Licht den Sensor trifft (etwa weil er durch eine Hand abgedeckt wird), bricht die Schleife ab und das Programm endet. Der erste Befehl weist B den definierten Wert 2 zu, um die Schleife zu starten.
2. Wie die For – Schleife benötigt auch die While - Schleife ein End, das hinter dem Befehl Get(B) eingefügt wird.

3. Unmittelbar nach dem Befehl Get( wird der Befehl Output( hinzugefügt, den man über die Taste [prgm] im Menü E/A bei 6: Output( findet.
   • Der Befehl Output( ermöglicht es genau festzulegen wo auf dem Display etwas angezeigt werden soll. Die Syntax ist:
   • Output(<Zeilennummer>, <Spaltennummer>, <Text oder Variable>)
   Beispiele:
   
   • Output(3,7,“HALLO”) setzt den Buchstaben “H” auf die Zeile 3 und Spalte 7 des Displays. Der Rest des Wortes folgt dem H.
   • Output(5,10,B) setzt den Wert der Variablen B so, dass die erste Ziffer in Zeile 5 Spalte 7 beginnt – der Rest folgt.

4. Nun kann man den Editor verlassen und das Programm starten.
   • Man sieht die Überschrift und einen Wert in der Mitte des Displays, der sich mit der Lichtintensität ändert, die der Sensor ausliest. Aber: die angezeigten Zahlen müssen nicht richtig sein!

Der Befehl Output( löscht keine nachfolgenden Zeichen, wenn eine kürzere Zahl dargestellt wird. Ist z.B. die dargestellte Zahl 1.23456 und die nächste 77, so erhält man 7723456. Aber man kann dieses Problem durch eine kleine Modifikation des Programmes lösen.

Dazu wird die Variable B in eine Zeichenkette (string) verwandelt, zu der noch ein paar Leerzeichen addiert werden, so dass der komplette vorherige Wert auf dem Display durch Überschreiben mit Leerzeichen ausgelöscht wird.

Man findet den Befehl toString( im Menü [prgm] E/A.
Die endgültige Fassung des Befehles Output( ist:
Output(5,10,toString(B)+“          ”)

Es wurden 10 Leerzeichen zwischen den Anführungsstrichen eingefügt.

Lässt man nun das Programm laufen, so sieht man, dass einige Werte kürzer sind als andere, da die Leerzeichen, die zu der Zeichenkette B addiert wurden, die vorherigen Zeichen überschrieben haben.

Verkettung:
Das im Befehl Output( verwendete “+” – Zeichen ist nicht im Sinne einer üblichen Addition zu verstehen. Hier verkettet (hängt aneinander) es zwei Zeichenketten. Die Leerzeichen in den Anführungsstrichen werden an das Ende der Zeichenkette B angehängt.

In der zweiten Stunde von Lektion 3 soll ein Programm entwickelt werden, das abhängig vom Umgebungslicht eine Lampe ein – und ausschaltet.

Lernziele:

• Verwendung des Befehls Send(„READ BRIGHTNESS“).
• Verwendung der While – Schleife.
• Verwendung von If…Then…Else…End um eine Lampe abhängig von der Helligkeit ein- und auszuschalten.

Es soll ein Programm geschrieben werden, das den Helligkeitswert BRIGHTNESS bestimmt und eine Lichtquelle einschaltet, wenn es dunkel wird, und wieder ausschaltet, wenn das Umgebungslicht heller wird. Genau so funktionieren viele automatische Lichter (Armaturenbrettbeleuchtung) oder auch Nachtlichter (Straßenbeleuchtung).

Das Programm verwendet den eingebauten Helligkeitssensor des TI-Innovator™ Hubs und schaltet die eingebaute LED an (LIGHT ON), wenn die Helligkeit unter einen bestimmten Wert absinkt und wieder aus, wenn der Wert überschritten wird.

Erste Programmschritte:

1. Es wird ein neues Programm mit dem Namen HELL2 erzeugt..
2. Die Befehle ClrHome und Disp mit der Überschrift werden hinzugefügt wie abgebildet.
3. Durch 2→B wird die Variable B auf einen definierten Wert gesetzt.
4. Eine While – Schleife mit der Bedingung B>1 wird hinzugefügt.
5. Der Befehl End beendet die While-Schleife.

6. In den Schleifenkörper der While - Schleife werden noch Send(“READ BRIGHTNESS”) und Get(B) aus dem Menü HUB eingefügt wie abgebildet.

Um die Schleife und das Programm zu beenden, muss der Sensor nur abgedeckt werden. Dann ist mit Sicherheit B<1, denn bei Dunkelheit liefert der Sensor nur einen sehr kleinen Wert.

Der If- Befehl:

Der verwendete If – Befehl hat zwei Befehlsblöcke: einen, wenn die Bedingung wahr ist, und den anderen, wenn sie falsch ist.

Die Syntax ist

    If <Bedingung>
    Then
        <tue dies wenn sie wahr ist>
    Else
        <tue dies wenn sie falsch ist>
    End

Der If – Befehl wird hinter Get(B) und vor End mit ein paar Leerzeilen für die fehlenden Programmblöcke eingebaut wie auf dem Bild oben gezeigt. Leerzeilen erhält man, indem man [ins][enter] drückt.

Die Bedingung für die If – Abfrage:

Der Helligkeitswert ist in der Variablen B abgespeichert und bewegt sich im Bereich 0 bis 100. Was ist nun ein guter Wert für „dunkel“? Im Programm wird 25 verwendet, aber man kann natürlich auch jeden anderen Wert des Wertebereiches nehmen. Das Zeichen „<“ findet man im Menü test (2nd math).

Man kann das Programm ergänzen durch einen Input – Befehl, mit dem die sogenannte „Triggerschwelle“ eingelesen werden kann, also jene Zahl, die die Empfindung „dunkel“ bestimmt.

Zum Schluss müssen noch LIGHT ON und OFF in die Then und Else – Blöcke eingefügt werden wie gezeigt.

Nun kann der Editor verlassen und das Programm gestartet werden. Bei genügender Abdunkelung des Sensors sollte die rote LED (LIGHT) auf dem TI-Innovator™ Hub aufleuchten, bei Aufhellung wieder ausgehen und bei totaler Abdunkelung sollte das Programm enden.

Es kann hilfreich sein, wenn man wie im vorigen Programm noch den Befehl Output( hinzufügt, um die Helligkeitswerte auf dem Display anzuzeigen. Außerdem kann man in die beiden Blöcke des If – Befehls noch Befehle einfügen, die den Status der LED anzeigen, etwa durch:

    Output(9,1,“AN ”) und Output(9,1,“AUS”)

In dieser dritten Stunde der Lektion 3 wird die Helligkeit (BRIGHTNESS) genutzt um eine LED (die COLOR LED) zu steuern.

Lernziele:

• Auslesen des Lichtsensors und Steuern der Helligkeit der COLOR LED oder des vom Lautsprecher erzeugten Tones.
• Verwendung von Formeln, um die BRIGHTNESS-Werte in COLOR- oder SOUND-Werte umzurechnen.

Es soll ein Programm geschrieben werden, das auf die Umgebungshelligkeit reagiert. Je heller die Beleuchtung, desto heller soll auch die COLOR LED leuchten. Der schwierige Teil dabei ist die Umwandlung der BRIGHTNESS-Werte in angemessene COLOR-Werte:

    Die Helligkeit (BRIGHTNESS) B umfasst den Bereich von 0 bis 100.
    Die Intensität (COLOR) C (alle drei Farbkanäle) variiert hingegen von 0 bis 255.
    Wie kann man B in C umwandeln?

Und nun das Programm:

1. Es wird ein neues Programm mit dem Namen HELL3 angelegt.
2. Die Befehle ClrHome und Disp werden hinzugefügt, damit die Überschrift auf dem Display angezeigt wird.
3. Der Variablen B wird der Anfangswert 2 zugewiesen.
4. Eine While – Schleife wird hinzugefügt, um die Helligkeit zu lesen und mit Get(B) in der Variablen B abzuspeichern.

5. Die Variable C erhält den Wert für die Farbe für alle drei Farbkanäle der COLOR LED. Die Umwandlung mit dem Faktor 2,55 führt zur Programmzeile 2.55·B→C. Die Formel lässt sich überprüfen:
   Ist B = 0, dann ist C = 2,55·0 = 0, und ist B = 100, dann ist C = 2,55·100 = 255.
6. Der Befehl Send(“SET COLOR wird vor dem End der Schleife eingefügt, und wird die Helligkeit der LED steuern.

7. Zum Schluss wird der SET COLOR – Befehl vervollständigt, indem für jede der drei Farben eval(C) eingesetzt wird. Haben alle drei Farbkanäle denselben Wert, so leuchtet die LED weiß mit den entsprechenden Intensitätsabstufungen in Abhängigkeit von C.
8. Das Programm kann gestartet werden, nachdem der TI-Innovator™ Hub angeschlossen wurde. Man kann die Helligkeit ändern, indem man den Sensor in verschiedene Raumrichtungen zeigen lässt. Dabei sind die Intensitätsschwankungen der COLOR LED gut zu sehen.

Man kann das Programm durch Output( - Befehle ergänzen, um die Werte von B und C anzeigen zu lassen.

Aber: Das Programm funktioniert doch eigentlich falsch! Je dunkler der Raum, desto heller sollte die LED sein. Wie kann man den Effekt ins Gegenteil verkehren?

Eine weitere Aufgabe: Wie muss man das Programm abändern, so dass unterschiedliche Helligkeitswerte unterschiedliche Farben zur Folge haben?

In dieser Anwendung soll ein Programm entstehen, mit dem Tonfrequenzen durch die Änderungen der Helligkeit gesteuert werden, die ein Lichtsensor misst. Das kann man erreichen, indem man ihn mit der Hand abschattet – also Musik mit der Hand!

Lernziele:

• Schreiben eines Programms, das Helligkeitswerte in Tonfrequenzen umsetzt.
• Wiederholung der Frequenzen der Musiknoten und des Prinzips der zwölften Wurzel aus 2.

Es soll ein Programm geschrieben werden, dass die Helligkeit des Lichtsensors (BRIGHTNESS) ausliest und einen von dieser Helligkeit abhängigen Ton spielt. Dabei gibt es für den Ton zwei Möglichkeiten:

• Es wird einfach eine Frequenz des Hörbereiches gespielt (etwa 100Hz – 1000Hz).
• Es wird eine Musiknote gespielt, so wie man sie z.B. auf einem Klavier oder einem anderen Instrument findet.

Die erste Möglichkeit erzeugt Töne, die man am ehesten mit “Geräusch” umschreiben kann. Mit der zweiten Möglichkeit erhält man Töne, die wie Musik klingen, aber die Mathematik ist etwas komplexer.

Mit diesem Programm verhält sich der TI-Innovator™ Hub wie ein Theremin (1920 erfundenes elektronisches Instrument, das berührungslos gespielt wird).

Anmerkungen zum Programm:

1. Ein neues Programm mit dem Namen APP3 wird angelegt.
2. Die Befehle ClrHome and Disp werden hinzugefügt, damit die Überschrift wie abgebildet angezeigt werden kann.
3. Eine While – Schleife wird hinzugefügt, in der die Helligkeit ausgelesen und in einer Variablen B gespeichert wird.
4. Hinzugefügt werden muss auch noch der Befehl, mit dem der Ton auf den eingebauten Lautsprecher ausgegeben wird. Achtung! Für den Ton wird die Variable F verwendet; es fehlt noch die Umrechnung von B in F!

Das Programm muss noch um die fehlenden Programmzeilen ergänzt werden, mit denen die Helligkeit in einen Ton oder einen musikalischen Ton umgewandelt wird.

Für einfache Töne hat sich der Frequenzbereich von 100 Hz – 1000 Hz als sinnvoll erwiesen (man sollte aber auch einmal einen anderen Bereich ausprobieren).

Bei Musiknoten sollte man den Bereich bei a (55 Hz) beginnen lassen und z.B. die nachfolgenden 50 Töne verwenden (s. Lektion 2, Übung 3, Programm TON2 – hier werden die 12 Töne einer Oktave gespielt).

Bei Musiknoten muss man die Helligkeit in ganze Zahlen umwandeln. Man kann entweder die Funktion int() oder die Funktion runde( ,0) verwenden:

     int(X)→X              erzeugt die größte ganze Zahl, die kleiner ist als X.
     runde(X,0)→X      rundet X auf den nächsten ganzzahligen Wert.

In der ersten Lerneinheit von Lektion 4 wird gezeigt, wie man den Programmeditor nutzt, um den Rover fahren zu lassen.

Lernziele:

• Verwendung des TI-84 Plus CE-T Programmeditors
• Verwendung des Befehls Send(“CONNECT RV"), um den TI-Innovator Rover mit dem TI-Innovator™ Hub zu verbinden
• Anwendung der Fahrbefehle FORWARD, BACKWARD, LEFT und RIGHT

Erste Schritte

• Will man ein neues Programm schreiben oder ein vorhandenes editieren, so findet man im Editiermodus die TI-Innovator Rover Befehle, indem man die Taste [prgm] drückt und dann im Hub-Menü 7:Rover (RV)… wählt. Das geht besonders schnell, wenn man gleich ◄ wählt und dann die Nummer 7.
• Die zur Vervollständigung der Rover-Befehle manchmal notwendigen Zahlen oder optionalen Parameter kann man ganz normal von der Tastatur eingeben oder aus einem anderen Rover-Menü auswählen
• Manchen Rover-Befehlen kann nichts hinzugefügt werden – sie enthalten bereits das schließende Anführungszeichen und die schließende Klammer. Allen anderen Befehlen müssen diese Zeichen unbedingt hinzugefügt werden.

Als erster Befehl muss dem TI-Innovator Hub mitgeteilt werden, dass er sich mit dem Rover verbinden soll:

Send(“CONNECT RV”)

Mit RV wird der Rover bezeichnet.

Diesen Befehl erhält man folgendermaßen:

1. Taste [prgm] drücken und dann das Hub-Menü wählen.
2. Anschließend das Rover (RV)… -Untermenü wählen.
3. Den Befehl Send(“CONNECT RV”) auswählen (befindet sich weiter unten im Untermenü).

Nun soll der Befehl Pause eingefügt werden. Dieser Befehl hält das Programm solange an, bis die Taste [enter] gedrückt wurde.

4. Mit der Taste [enter] erhält man eine neue Programmzeile
5. Mit der Taste [enter] erhält man alle Untermenüs. Im CTL-Menü wählt man dann den Befehl Pause.
6. Der Pause-Befehl kann mit einem zusätzlichen Text versehen werden wie hier “START : ENTER” , indem man die alphabetischen Tasten verwendet.

Testet man dieses Programm und hört man den Ton vom TI-Innovator Hub, der einen Fehler signalisiert, so bedeutet es in diesem Fall, dass der Befehl CONNECT RV nicht erfolgreich war. Man sollte überprüfen, ob der Rover eingeschaltet ist.

Der erste Fahrbefehl für den Rover

7. Mit [enter] wird nach dem Pause-Befehl eine neue Zeile eingefügt.
8. Mit der Tastenfolge prgm > Hub > Rover (RV)…> Drive RV… erhält man das abgebildete Untermenü.
9. Aus dem Drive RV…-Menü wird FORWARD ausgewählt.

Dem ausgewählten Befehl fehlen die schließenden Anführungszeichen und die schließende Klammer, ein Hinweis darauf, dass der Befehl noch vervollständigt werden muss.

10. Es werden noch die Zahl 1 sowie die schließenden Anführungszeichen ([alpha] [ + ]) und die schließende Klammer (über der 9) hinzugefügt.
11. Mit [2nd][mode] verlässt man den Editor und startet das Programm. Man achte darauf, dass der Rover nach vorne hin genügend Platz hat!

Hat man alles richtiggemacht, so bewegt sich der Rover vorwärts – aber wie weit? Misst man die gefahrene Strecke aus, so sollte schnell klar sein, was FORWARD 1 bedeutet.

Auf dem Display des Taschenrechners erscheint „Fertig“, sobald das Programm beendet ist. Das geschieht, noch während der Rover sich bewegt. Taschenrechner und TI-Innovator Hub arbeiten mit unterschiedlichen Geschwindigkeiten.

Rückwärts fahren

12. Im Editiermodus wird durch die Tastenfolge prgm > Hub > Rover (RV)… > Drive RV… > BACKWARD der Befehl Send(“RV BACKWARD eingefügt.
13. Wie im Befehl FORWARD müssen noch die Zahl 1 sowie die Anführungszeichen und die abschließende Klammer eingefügt werden.

Verlässt man nun den Editor und startet das Programm, so fährt der Rover etwas vorwärts und anschließend rückwärts in seine Ausgangsposition. Wenn das geklappt hat – Glückwunsch! Der Rover bewegt sich!

Drehungen

Die nächsten beiden Befehle im Menü Drive RV… sind LEFT und RIGHT. Was passiert, wenn man diese beiden Befehle dem Programm hinzufügt?

Eine längere Fahrt

Was bewirkt das nebenstehende Programm? Wo steht der Rover am Ende des Programms? Zur Kontrolle der theoretischen Vorhersage sollte man das Programm in den Taschenrechner eingeben und testen.

Verhält sich der Rover wie vorhergesagt? Kann man nur mit diesen Befehlen ein Programm schreiben, so dass der Rover ein Rechteck fährt?

Verwendung des neuen zusätzlichen Programm-Menüs

Man gelangt in dieses zusätzliche Menü, indem man alpha-F5 drückt. Man kann mit diesem Menü eine Zeile kopieren (5: Copy Line) und wieder einfügen (6: Paste Line Below) unterhalb der aktuellen Cursor-Zeile. Ferner kann man Löschen rückgängig machen (Undo Clear), Zeilen oberhalb des Cursors einfügen (Insert Line Above) und das Programm im Home - Bildschirm starten (Execute Program).

Den vier Fahrbefehlen aus Übung 1 fehlten die abschließenden Anführungszeichen und die schließende Klammer, weil es weitere Möglichkeiten gibt, um die Befehle zu vervollständigen. In dieser Lektion sollen diese Möglichkeiten untersucht werden.

Lernziele:

• Erweiterung der Fahrbefehle des Rovers
• Optionen für RIGHT und LEFT
• Der Befehl Wait

Parameter für FORWARD und BACKWARD

Diese Fahrbefehle haben drei optionale Parameter:

• SPEED (Geschwindigkeit)
• TIME (Zeit)
• DISTANCE (Entfernung)

Man findet sie im Menü prgm > Hub > Rover (RV)… > RV Settings… ebenso wie die Einheiten für die Geschwindigkeit UNITS/S and M/S.

Verwendung von DISTANCE-T-T, SPEED und TIME
Beispiele für unterschiedlichen Anwendungen im Befehl FORWARD:

• FORWARD DISTANCE # ist gleichbedeutend mit FORWARD #.
  • Die Voreinstellung für die Entfernungseinheit # ist 10 cm.
• FORWARD DISTANCE # M bewegt den Rover um # Meter.
• FORWARD # SPEED # stellt zusätzlich die Geschwindigkeit ein.
  • Speed darf einen Wert zwischen 1.4 und 2.3 haben. Werte außerhalb dieses Bereichs erzeugen eine Fehlermeldung des Hubs.
• FORWARD TIME #.

Man kann höchstens 2 der drei Optionen in den Befehlen FORWARD und BACKWARD verwenden, da die dritte von den beiden anderen abhängig ist.

Sollte der anzuwendende Wert in einer Variablen gespeichert oder aus einem Term berechnet werden, so muss eval( ) verwendet werden.

SPEED und TIME Programm

1. Das rechts dargestellte Programm enthält den Befehl:
   Send(“RV FORWARD SPEED 2.3 TIME 2”)
2. Nun soll der richtige Wert für TIME eingefügt werden, so dass der Rover wieder in seine Ausgangsposition kommt:
   Send(“RV BACKWARD SPEED 1.4 TIME ? ”)

Hinweist: DISTANCE = SPEED * TIME

Optionen für RIGHT und LEFT

Die Voreinstellung für diese Befehle ist eine Drehung um 90° rechts- (RIGHT) oder linksherum (LEFT), aber man kann auch einen Winkel einfügen, sodass der Rover sich um jeden Winkel zwischen -360° … 360° dreht. Negative Werte sind erlaubt; d.h., LEFT -90 ist dasselbe wie RIGHT 90.

3. Im Beispiel wurde ein Befehl eingefügt, durch den der Rover rechtsherum um 135° dreht: RV RIGHT 135. Man muss die Zahl 135 eingeben und auch die abschließenden Anführungszeichen und die Klammer. Die Maßeinheit DEGREES ist nicht notwendig, aber sie ist verfügbar im Menü RV Settings… , wenn man die Drehung verdeutlichen will.

Man kann die Drehung auch in RADIANS oder GRADS angeben (ebenfalls im Menü RV Settings…), aber dann müssen diese Maßeinheiten auch zwingend dazu geschrieben werden.

Im Beispielprogramm rechts sind ein paar Befehle aufgelistet. Wie genau steht der Rover, wenn diese drei Befehle ausgeführt sind?

Es soll ein Programm geschrieben werden, so dass der Rover ein gleichseitiges Dreieck fährt. Man kann mit den folgenden Befehlen anfangen und vielleicht auch eine Schleife verwenden:

In der dritten Übung für Lektion 4 geht es um die Drehung um einen bestimmten Winkel, den Einfluss der Zeit (das richtige „Timing“) sowie um die Verwendung der RGB-LED (COLOR LED) auf dem Rover.

Lernziele:

• Verwendung des Befehls TO ANGLE
• Verwendung des Befehls RV.COLOR
• Abstimmung des Timings auf dem Taschenrechner und dem Rover

Diese Übung behandelt zwei Befehle und ein wesentliches Merkmal des Rovers:

• den Befehl TO ANGLE, der sich deutlich unterscheidet von LEFT und RIGHT
• das Einschalten der eingebauten RGB-LED durch RV.COLOR (bezeichnet mit ‘Color’, befindet sich vorne links über der Ladezustandsanzeige)
• die Abstimmung der Bewegung des Rovers mit dem Programmablauf durch den Befehl Wait

Der Befehl TO ANGLE

Der Befehl Send(“RV TO ANGLE <Zahl>”) wird verwendet, um den Rover um einen bestimmten Winkel zu drehen. Mathematisch gesehen entspricht dabei dem Winkel 0° die Richtung der positiven x-Achse (auch genannt „Ost“). Durch eine Drehung im Gegenuhrzeigersinn kommt man dann zu 90° (positive y-Achse, „Nord“), 180° (negative x-Achse, „West“) und 270° (negative y-Achse, „Süd“) (s. Bild rechts).

Egal wie der Rover steht, wird seine Ausrichtung beim Empfang des Befehls Send(“CONNECT RV”) auf 0° festgelegt. Mit dem Befehl Send(“RV TO ANGLE 0”) wird der Rover angewiesen, sich aus jeder beliebigen Stellung wieder in diese anfängliche Ausrichtung zu drehen.

Die Voreinstellung für das Winkelmaß ist DEGREES, aber man kann die Winkeldrehung auch in RADIANS oder GRADS angeben (auswählbar im Menü RV Settings…).

Ein kleines Programm:

Verhält sich der Rover wie erwartet?

Programmablauf und Bewegung des Rovers synchronisieren

Das Programm auf dem Taschenrechner ist meistens abgelaufen („Fertig“), bevor der Rover seine Bewegungen abgeschlossen hat. Das liegt daran, dass die Fahrbefehle, die im TI-Innovator™ Hub gespeichert sind, weniger Zeit für ihre Durchführung benötigen wie der Rover für ihre Ausführung. Die Fahrbefehle werden in einer Art „Warteschlange“ gespeichert und ausgeführt, wenn der Rover dazu bereit ist.

Das Beispielprogramm zeigt diese Synchronisation durch die Verwendung des Befehls Wait. Der Rover selbst bewegt sich zufallsgesteuert und schaltet dabei die eingebaute RGB-LED während der Bewegung mit dem Befehl RV.COLOR an. Innerhalb des Befehls TO ANGLE wird dabei eval( ) verwendet, da der Winkel durch eine Berechnung entsteht.

Beispielprogramm

1. Das neue Programm ROVER43 anlegen.
2. Eine For – Schleife für die spätere Zufallsbewegung einfügen. Man sollte das zugehörige End nach ein paar Leerzeilen ebenfalls einfügen, um es später nicht zu vergessen.
   
   Hinweis: Die Befehle For( und End befinden sich im Menü CTL.

3. In die Schleife kommt zunächst ein Befehl FORWARD.
4. Dann wird der Drehwinkel als eine Zufallszahl aus dem Bereich 0° … 360° erzeugt und in der Variablen H abgespeichert: randInt(0,360) → H.
5. Jetzt kommt noch der Befehl TO ANGLE hinzu.
6. Lässt man nun das Programm laufen, so sollte man sehen:
   • Der Rover bewegt sich zufällig.
   • Das Programm meldet „Fertig“, während der Rover sich noch bewegt.

Der Befehl RV.COLOR

Da die RGB-LED des Hub durch den Rover verdeckt wird, wurde eine weitere RGB-LED oben auf dem Rover angebracht. Ihre Bezeichnung ist RV.COLOR. Sie kann genauso verwendet werden wie die RGB-LED auf dem Hub. Man kann sie über die vier Befehle steuern, die auf dem Bild rechts abgebildet sind. Man findet sie im Menü prgm > Hub > Rover (RV)… > RV Color….

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

Einfügen des Befehls RV.COLOR in das Programm

7. Der Befehl RV.COLOR soll unmittelbar vor dem Befehl FORWARD 1 in die For( – Schleife eingefügt werden. Die Farbwahl ist dabei beliebig.
8. Lässt man nun das Programm laufen, so sieht man, dass die LED sofort und dann dauerhaft leuchtet.

Nun soll die LED dazu gebracht werden nur dann zu leuchten, wenn der Rover sich vorwärts bewegt. Dazu muss der Rover warten, bis jede Teilbewegung vollendet ist und dann für die Drehung die LED ausschalten. Dazu muss ein Wait-Befehl dem Programm hinzugefügt werden.

1. Wie lange dauert die Bewegung beim Befehl FORWARD 1? Etwa 1 Sekunde? Dann sollte man den Befehl Wait 1 unmittelbar nach dem Befehl FORWARD 1 einfügen. Den Befehl findet man im Menü prgm > Hub.
2. Lässt man nun das Programm laufen, so stellt man fest, dass die LED immer noch dauerhaft leuchtet. Sie muss also noch nach der Vorwärtsbewegung abgeschaltet werden.

11. Das geschieht durch den Befehl Send(“SET RV.COLOR 0 0 0”).
12. Nun kann das Programm wieder getestet werden. Schaltet sich die LED zu den richtigen Zeiten ein und wieder aus?

Es müssen nun noch die Zeiten berücksichtigt werden, die der Rover zum Drehen benötigt, denn dann soll die LED ja nicht leuchten.

13. Ein weiterer Wait – Befehl wird nach dem Befehl TO ANGLE eingefügt. Er sollte lang genug gewählt werden, um jede Drehung bis hin zu 360° zu umfassen.

Erweiterung:

Nach jeder Drehung soll die Farbe wechseln! Hinweis: Verwende eval().

Herausforderung: Man kann die Wartezeit bei der Drehung abhängig machen vom Drehwinkel, indem man die Zeiten bei der Verwendung von TO ANGLE misst.

In dieser Anwendung soll der Rover so programmiert werden, dass er ein regelmäßiges Vieleck fährt. Seitenlänge (in Rover-Einheiten) und Seitenzahl sollen vom Benutzer eingegeben werden.

Lernziele:

• Eingabebefehle
• Verwendung von eval( ) in Rover-Befehlen
• Verstehen der Grundlagen eines regelmäßigen Vielecks
• Verwendung von COLOR und Timing (Wait)

Die Aufgabe von eval( ) ist es, den Wert einer Variablen oder eines Terms zu ermitteln und ihn in einen String zu verwandeln, der zum TI-Innovator™ Hub gesendet wird. In dem kleinen Beispielprogramm gibt der Benutzer einen Wert für die Variable F (als Tonfrequenz) ein und die Funktion eval(F) wandelt diese Zahl in einen String um, der vom Hub verarbeitet werden kann.

Aufgabe:

Es soll ein Programm geschrieben werden, dass die Länge einer Polygonseite und die Anzahl der Seiten erfragt und den Rover innerhalb dieser Grenzen bewegt.

Man kann zusätzlich einen Filzstift am Rover befestigen und das Polygon auf einem ausreichend großen Stück Papier zeichnen lasen. Man beachte: 1 Einheit entspricht 10 cm.

Optional kann man noch eine LED zu den Drehungen an den Eckpunkten aufleuchten lassen.

Einige nützliche Befehle:

In der ersten Übung geht es um den Ultraschall-Entfernungssensor des Rovers (kurz: Ranger) und die damit verbundenen Möglichkeiten, um die Bewegung des Rovers zu kontrollieren.

Lernziele:

• Verwendung des Befehls READ RV.RANGER zur Messung von Entfernungen
• Verwendung dieses Befehls zur Beeinflussung der Bewegung des Rovers

Vorne am TI-Innovator Rover ist ein Ultraschall-Entfernungssensor fest angebracht. Er misst die Entfernung zu einem Objekt, das sich vor dem Rover befindet. Diese Entfernung kann dann dazu benutzt werden, um die Bewegung des Rovers zu steuern. Gerät der Rover zu dicht an ein Hindernis, so kann er so programmiert werden, dass er seine Richtung ändert, um dem Hindernis auszuweichen.

Zunächst soll an einem einfachen Programm gezeigt werden, wie der Ranger arbeitet. In Übung 2 soll dann diese Information zur Steuerung der Bewegung des Rovers verwendet werden.

Das Programm liest den vom Ranger ermittelten Wert und zeigt ihn auf dem Display an. Es findet keine Bewegung des Rovers dabei statt. Stattdessen bewegt man die Hand vor dem Ranger oder nimmt den Rover in die Hand und bewegt ihn auf verschiedene Hindernisse zu.

Die ersten Befehle

1. Das neue Programm heißt ROVER51.
   Der erste Befehl ist ClrHome
   Dann folgt der übliche Befehl Send (“CONNECT RV”) aus dem Menü prgm > Hub > Rover (RV)…

Die zentrale Schleife

ist eine While – Schleife. Ist die gemessene Entfernung D (von distance) kleiner als ein bestimmter Wert, so wird das Programm beendet.

2. D wird der Anfangswert 1 zugewiesen (ein solcher Anfangswert ist bei einer While-Schleife unbedingt nötig).
3. While wird aus dem Menü prgm > CTL ausgewählt. Die Schleife soll solange ausgeführt werden wie D größer als 0.1 ist.

Die Befehle innerhalb der Schleife

4. Der Befehl READ RV.RANGER befindet sich im Menü prgm > Hub > Rover (RV)… > Read RV Sensors… .
5. Ausgewählt wird Send(“READ RV.RANGER”).

6. Dann müssen noch die Befehle
       Get(D)
       Wait 0.25
   in die Schleife eingefügt werden.

Um einen Wert von einem Sensor zu erhalten, benötigt man immer zwei Befehle: zunächst den Befehl Send(“READ…”), durch den der Wert aus dem Sensor in den TI-Innovator™ Hub übertragen wird, und dann den Befehl Get( ), um den Wert in den Taschenrechner zu übertragen. Der Befehl Wait .25 verlangsamt den Vorgang etwas, damit man die Werte besser ablesen und verstehen kann.

Darstellung des Wertes

7. Mit dem Befehl Output( ) wird der Wert von D an einer bestimmten Stelle des Displays angezeigt.
8. Zuletzt wird noch der Befehl End hinzugefügt.

Programmablauf

9. Wenn das Programm läuft, werden Zahlen auf dem Display dargestellt. Bewegt man die Hand vor dem Rover, ändern sie sich. In welcher Maßeinheit werden die die Entfernungen gemessen? Wann endet das Programm?
   
   Antwort: In der Maßeinheit Meter, und das Programm endet, wenn 0,1 m = 10 cm unterschritten werden.

In der ersten Übung der Lektion 5 wurde der Ranger vorgestellt und wie man mit ihm Entfernungen bestimmt und darstellt. Nun erfolgt die Erweiterung, in der der Ranger die Bewegung des Rovers beeinflusst.

Lernziele:

• Verwendung des Befehls READ RV.RANGER, um die Entfernung zu einem Hindernis zu bestimmen
• Steuern der Bewegung des Rovers, wenn er zu dicht an das Hindernis herankommt
• Berücksichtigen des Timings bei der Bewegung des Rovers im Programm

Es soll ein Programm geschrieben werden, mit dem der Rover hin und her zwischen zwei „Mauern“ fährt, die sich genau gegenüberstehen. Der Rover fährt erst vorwärts und bestimmt dann die Entfernung. Gerät er zu dicht an die „Mauer“, so hält der Rover an, dreht sich um 180° und fährt wieder vorwärts bis zur nächsten „Mauer“ .

Daraus ergibt sich der grundsätzliche Ablaufplan

Kernstück ist die zentrale For-Schleife, die dafür sorgt, dass der Rover nach einiger Zeit wieder anhält.
For - Schleife
Der Rover startet vorwärts (FORWARD)
While die Entfernung größer ist als 0,25 m
Ermittele die Entfernung
End der While - Schleife
STOP
Drehe um 180° (RIGHT 180)
End der For - Schleife

Das Programm

1. Das Programm enthält am Anfang die üblichen Befehle.
2. Eine For( - Schleife wird hinzugefügt, die 10mal durchlaufen wird..
3. Der Befehl FORWARD 100 wird hinzugefügt, so dass der Rover maximal 10 Meter (100 * 0.1m pro Entfernungseinheit) fährt.
4. Der Befehl End der For( - Schleife darf nicht vergessen werden!

Wie in der vorhergehenden Übung wird wieder die Variable D für die Entfernung (distanCE-T) des Rangers vom Hindernis verwendet.

5. Bestimmung des Anfangswertes von D zu 1.
6. Starten der While D > 0.25 - Schleife.

Der Programmcode enthält zwei Ends: einer ist das End der For - Schleife und der andere das End der While - Schleife.

7. Nun kommen die Befehle, die sich innerhalb der While – Schleife befinden. Hat man nicht genug Leerzeilen bis zum End eingefügt, kann man den Cursor an den Anfang der Zeile setzen, wo man einen weiteren Befehl einfügen möchte. Mit [ins] ([2nd] [del]) und dann [enter] fügt man eine neue Leerzeile ein. Alternativ dazu kann man eine Leerzeile auch einfügen über [alpha] F5 und dann Insert Line Above.

8. Der Befehl Send(“READ RV.RANGER”) wird hinzugefügt.
9. Mit dem Befehl Get( wird die Entfernung in der Variablen D gespeichert.

Die While – Schleife ist nun vollständig. Der Rover fährt 10 m geradeaus und in der While – Schleife wird die Entfernung gemessen. Wenn man will, kann man sich die Entfernung auf dem Display mit einem Befehl Output( innerhalb der While – Schleife anzeigen lassen um zu überprüfen, dass alles richtig funktioniert.

Endet die While – Schleife, so ist das ein Hinweis darauf, dass sich der Rover zu dicht vor einem Hindernis befindet. Jetzt muss dem Rover mitgeteilt werden, dass er anhalten (STOP) und sich um 180° (RIGHT 180) drehen soll. Aber man muss dem Rover nicht erneut mitteilen, dass er vorwärtsfahren soll, da der erneute Durchgang bei der For – Schleife ja mit diesem Befehl anfängt

10. Zwischen dem End der While – Schleife und dem End der For – Schleife werden also die Befehle
    RV STOP und dann RV RIGHT 180 eingefügt.
11. Der zusätzliche Befehl Wait 2 lässt dem Rover genügend Zeit, um sich einmal umzudrehen, bevor er wieder vorwärtsfährt, da nun ein erneuter Durchlauf der For – Schleife anfängt.
12. Das Programm ist fertig und kann getestet werden. Nähert sich der Rover nun einem Hindernis, so sollte er sich um 180° drehen und in die entgegengesetzte Richtung zurückfahren. Die Werte für die Minimaldistanz und die Wartezeit beim Drehen müssen eventuell noch angepasst werden. Ist die Minimaldistanz zu klein, so kann der Rover mit seinem Heck an die „Mauer“ treffen und die Drehung beeinflussen.

In dieser dritten Übung von Lektion 5 geht es um den Sensor COLORINPUT und die Verwendung der von ihm gelieferten Werte, um die Fahrtrichtung des Rovers zu beeinflussen.

Lernziele:

• READ COLORINPUT
• Verwendung des Wertes zur Richtungsänderung

Der Rover hat einen RGB - Sensor COLORINPUT, der vorne unten am Rover angebracht ist. Daneben ist eine weiße LED angebracht, die den Boden beleuchtet, so dass das der Sensor ein gutes Signal aus dem reflektierten Licht erzeugen kann. Das RGB – Signal des Sensors wird vom TI-Innovator™ Hub in neun Werte umgewandelt, die bestimmten Farben zugeordnet sind:

1 = rot
2 = grün
3 = blau
4 = cyan
5 = magenta
6 = gelb
7 = schwarz
8 = weiß
9 = grau

1. Das Programm beginnt mit den üblichen Befehlen.

2. Eine zentrale For – Schleife wird verwendet, um den Rover viermal sich bewegen und drehen zu lassen.
3. End ist hier das Ende der For - Schleife.

4. Mit einer While – Schleife wird überprüft, ob sich die vom Sensor „gesehene“ Farbe ändert. Dazu muss man aber erst einmal wissen, welche Farbe der Sensor überhaupt „sieht“. Das geht mit dem Befehl READ RV.COLORINPUT und einem anschließenden Get(C), so dass die der Farbe zugeordnete Zahl in C gespeichert wird.

5. Es wird noch eine weitere Variable D als Variable für die While – Schleife benötigt. D enthält den Farbwert, während der Rover sich bewegt. Anfänglich sind D und C natürlich gleich. Nun fängt der Rover an, sich für 1 Sekunde vorwärts zu bewegen.

6. In der While – Schleife wird nun D mit C verglichen, denn innerhalb der While – Schleife wird D fortlaufend eingelesen und auf eine Veränderung gewartet.
   
   Das Gleichheitszeichen findet man im Menü [test] ([2nd] [math]).
7. Der Befehl End für die While – Schleife darf nicht vergessen werden.

8. Innerhalb der While – Schleife wird der vom Farbsensor gelieferte Farbwert fortlaufend eingelesen und in D gespeichert, während der Rover sich bewegt. Die Schleife wird verlassen, wenn die „aktuelle“ Farbe aus D sich von der „älteren“ Farbe in C unterscheidet, wenn also ein Farbwechsel stattfindet.

9. Jetzt erhält der Rover die Befehle STOP (wird unmittelbar ausgeführt!) und RIGHT. Diese beiden Befehle stehen zwischen den beiden Ends im Programm. Das zweite End ist das Ende der For – Schleife. Der Rover macht also viermal eine Rechtsdrehung um 90°, wenn ein Farbwechsel stattgefunden hat.
10. Durch den Befehl FORWARD 1 mit einem anschließenden Wait 1 soll sichergestellt werden, dass der Rover sich von dem Ort des Farbwechsels entfernt, bevor wiederum ein Farbwert in C eingelesen wird.

11. Man kann das Programm am besten auf einem hellen einfarbigen Untergrund testen. Für die Richtungsänderung sollte man dem Rover ein Stück Papier (ca. 5 cm x 5 cm) in möglichst gut kontrastierender Farbe (z.B. schwarz) in den Weg legen und auf dem Untergrund fixieren. Wird das Papier vom Farbsensor des Rovers erkannt, so sollte er anhalten, sich um 90° drehen und erneut losfahren. Dieses Manöver sollte man viermal wiederholen können.

In der Anwendung zur Lektion 5 soll ein Programm entwickelt werden, mit dem der Rover in der Lage ist, einem Weg auf einem Stück Papier zu folgen.

Lernziele:

• Verwendung von COLORINPUT, um einen gezeichneten kurvigen Weg zu finden und ihm zu folgen.
• Folgen des Beispielweges der PDF - Testseite.

Dazu soll ein Programm geschrieben werden. Der Weg wird beschrieben durch zwei unterschiedliche Farben wie in dem dargestellten Beispiel:

Der Rover soll von links nach rechts entlang der Grenze zwischen den beiden Farben über das Papier fahren. „Sieht“ der Rover rot, so fährt er ein wenig nach links und vorwärts. „Sieht“ er weiß, so fährt er etwas nach rechts und ebenfalls ein wenig vorwärts.

Man muss ein wenig herumexperimentieren, um den richtigen Drehwinkel und die richtige Strecke vorwärts herauszufinden. Verwendet man einen roten und weißen Untergrund wie in dem Bild oben, so kann man den Befehl READ COLORINPUT.RED verwenden und sehen, welche Farbwerte für den roten und weißen Bereich vom Sensor ermittelt werden. Bei anderen Farben nutzt man den entsprechend modifizierten Befehl wie z.B. READ COLORINPUT.GRAY für weiß/schwarz und entsprechend für weiß/grün undweiß/ blau.

Mit dem kleinen Programm FARBTEST kann man feststellen, welche Werte für ROT vom Sensor gelesen werden:

ClrHome
Disp "TEST FARBSENSOR"
Send("CONNECT RV")
While 1
Send("READ RV.COLORINPUT.RED")
Get(R)
Disp R
Wait .25
End

In dem kleinen Programm ist keine Bewegung des Rovers vorgesehen. Man muss den Rover manuell mehrfach über die Farbgrenze schieben und dabei beobachten, welche Farbwerte angezeigt werden.

Das Programm verwendet eine unendliche While – Schleife. Man muss also das laufende Programm unterbrechen, wenn man es anhalten will. Dazu drückt man auf die Taste ON. Man erhält dann oben auf dem Display die Fehlermeldung: FEHLER: ABBRUCH und hat zwei Möglichkeiten: 1:Abbruch des Programmes und Rückkehr zum HOME-Bildschirm oder 2:GeheZu der Stelle im Programmeditor, an der das Programm durch ON unterbrochen wurde.