Bis jetzt hast du in diesem Buch Fahrzeuge, Robotertiere und Maschinen gebaut. Die coolsten Projekte, die mit dem EV3-Kasten möglich sind, sind aber menschenähnliche Roboter, die sich auf zwei Beinen bewegen. In diesem Kapitel baust und programmierst du den LAVA R3X, den du in Abbildung 19-1 siehst. Er geht auf zwei Beinen, die von großen Motoren angetrieben werden, und kann seinen Kopf und seine Arme mithilfe des mittleren Motors bewegen.
Abbildung 19-1: Der LAVA R3X geht auf zwei Beinen und bewegt dabei seinen Kopf und seine Arme. Wenn du seine Hand schüttelst, begrüßt er dich.
Wenn du es geschafft hast, den Roboter zum Gehen zu bringen, kannst du das Programm erweitern, um den Roboter mit den in diesem Buch vorgestellten Techniken interaktiv und lebensecht zu gestalten.
Der LAVA R3X geht, indem er sein Gewicht auf den einen Fuß verlagert, während er den anderen nach vorn bewegt. Ein Mechanismus in beiden Beinen wandelt die kontinuierliche Vorwärtsbewegung des Motors in eine abwechselnde Vorwärts- und Rückwärtsbewegung des Fußes und ein abwechselndes Schwenken des Fußgelenks nach rechts und links um (siehe Abbildung 19-2).
Abbildung 19-2: Bei einer Umdrehung des Motors wird der Fuß nach vorn und hinten bewegt und das Fußgelenk nach links und rechts geschwenkt.
Damit der Roboter beim Gehen nicht umfällt, müssen die Mechanismen beider Beine jeweils die genau gegenüberliegende Stellung einnehmen und sich die Motoren mit der gleichen Drehzahl drehen. Wenn diese Voraussetzungen erfüllt sind, wird ein Fuß so geneigt, dass er den Boden während der Vorwärtsbewegung nicht berührt, und gleichzeitig trägt der andere das Gewicht des Roboters, während er nach hinten geschoben wird. Dadurch wird der Roboter nach vorn gedrückt.
Während einer Umdrehung eines Beinmotors bewegt sich der zugehörige Mechanismus nach links, nach rechts, nach vorn und nach hinten. Danach hat er einen Schritt gemacht und befindet sich wieder in der Ausgangsstellung.
Mit dem Berührungssensor zwischen den Beinen des Roboters kannst du die Mechanismen in gegenüberliegender Stellung ausrichten, so wie du es bei den Motoren von ANTY in Kapitel 13 gemacht hast. Damit sich beide Motoren gleich schnell bewegen, richtest du eine Drehzahlregelung ein.
Als Erstes baust du die Beine und erstellst Eigene Blöcke, mit denen der Roboter gehen und sich umdrehen kann. Danach konstruierst du den Oberkörper und schreibst ein Programm, das den Roboter dazu bringt, mithilfe seiner Sensoren auf seine Umgebung zu reagieren. Suche die in Abbildung 19-3 gezeigten Teile für den Bau des Roboters zusammen und folge der Anleitung auf den nächsten Seiten.
Abbildung 19.3: Diese Teile brauchst du, um den LAVA R3X zu bauen. Nachdem du die Beine fertiggestellt hast, sind noch Teile übrig, mit denen du später den Kopf und die Arme konstruierst.
1 
2 
3 
4 
5 
6 
7 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
1 
2 
3 
4 
5 
6 
1 
2 
3 
4 
5 
6 
7 
Einer der Winkelbalken ist hier der Deutlichkeit halber blau dargestellt. Verwende in diesem Schritt aber einfach schwarze Balken.
8 
9 
10 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
1 
Nachdem du die Beine miteinander verbunden hast, musst du prüfen, ob die Winkelbalken wie hier gezeigt auf den grauen Kugelkopfpins aufliegen.
2 
3 
4 
5 
6 
Stecke ein kurzes Kabel in Anschluss A ein. Später wirst du es mit dem mittleren Motor verbinden.
7 
Als Nächstes erstellst du mehrere Eigene Blöcke, um die Beine in gegenüberliegender Stellung auszurichten, den Roboter vorwärts gehen zu lassen und ihn nach links zu drehen. Außerdem schreibst du ein kleines Programm, um die einzelnen Blöcke zu testen.
Die Prüfung der Blöcke ohne den schweren Oberkörper des Roboters macht die Fehlerbehebung einfacher, da der Roboter dann nicht so leicht umfällt. Wenn du es geschafft hast, dass sich der Roboter stabil bewegt, kannst du die Konstruktion fertigstellen.
Jedes Mal, wenn der Motor eine komplette Umdrehung ausgeführt hat, drückt der zugehörige Mechanismus einmal auf den Berührungssensor (siehe Abbildung 19-4). Anhand der Informationen dieses Sensors kann der LAVA R3X das rechte und das linke Bein gegenläufig ausrichten.
Abbildung 19-4: Während sich die Motoren drehen, drücken sie jeweils einen Winkelbalken gegen die graue Scheibe, die wiederum den Berührungssensor betätigt. Die beigefarbene Achse sorgt dafür, dass die Scheibe korrekt ausgerichtet bleibt.
Da der Roboter nicht erkennen kann, welcher der beiden Beinmechanismen den Berührungssensor betätigt hat, müssen die Beine erst so positioniert werden, dass der Sensor nicht gedrückt wird. Dazu bewegt der Roboter die Motoren vorwärts, bis der Sensor losgelassen ist, und hält sie dann an. Dabei kann es durch ein gewisses Spiel im Mechanismus manchmal passieren, dass der Berührungssensor erneut gedrückt wird. Um sicherzustellen, dass der Sensor in der losgelassenen Position verbleibt, wartet der Roboter 0,1 s lang und prüft den Sensorzustand dann erneut. Die Bewegung und die Prüfung erfolgen in einem Schleifenblock. Ist der Sensor nach der kurzen Pause immer noch freigegeben, endet die Schleife, wurde der Sensor dagegen zwischenzeitlich wieder gedrückt, wird sie erneut ausgeführt.
Wenn es sicher ist, dass keiner der Mechanismen den Sensor berührt, wird der Rücksetzvorgang fortgeführt. Dazu dreht sich der linke Motor (D) weiter vorwärts, bis der Berührungssensor angestoßen wird, und dann um weitere 90 Grad vorwärts. Danach wird der rechte Motor (B) vorwärts gedreht, bis er den Sensor berührt, und dann um 90 Grad rückwärts. Jetzt sind die beiden Beinmechanismen um 180 Grad getrennt, sodass der Roboter zum Gehen bereit ist. Die beiden Drehsensoren werden jetzt auf 0 gesetzt. Während der Roboter geht, befinden sich die Mechanismen also in gegenüberliegender Stellung, wenn die Drehsensoren beider Motoren den gleichen Wert aufweisen. Durch das Zurücksetzen der Sensoren wird es einfacher, später zur Ausgangsposition zurückzukehren.
Den Block Reset, der diese Vorgänge ausführt, siehst du in Abbildung 19-5. Er steht am Anfang jedes Programms für den LAVA R3X.
Der LAVA R3X soll nicht nur geradeaus marschieren, sondern sich auch nach links drehen können. Nach einer solchen Drehung kann es sein, dass sich die beiden Beinmechanismen nicht mehr gegenüberstehen. Bevor der Roboter weitergehen kann, musst du die Beine daher wieder in die richtige Stellung bringen. Es wäre allerdings ziemlich umständlich, nach jedem Wendemanöver den Reset-Block auszuführen, da er zu viel Zeit in Anspruch nimmt. Zum Glück kannst du aber denselben Effekt erzielen, indem du den Motor in die Nullstellung zurückfährst.
Dazu muss der Roboter die aktuelle Stellung des Roboters messen und ihn um den gemessenen Betrag zurückdrehen. Hat sich der Motor also beispielsweise um 25 Grad vorwärts gedreht, muss er nun um 25 Grad zurückgedreht werden. Wenn der Motor mehr als eine Umdrehung ausgeführt hat, muss er jedoch nur um den Winkel zurückgedreht werden, der über die vollständigen Drehungen hinausgeht (siehe Abbildung 19-6). Misst der Sensor beispielsweise 450 Grad, muss der Motor nur um 90 Grad zurückgedreht werden, sodass der Sensor schließlich 360 Grad anzeigt. In dieser Motorstellung ist der Fuß genauso ausgerichtet wie bei 0 Grad.
Den Betrag, um den die Position die vollständigen Umdrehungen überschreitet, kannst du mit dem Modulo-Operator (%) berechnen. Er gibt den Rest einer Division an. Beispielsweise ergibt 7 geteilt durch 3 den Wert 2 mit dem Rest 1, also 7 % 3 = 1. Auf den Modulo-Operator kannst du im Matheblock im erweiterten Modus zugreifen.
Der benötigte Winkel ist der Rest der Division durch 360, also z.B. 450 % 360 = 90.
Abbildung 19-5: Die Abfolge der Blöcke im Eigenen Block Rest (links) und der fertige Eigene Block (unten rechts)
Abbildung 19-6: Wenn sich der Motor vorwärts dreht (blauer Pfeil), kann er in die Ausgangsstellung (0°) zurückkehren, indem er die aktuelle Position (hier 90°) misst und sich um diesen Winkel rückwärts dreht (grüner Pfeil). Hat der Motor mehr als eine Umdrehung zurückgelegt, muss er sich nicht ebenso oft rückwärts drehen, sondern nur um den Winkel, der über die vollständigen Umdrehungen hinausgeht (siehe rechts; 450° - 360° = 90°).
Mit anderen Worten: Die vollständigen Umdrehungen werden vom Gesamtwinkel abgezogen, sodass nur ein Winkel kleiner als eine ganze Umdrehung (also von weniger als 360 Grad) übrig bleibt. Der Mechanismus wird um diesen Restwinkel in seine Ausgangsstellung zurückgedreht.
Stelle den Block Reset wie in Abbildung 19-7 zusammen, um beide Mechanismen in die Ausgangsstellung zurücksetzen zu können.
HINWEIS Als Symbol für die Division wird im Matheblock ein Schrägstrich (/) verwendet, für die Multiplikation ein Sternchen (*). Der Modulo-Operator wird als Prozentzeichen dargestellt (%). Anstatt die Symbole einzugeben, kannst du sie auch aus der Liste auswählen, die eingeblendet wird, wenn du die Gleichung eingibst.
Damit der Roboter nach der gegenläufigen Ausrichtung der Beinmechanismen losmarschieren kann, muss er beide Motoren mit 20 % der Höchstdrehzahl vorwärts bewegen (34 U/min). Ein Bewegungslenkungsblock im Modus An scheint die richtige Wahl für diese Aufgabe zu sein, aber aufgrund von leichten Drehzahlabweichungen kann es schließlich dazu kommen, dass ein Motor hinter dem anderen zurückbleibt, sodass die beiden Beinmechanismen nicht mehr gegenläufig ausgerichtet sind. Daher musst du einen eigenen Ersatzblock erstellen, der die Motoren synchronisiert. Das heißt, dieser Block muss beide Motoren im Durchschnitt mit einer Drehzahl von 20 % bewegen und dabei sicherstellen, dass die Werte der Drehsensoren von Motor D und B (fast) gleich sind.
Abbildung 19-7: Die Konfiguration der Blöcke im Eigenen Block Return (links) und der fertige Eigene Block (rechts)
Dazu musst du den Motor, der zurückfällt, ein weniger schneller als mit 20 % laufen lassen, und den anderen ein wenig langsamer. Je weiter die Motorstellungen auseinander liegen, umso stärker muss die Drehzahlanpassung sein. Wenn beispielsweise Motor B bei 790 Grad steht und Motor D bei 750 Grad, drehst du Motor D mit 22 % und B mit 18 %, sodass D aufholen kann.
Um die Drehzahlanpassung zu berechnen (hier 2 %), musst du als Erstes den Winkel zwischen den beiden Motorstellungen bestimmen, indem du die Position von D von der von B abziehst (hier 790 - 750 = 40). Wie im Eigenen Block Return wendest du den Modulo-Operator für die Division durch 360 Grad auf diese Zahl an, denn wenn ein Motor um mehr als eine Umdrehung hinter dem anderen zurückfällt, lässt sich der Abstand viel schneller aufholen, indem du ihn nur um den Winkel drehst, der über die vollständigen Umdrehungen hinausgeht. (Dadurch erreichst du dasselbe Ergebnis mit viel weniger Aufwand.) Stelle die Blöcke wie in Abbildung 19-8 gezeigt zusammen.
Abbildung 19-8: Schritt 1: Die ersten Blöcke im Eigenen Block OnSync berechnen den Winkel zwischen den beiden Motorstellungen.
Du weißt jetzt, um welchen Winkel Motor B gegenüber Motor D vorausläuft. Manchmal ist dieser Abstand größer als 180 Grad oder kleiner als -180 Grad. In einem solchen Fall ziehst du 360 Grad von dem Wert ab, um auf einen günstigeren Winkel zu kommen. Wenn Motor B beispielsweise um 220 Grad vorläuft, rechnest du 220 - 360 = -140. Das heißt, dass Motor B um 140 Grad zurückbleibt. Da sich die Motoren im Kreis drehen, hat das dieselbe Bedeutung, macht aber eine geringere Drehzahlanpassung erforderlich, weshalb sich der Roboter gleichmäßiger bewegt.
Bei einem Abstand kleiner -180 Grad addierst du 360 Grad. Für diese Berechnungen musst du dem Programm Vergleichsblöcke hinzufügen (siehe Abbildung 19-9). Der Ausgang des ersten dieser Blöcke ist wahr (1), wenn der Winkel mehr als 180 Grad beträgt, anderenfalls falsch (0). Bei wahr subtrahiert der Matheblock 1 x 360 = 360 von dem Abstandswert, bei falsch 0 x 360 = 0, sodass der Wert unverändert bleibt. Der zweite Satz von Vergleichs- und Matheblöcken funktioniert genauso, addiert aber 360 Grad, wenn der Abstand kleiner als -180 Grad ist.
Damit hast du jetzt den Abstand zwischen den Stellungen von Motor B und D auf den kleinsten Winkel verringert. Da die Drehzahl jedes Motors bei einem Abstand von 40 Grad um 2 % angepasst werden soll, teilst du den Abstandswert durch 20. Anschließend addierst du das Ergebnis zum Drehzahlwert von Motor D und ziehst es von dem Wert von Motor B ab (siehe Abbildung 19-10). Wandle die Blöcke im Programmierbereich in einen Eigenen Block um und gib ihm den Namen OnSync (siehe Abbildung 19-11).
Abbildung 19-9: Schritt 2: Diese Blöcke verarbeiten den Abstand zwischen den Motorstellungen, um den kleinsten Winkel dazwischen zu finden. Ist der Abstand größer 180 Grad, wird 360 Grad davon subtrahiert, ist er kleiner als -180 Grad, wird 360 Grad dazu addiert.
Abbildung 19-10: Schritt 3: Um die erforderliche Änderung der Motordrehzahl zu ermitteln, teilst du den Winkel zwischen den Motorstellungen durch 20. Das Ergebnis addierst du zum Drehzahlwert von Motor D, um ihn schneller zu machen, und subtrahierst es von der Drehzahl für Motor B, sodass er sich langsamer dreht. (Dieser Block funktioniert auch dann, wenn Motor D gegenüber B vorauseilt: Der Winkel wird dann negativ, sodass Motor B schneller gemacht wird, um Motor D wieder einzuholen.)
Abbildung 19-11: Schritt 4: Wandle die Blöcke in den Eigenen Block OnSync um.
Der LAVA R3X kann sich nach links umwenden, indem er den rechten Motor rückwärts dreht, während er den linken Fuß in einer festen Position hält. Diese Position (120 Grad hinter der Ausgangsstellung) ist so gewählt, dass der linke Fuß den Boden bei jeder Umdrehung des rechten Motors gerade berührt. Der Roboter bewegt sich dabei jeweils um einen kleinen Winkel nach links. Wie groß dieser Winkel ist, hängt von der Oberfläche ab, auf der der Roboter steht. Durchschnittlich aber führen zehn Rückwärtsdrehungen des rechten Motors zu einer Drehung um etwa 90 Grad.
Damit dieser Eigene Block unabhängig von der derzeitigen Stellung der Motoren funktioniert, stellst du an seinen Anfang und sein Ende einen Return-Block. Wie du den Block Left aufbaust, siehst du in Abbildung 19-12.
Abbildung 19-12: Die Konfiguration der Blöcke im Eigenen Block Left (links) und der fertige Eigene Block (rechts)
Das Programm WalkTest greift auf die Eigenen Blöcke zurück, um den LAVA R3X wiederholt 15 s lang gehen und sich dann nach links drehen zu lassen (siehe Abbildung 19-13).
Stelle den Roboter auf eine ebene, glatte Oberfläche, z.B. einen Holzfußboden, und führe das Programm aus. Der Reset-Block zu Beginn des Programms richtet die Beine gegenläufig aus. Der Klangblock im Reset-Block spielt einen Piepser ab, um anzuzeigen, dass das Zurücksetzen abgeschlossen ist und der Roboter bereit ist, loszumarschieren. Der innere Schleifenblock mit dem OnSync-Block lässt den Roboter 15 s lang gehen, und die äußere Schleife wiederholt die Vorwärtsbewegung und die Drehung.
HINWEIS Wenn der Roboter nicht richtig zu gehen scheint, schau dir auf http://ev3.robotsquare.com/ das Video an, das zeigt, wie er funktionieren soll. Außerdem kannst du dort das fertige Programm herunterladen und mit deinem eigenen vergleichen.
Abbildung 19-13: Das Programm WalkTest
SELBST ENTDECKEN 123:
DER EIGENE BLOCK WALK
Schwierigkeitsgrad: 
Zeit: 
Kannst du einen Eigenen Block erstellen, der den Roboter eine bestimmte Zeit lang vorwärts gehen lässt? Erstelle den eigenen Block Walk mit dem numerischen Eingang Seconds wie in Abbildung 19-14.
HINWEIS Wandle den inneren Schleifenblock aus Abbildung 19-13 in einen Eigenen Block um und steuere über den numerischen Eingang, wie lange die Schleife wiederholt werden soll.
SELBST ENTDECKEN 124:
UMKEHREN
Schwierigkeitsgrad: 
Zeit: 
Kannst du den Eigenen Block OnSync so ändern, dass der LAVA R3X in der Lage ist, rückwärts zu gehen? Halte die beiden Motoren synchron, aber lass sie sich mit -20% statt 20% drehen.
HINWEIS Du musst lediglich eine Kopie von OnSync erstellen (nenne sie OnRev) und zwei Werte ändern. Welche Werte bestimmen die durchschnittliche Drehzahl der Motoren?
SELBST ENTDECKEN 125:
RECHTS UM!
Schwierigkeitsgrad: Zeit:
Erstelle den Eigenen Block Turn mit dem Logikeingang Direction (siehe Abb. 19-15). Der Roboter soll sich bei der Auswahl von wahr nach links drehen und bei false nach rechts. Baue den Block Turn im Programm WalkTest anstelle von Left ein, um ihn zu testen.
Als Nächstes baust du anhand der Anleitung auf den folgenden Seiten den Kopf und die Arme des Roboters und schließt sie an den Unterkörper an. Danach musst du sicherstellen, dass sich die beweglichen Teile des Armmechanismus nicht mit den Kabeln oben am EV3-Stein verheddern. Um das zu prüfen, drehst du die an den mittleren Motor angeschlossene Achse mit der Hand. Verlege die Kabel anders, wenn das nötig sein sollte.
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
1 
2 
3 
4 
1 
2 
3 
4 
5 
6 
7 
8 
Nachdem du den Roboter jetzt fertig gebaut hast, kannst du ein Programm schreiben, mit dem er geht, seinen Kopf und seine Arme bewegt und auf die Umgebung reagiert.
Für die Bewegung der Arme und des Kopfes sorgt der mittlere Motor: Wenn er sich vorwärts dreht, bewegen sich Kopf und Arme nach rechts, bei Rückwärtsdrehung nach links.
Um die Bewegung von Kopf und Armen einfacher steuern zu können, erstellst du einen Eigenen Block und platzierst ihn parallel zum Hauptprogramm.
Der Eigene Block Head bringt den mittleren Motor als Erstes in eine bekannte Stellung, indem er den Kopf ganz nach rechts dreht. Anschließend bewegt er den Kopf fortwährend nach links und rechts, wie Abbildung 19-16 zeigt. Dadurch kann der Infrarotsensor nicht nur Hindernisse wahrnehmen, die genau vor ihm liegen, sondern auch solche, die sich rechts und links befinden.
Abbildung 19-16: Die Konfiguration der Blöcke im Eigenen Block Head (links) und der fertige Eigene Block (rechts)
Mit den fertigen Eigenen Blöcken kannst du nun auf einfache Weise Programme schreiben, mit denen der Roboter geht und auf Sensoreindrücke reagiert. Beispielsweise kannst du den inneren Schleifenblock des Programms WalkTest so ändern, dass der Roboter nicht einfach 15 s lang vorwärts marschiert, sondern so lange, bis der Infrarotsensor ein Hindernis wahrnimmt.
Das endgültige Programm lässt den Roboter eine Weile herumlaufen und dabei Hindernissen ausweichen. Außerdem reagiert er, wenn du seine rechte Hand schüttelst, indem er anhält und: »Hello, good morning« sagt. Anschließend marschiert er weiter. Wenn der Roboter ein Hindernis erkennt, sagt er: »Detected«, und dreht sich dann nach links.
Zu Anfang bringt das Programm die Beine mit dem Reset-Block in eine gegenläufige Stellung. Dann führt es eine Schleife aus, sodass der Roboter geht und auf Sensoreindrücke reagiert.
Während der Roboter geht, bewegt er den Kopf nach links und rechts. Dazu dient der eigene Block Head, der an seinen eigenen Startblock angeschlossen ist (siehe Abbildung 19-17). Dadurch ist es möglich, Kopf und Beine unabhängig voneinander zu steuern: Du kannst das Verhalten der einzelnen Blockreihen ändern, ohne dich um die andere Reihe zu kümmern. Um die Bewegung des Kopfs zu ändern, passt du den Block Head an, und um für ein anderes Gehverhalten zu sorgen, bearbeitest du die Blöcke in der Schleife.
Erstelle das neue Programm ObstacleAvoid und füge ihm die in Abbildung 19-17 gezeigten Blöcke hinzu.
Als Nächstes fügst du der Hauptschleife Blöcke hinzu, die dafür sorgen, dass der Roboter vorwärts geht, bis er ein Hindernis erkennt oder bemerkt, dass seine Hand geschüttelt wird (siehe Abbildung 19-18).
Um nach vorn zu gehen, dreht der Roboter die großen Motoren mit dem OnSync-Block vorwärts. Dieser Block steht in einer Schleife, sodass die Motordrehzahl ständig angepasst wird, um die Motoren synchron zu halten. Diese Schleife läuft so lange, bis einer oder beide Sensoren ausgelöst werden – der Infrarotsensor, wenn er ein Hindernis erkennt, oder der Farbsensor, wenn die Hand geschüttelt wird.
Abbildung 19-17: Schritt 1: Diese Blöcke richten die Beine gegenläufig aus und drehen den Roboterkopf. Beachte, dass der Schleifenblock innerhalb von Head endlos läuft, sodass der Kopf ständig nach links und rechts pendelt.
Der Farbsensorblock erkennt einen Händedruck, indem er die Intensität des reflektierten Lichts mit einem Schwellenwert vergleicht. Ist der Sensorwert größer als 10 %, hat der Roboter deine Hand wahrgenommen, weshalb der Sensor wahr ausgibt. Bei einem Wert unter 10 % lautet der Ausgabewert falsch. Der Block für den Infrarotsensor ist ähnlich ausgerichtet und gibt bei einer Nähemessung von weniger als 50 % wahr aus, anderenfalls falsch.
Ein Logikblock vergleicht die beiden logischen Werte. Der Ausgang ist wahr, wenn wenigstens einer der beiden Eingangswerte wahr ist. In diesem Fall wird die Schleife beendet.
Der Roboter kann jetzt auf den ausgelösten Sensor reagieren. War es der Infrarotsensor, sagt der Roboter: »Detected«, und wendet sich nach links. Bei Auslösung des Farbsensors hält er vorübergehend an und sagt: »Hello, good morning!«
Wenn die Schleife beendet wurde, kannst du bestimmen, welcher Sensor dafür verantwortlich war, indem du dir den Ausgabewert des Infrarotsensorblocks ansiehst: Wenn er wahr ist, wurde der IR-Sensor ausgelöst, anderenfalls der Farbsensor. (Schließlich wurde die Schleife beendet, und wenn der IR-Sensor nicht ausgelöst worden ist, muss der Farbsensor dafür verantwortlich sein.)
Auf der Grundlage dieses Wertes entscheidest du mithilfe eines Schalterblocks, welche Blöcke ausgeführt werden sollen (siehe Abbildung 19-19).
Es ist zwar unwahrscheinlich, aber die Schleife kann auch dadurch beendet worden sein, dass beide Sensoren gleichzeitig ausgelöst wurden. In diesem Fall haben beide Sensorblöcke den Ausgabewert wahr. Da die Ausgabe des IR-Sensorblocks wahr lautet, führt das Programm einfach die Blöcke oben im Schalterblock aus, also die gleichen, die auch dann laufen, wenn nur dieser Sensor ausgelöst wurde. Mit anderen Worten, das Programm ignoriert in diesem Fall den Farbsensor.
Füge dem Schalter die Blöcke hinzu, die dafür sorgen, dass der Roboter im Fall wahr »Detected« sagt und sich nach links dreht und im Fall falsch »Hello, good morning« sagt (siehe Abbildung 19-20).
Führe das Programm aus und teste es. Wenn du zur Programmierung ein USB-Kabel verwendest, musst du den Kopf über die an den mittleren Motor angeschlossenen Zahnräder manuell nach vorn drehen, um Platz für das Kabel zu schaffen. Klicke auf die Schaltfläche Herunterladen, um das Programm an den Roboter zu senden, ziehe das USB-Kabel ab und starte das Programm manuell über die Tasten auf dem EV3-Stein.
Der Roboter wandert jetzt selbstständig umher und begrüßt dich, wenn du seine Hand schüttelst.
Abbildung 19-18: Schritt 2: Die innere Schleife sorgt dafür, dass der Roboter vorwärts geht, bis er ein Hindernis erkennt oder jemand seine Hand schüttelt.
Abbildung 19-19: Schritt 3: Der Schalterblock ermittelt, welcher Sensor die Schleife beendet hat. Wenn es der Infrarotsensor war, werden die Blöcke im oberen Teil ausgeführt (wahr), anderenfalls die Blöcke im unteren Teil (falsch).
Abbildung 19-20: Schritt 4: Der Roboter wendet sich nach links, wenn er ein Hindernis erkennt (wahr), bzw. hält an und begrüßt dich, wenn er einen Händedruck erkennt (falsch).
Damit hast du das Ende des Buchs erreicht. Herzlichen Glückwunsch! Ich hoffe, du hattest viel Spaß dabei, mehr über den Robotik-Bausatz Lego Mindstorms EV3 zu erfahren und die vorgestellten Roboterprojekte zu bauen und zu programmieren. Jetzt bist du in der Lage, eigene Roboter zu konstruieren und deine Ideen anderen mitzuteilen. Ob die Roboter nun fahren, gehen, etwas greifen oder sprechen sollen – mit Lego Mindstorms EV3 stehen dir unbegrenzte Möglichkeiten offen!
Aber bevor du dieses Buch zuklappst, solltest du das Programm für den LAVA R3X mithilfe der Selbst-entdecken-Aufgaben erweitern, um es interaktiver zu gestalten. Versäume auch nicht, dir die Bau- und Programmieranleitung für einen Roboter herunterzuladen, der Lego-Steine nach Farbe und Größe sortiert (siehe Abbildung 19-21). Du findest sie auf der Begleitwebsite zu diesem Buch auf http://ev3.robotsquare.com/.
SELBST ENTDECKEN 126:
TANZENDE ROBOTER
Schwierigkeitsgrad: Zeit:
Um zu gehen, bringt der LAVA R3X die Beinmechanismen in gegenläufige Stellung und dreht beide Motoren vorwärts. Was geschieht, wenn du beide Beine in die gleiche Stellung bringst und die Motoren dann fünf Umdrehungen lang mit einem Drehzahlwert von 10 % in entgegengesetzte Richtungen drehst? (Um die Motorsynchronisierung musst du dich dabei nicht kümmern.)
HINWEIS Wenn du die Beine mit dem Reset-Block gegenläufig ausgerichtet hast, kannst du sie ganz leicht in die gleiche Stellung bringen, indem du einen der Motoren vorwärts drehst. Um wie viele Grad musst du den Motor bewegen?
Abbildung 19-21: Noch mehr Roboter gefällig? Der BRICK SORT3R sortiert Lego-Steine nach Farbe (rot, gelb, grün und blau) und Größe (2x2 und 2x4). Die Bau- und Programmieranleitung findest du auf der Begleitwebsite zu diesem Buch.
SELBST ENTDECKEN 127:
GROSS IST DIE ABWEICHUNG?
Schwierigkeitsgrad: Zeit:
Um besser zu verstehen, wie der Block OnSync funktioniert, zeigst du die Abweichung zwischen den Motorstellungen auf dem Bildschirm an. Dazu stellst du in den OnSync-Block einen Anzeigeblock, der den Wert des letzten Matheblocks aus Abbildung 19-9 auf Seite 333 ausgibt. Anschließend platzierst du den veränderten OnSync-Block in einer Schleife, die unbegrenzt oft ausgeführt wird. Wie verhält sich die Abweichung, wenn du einen Motor manuell verlangsamst, indem du das Bein festhältst? Wie versucht der andere Motor, diese Abweichung auszugleichen? (Das darfst du nur wenige Sekunden lang machen!)
SELBST ENTDECKEN 128:
DER ROBOTER ALS AUFPASSER
Schwierigkeitsgrad: Zeit:
Kannst du den Roboter dazu bringen, dass er erkennt, wie lange du an deinem Schreibtisch arbeitest? Programmiere den LAVA R3X so, dass er die verstrichene Zeit anzeigt und dir nach einer Stunde rät, eine Pause einzulegen. Wenn er feststellt, dass du seinem Rat nicht folgst, soll er den Kopf schütteln und einen Klang abspielen, um auf sich aufmerksam zu machen.
SELBST ENTDECKEN 129:
DER ROBOTER ALS BEGLEITER
Schwierigkeitsgrad: 
Zeit:
Kannst du den Roboter so programmieren, dass er beim Gehen zu dir blickt, indem er den Kopf in die Richtung des IR-Senders dreht? Richte die Drehzahl des mittleren Motors proportional zum IR-Richtungswert ein. Dazu kannst du eine ähnliche Technik verwenden wie beim SNATCH3R (siehe Abbildung 18-20 auf Seite 308). Beachte, dass sich der Kopf des Roboters nicht einmal komplett um die eigene Achse drehen kann. Wie schränkst du den Bewegungsbereich in dem Programm ein, sodass der Roboter nicht versucht, den Kopf über den Anschlag hinaus zu drehen?
SELBST ENTDECKEN 130:
ARME UND BEINE SYNCHRONISIEREN
Schwierigkeitsgrad: Zeit:
Im Programm ObstacleAvoid bewegen sich die Arme des LAVA R3X unabhängig von der Schrittgeschwindigkeit nach links und rechts. Kannst du die beiden Bewegungen so synchronisieren, dass sich der Roboter realistischer und eleganter bewegt?
SELBST ENTDECKEN 131:
DEN ROBOTER FERNSTEUERN
Schwierigkeitsgrad: Zeit: 
Kannst du ein Programm schreiben, um den LAVA R3X fernzusteuern, sodass du ihn in jede beliebige Richtung gehen lassen kannst? Dazu kannst du die Techniken aus Kapitel 8 verwenden. Allerdings musst du auch die in diesem Kapitel vorgestellten Techniken einsetzen, damit die Beine synchronisiert bleiben. Wie sorgst du dafür, dass der Roboter losmarschiert oder sich dreht, wenn du eine Taste auf der Fernsteuerung drückst, und anhält, wenn du die Taste loslässt?
SELBST ENTDECKEN 132:
TAMAGOTCHI
Schwierigkeitsgrad: 
Zeit:
Kannst du aus dem LAVA R3X einen lebensechten Roboter machen, der unterschiedliche Stimmungen und Verhaltensweisen zeigt? Mit der Infrarotfernsteuerung kannst du den Roboter gehen, reden, essen und schlafen lassen, und mit numerischen Variablen kannst du seinen Gesundheitszustand festhalten und seinen Hunger, sein Energieniveau und seine Zufriedenheit überwachen.
Das Energieniveau soll bei jedem Schritt sinken, den der Roboter zurücklegt, und steigen, wenn du ihm befiehlst, zu schlafen. Ebenso steigt das Hungergefühl, während der Roboter geht, und sinkt, wenn du ihn fütterst. Die Zufriedenheit des Roboters nimmt langsam im Lauf der Zeit ab und steigt jedes Mal, wenn du seine Hand schüttelst.
Wenn Hungergefühl, Energieniveau oder Zufriedenheit einen kritischen Grenzwert erreichen, soll der Roboter neue Befehle ignorieren und seine eigenen Entscheidungen treffen. Wenn er beispielsweise müde ist (bei einem Energieniveau von unter 10 %), soll er eine Weile schlafen, um sich wieder zu erholen. Ist er traurig, kann er jedes Mal, wenn du ihm neue Befehle sendest, »No!« sagen und weinen.
Energieniveau, Hungergefühl und Zufriedenheit zeigst du auf dem EV3-Bildschirm an, sodass du Gesundheit und Stimmung des Roboters stets im Blick hast. Du kannst auch mit verschiedenen Arten von Verhaltensweisen experimentieren und Klänge und Lichteffekte hinzufügen, mit denen der Roboter Gefühle ausdrückt, sodass er lebensechter wirkt. Beispielsweise kannst du lachende Augen auf dem EV3-Bildschirm anzeigen, wenn der Roboter fröhlich ist, und ein Schnarchgeräusch erklingen lassen, wenn er schläft.
Das Flussdiagramm in Abbildung 19-22 kannst du als Richtschnur für die Gestaltung deines Programms verwenden. Trau dich aber ruhig, deine eigenen Ideen einzubringen.
Abbildung 19-22: Ein möglicher Ansatz für Selbst entdecken 132. Dies ist nur ein grober Überblick, der dir als Ausgangspunkt dienen soll. Jeder der hier aufgeführten Schritte kann mehrere Programmierblöcke deiner Wahl und viele Schalter- und Schleifenblöcke umfassen.
SELBST KONSTRUIEREN 30:
ZWEIBEINIGER ROBOTER
Bau: 
Programmierung: 
Kannst du ein Robotertier bauen, das sich auf zwei Beinen fortbewegt? Nimm den Oberkörper des LAVA R3X und den EV3-Stein ab, sodass nur die Beine übrig bleiben. Auf dieser Grundlage kannst du nun eine beliebige Art von zweibeinigem Roboter konstruieren. Wie wäre es mit einem Storch oder vielleicht einem Dinosaurier? Mit dem mittleren Motor kannst du den Kopf, den Schwanz und sogar die Klauen dieses Roboters steuern. Zur Steuerung der Beine verwendest du die in diesem Kapitel erstellten Eigenen Blöcke.