Almanach - rocci.net · Almanach Das Nachschlagewerk für den Robotik Unterricht herausgegeben vom...

AlmanachDas Nachschlagewerk für den Robotik Unterricht

herausgegeben vom

Robotics Competence Center Illertal e.V.www.rocci.net

1. Auflage

RoCCI e.V. Almanach 1. Auflage

Herausgeber:

Robotics Competence Center Illertal e.V.

Maiweg 2

89250 Senden

www.rocci.net

Vorstand: [email protected]

Vereinsvorsitzender: Johannes Georg Klotz

Schatzmeister: Andreas Hausladen

Schriftführer: Sebastian Polly

erweiterter Vorstand:

Benjamin Michaelis, Matthias Stocker

Autoren:

Andreas Hausladen, Johannes Georg Klotz, Daniela Koch, Jana Mäschle, Benjamin Michaelis, Sebastian Polly, Dominik Puckert, Florian Schrapp, Matthias Stocker

Lektoren:

Patrizia Di Campli San Vito, Maria Polly

© 2005 Robotics Competence Center Illertal e.V.

Jegliche Art der kommerziellen Nutzung dieses Almanachs und seiner Inhalte ist verbo-ten.

1. Auflage

Copyright: RoCCI e.V. www.rocci.net Seite 2

Dieser Almanach ist Dr. Martin Bader gewidmet.

Vorwort

Die Robotik hält nicht nur verstärkt Einzug in die deutsche Industrie und Wirtschaft,sondern auch zunehmend in die Klassenzimmer der Schulen. Nichts desto trotz ist sienoch kein reguläres Schulfach.

Das im Jahre 2002 gegründete Robotics Competence Center Illertal e.V. (RoCCI) hat essich zum Ziel gesetzt, Schülerinnen und Schülern aus dem Illertal diese Vernetzung vonPhysik, Mathematik, Informatik und einer ganzen Menge Teamwork in Form vonRobotikunterricht näher zu bringen.Hierfür bieten wir in unserem am Illertal-Gymnasium Vöhringen beheimateten Raumzahlreiche Nachmittagskurse für Schülerinnen und Schüler von der 5. bis zur 13.Jahrgangsstufe an. Derzeit wird unser Angebot von 120 Schülerinnen und Schülern aus10 Schulen wahrgenommen.

Da die Robotik oder generell ein Unterricht über und mit Robotern kein Teil des regulärenSchulunterrichts ist, fehlt es an Lehrplänen, Skripten und Lehrbüchern. Diesen Engpasshaben wir bisher mit selbst erstellten Powerpoint-Präsentationen, Folien und vereinzelt mitArbeitsblättern kompensiert.Mit diesem Almanach der Robotik wollen wir diese Lücke nun endgültig schließen. UnserZiel ist es sowohl ein unterrichtsbegleitendes Skript, als auch ein Nachschlagewerk fürunsere Schülerinnen und Schüler zur Verfügung zu stellen.

Verfasst wurde diese erste Auflage des Almanachs von den am RoCCI e.V. tätigenLehrerinnen und Lehrern im Laufe des Schuljahres 2004/2005. Da er unserenSchülerinnen und Schülern bereits zu Beginn des Schuljahres 2005/2006 zur Verfügungstehen sollte, sind einige Kapitel noch verhältnismäßig karg und knapp.Wir beabsichtigen zu Beginn eines jeden Schuljahres eine neue, überarbeitete undergänzte Auflage anzubieten. Wir freuen uns sehr über Kritik undVerbesserungsvorschläge für künftige Auflagen. Hierfür bieten wir in unserem Online-Forum unter www.rocci.net/forum/ eine Kategorie „Almanach“ für Beiträge an.

Abschließend möchten wir uns bei allen bedanken, die zur Entstehung dieses Almanachsbeigetragen haben.

Viel Spaß beim Schmökern und beim Lernen. ;-)

Euer RoCCI-Team


InhaltsverzeichnisKapitel I: Handhabungshinweise................................................................ ......9Kapitel II: Raumregeln...................................................................................10Kapitel III: Roboter.........................................................................................11

1. Definition Roboter.............................................................................................122. Beispiele...........................................................................................................143. Robotergesetze................................................................................................154. Testen..............................................................................................................16

Kapitel IV: Hardware..................................................... .................................171. Hardware allgemein.........................................................................................18

1.1. Sensorik.......................................................................................................... ....181.1.1. Einführung........................................................................... ........................181.1.2. analog vs. digital................................................................................ ..........191.1.3. aktiv vs. passiv................................................................................... ..........201.1.4. Beispiele........................................................................................ ..............20

1.2. Effektoren........................................................................... ................................211.2.1. Motoren allgemein..................................................................... ..................211.2.2. Antriebsarten..................................................................... ..........................22

1.3. Stabiler Bau.............................................................................. ..........................241.4. Zahnräder, Getriebe, Riemen......................................................... ....................25

2. Hardware Lego.................................................................................................272.1. Das RCX..................................................................................................... ........272.2. Legosensoren..................................................................................... ................28

Kapitel V: Software........................................................................................291. Software Allgemein..........................................................................................30

1.1. Umgang mit dem Laptop und dem Rechner............................................. ..........301.2. Was ist ein Compiler?......................................................................................... 301.3. Flussdiagramme................................................................... ..............................31

2. Software RoboLab............................................................................................322.1. Allgemeine Bedienung................................................................................ ........322.2. Firmware..................................................................................................... ........322.3. Motoren....................................................................................................... ........332.4. Sensoren........................................................................ ....................................35

2.4.1. Allgemeines................................................................................. ................352.4.2. Tastsensoren............................................................................................. ..352.4.3. Lichtsensoren.................................................................... ..........................362.4.4. Rotationssensoren................................................................................. ......36

2.5. Kontrollstrukturen............................................................................................ ....372.5.1. Sprünge (Jumps)....................................................................... ..................372.5.2. Verzweigungen................................................................................ ............382.5.3. Wiederholungen............................................................ ..............................39

2.6. Tasks.......................................................................................... ........................392.7. Variablen/Container.......................................................................... ..................40

3. Software NQC..................................................................................................423.1. Allgemeine Bedienung des NQC Editors............................................ ................423.2. Kurzübersicht NQC vs. RoboLab.................................................................. ......423.3. Befehlsübersicht NQC.......................................................... ..............................473.4. Firmware..................................................................................................... ........49



3.5. Motoren....................................................................................................... ........503.6. Kontrollstrukturen............................................................................................ ....51

3.6.1. Boolsche Operatoren (Bedingungen).................................. ........................513.6.2. Schleifen...................................................................................................... 52

3.6.2.1. while.......................................................................... ...........................523.6.2.2. do while..................................................................... ...........................533.6.2.3. for..................................................................................... ....................53

3.6.3. if-Abfrage......................................................................................... ............543.6.3.1. Einfache Einführung................................................................. ............543.6.3.2. if-else-Konstrukte........................................... ......................................553.6.3.3. switch............................................................ .......................................56

3.7. Sensoren........................................................................ ....................................583.7.1. Definieren............................................................................ ........................583.7.2. Auslesen.................................................................................................... ..593.7.3. Polly'sche Kombination........................................................................ ........59

3.8. Makros................................................................................................ ................593.9. Funktionen............................................................................................ ..............603.10. Tasks........................................................................................ ........................61

Kapitel VI: Übungsaufgaben..........................................................................621. Programmieraufgaben......................................................................................63

1.1. Aufgabe 1......................................................................... ..................................631.2. Aufgabe 2......................................................................... ..................................631.3. Aufgabe 3......................................................................... ..................................631.4. Aufgabe 4......................................................................... ..................................631.5. Aufgabe 5......................................................................... ..................................631.6. Aufgabe 6......................................................................... ..................................631.7. Aufgabe 7......................................................................... ..................................631.8. Aufgabe 8......................................................................... ..................................641.9. Aufgabe 9......................................................................... ..................................641.10. Aufgabe 10: Roboter-Fußball................................. ..........................................641.11. Aufgabe 11..................................................................... ..................................65

2. Mechanik..........................................................................................................662.1. Anfänger............................................................................................. ............662.2. Fortgeschrittene Anfänger.......................................................... ....................672.3. Fortgeschrittene.......................................................................................... ....68

Kapitel VII: Musterprüfungen.........................................................................69Kaptiel VIII: Fachbegriffe.............................................................................. ..74Stichwortverzeichnis......................................................................................76


RoCCI e.V. Almanach 1. AuflageKaptiel I Handhabungshinweise

Kapitel I: HandhabungshinweiseDieser Almanach ist für zwei Kursstufen gedacht:

• Anfänger

• fortgeschrittene Anfänger

Fortgeschrittene Anfänger sollten im Prinzip alle Inhalte dieses Almanaches beherr-schen.

Anfänger sollten nach einem Jahr folgende Kapitel beherrschen:

• Kapitel III Roboter

• Kapitel IV 1.1. Sensorik

• Kapital IV 1.2.2. Antriebsarten

• Kapitel IV 1.3. Stabiler Bau

• Kapitel IV 1.4. Zahnräder, Getriebe, Riemen

• Kapitel V 1.1. und 1.2.

• Kapitel V 2. RoboLab


RoCCI e.V. Almanach 1. AuflageKaptiel II Raumregeln

Kapitel II: RaumregelnRegeln für den RoCCI-Raum

Damit der RoCCI-Raum für alle sauber und in einem benutzbarenZustand bleibt, haben wir folgende Regeln für den RoCCI-Raumaufgestellt.

1. Den Raum sauber halten.Nach jeder Unterrichtsstunde (auch wenn eine andere direkt imAnschluss folgt) muss der Raum aufgeräumt werden. SämtlicheLegoteile vom Boden aufheben. Regelmäßig kehren!

2. Kein Essen, kein TrinkenAusnahme: verschließbare Getränkeflaschen dürfen mitge-bracht werden, aber keine Getränke in der Nähe der Rechneroder Notebooks!Essen ist grundsätzlich verboten.

3. Das Inventar, vor allem die Rechner undNotebooks, sorgfältig behandelnEs liegt in eurem Interesse, dass die Rechner, etc. in einem gu-ten Zustand bleiben, da ihr mit diesen arbeiten müsst. BeiBeschädigungen müssen wir sonst die Kursgebühren erhöhen.

4. Nichts aus dem Raum mit nach HausenehmenDies gilt insbesondere für die Notebooks und Rechnerzubehör.Robotikkästen dürfen nur nach Rücksprache mit dem jeweiligenLehrer mit nach Hause genommen werden.

5. Nicht den Notausschalter betätigen!


RoCCI e.V. Almanach 1. AuflageKaptiel III Roboter

Kapitel III: RoboterInhaltKapitel III: Roboter.........................................................................................11

1. Definition Roboter.............................................................................................122. Beispiele...........................................................................................................143. Robotergesetze................................................................................................154. Testen..............................................................................................................16



1. Definition RoboterVorgeschichte

Schon im frühen Mittelalter hat die Menschheit damit begonnen von „automatischen Hel-fern“ zu träumen. Bis Mitte des 20. Jahrhunderts gab es immer wieder Versuche einesolche Maschine zu bauen, jedoch hatten diese Wunderwerke nie eine praktische Be-deutung.

Mechanische Hand von Ambroise Paré:

Der große französische Arzt Ambroise Paré (1510 - 1590)machte sich darüber Gedanken, wie man die menschlicheHand durch eine mechanische Vorrichtung ersetzen könn-te. Die aufgeschnittene Hand aus den „Dix livres de chirur-gie“ (Paris 1564) zeigt eine den menschlichen Muskelnentsprechende mechanische Vorrichtung.

Vaucanson-Ente:

Vaucanson (1709 - 1782) war von der Idee gepackt , einenkünstlichen Menschen zu schaffen. Aber sein Ziel schienzu weit gesteckt. Schließlich reduzierte er seinen Traum:

Er baute einen Enterich. Sein Automatenerpel schlug mitden Flügeln, schnatterte, trank Wasser und pickte Körner.Diese wurden mit chemischen Stoffen "verdaut" und alsentengemäßes Abfallprodukt wieder hergegeben.1

Als Geburtsjahr für den praktischen Einsatz von Robotern, d.h. für die Erfindung des In-dustrieroboters, gilt das Jahr 1956. George C. Devor beantragte in diesem Jahr ein US-Patent für die "Programmierte Übergabe von Artikeln". Der erste Prototyp wurde 1958von der "Devol Consolidated Control Corporation" gebaut. Die ersten serienmäßigen In-dustrieroboter stellte dann Anfang der 60er Jahre die Firma Unimation her. Die anfäng-lich nur zögerliche Reaktion der Industrie in den USA und den anderen Industrieländernänderte sich erst, als Japan 1968 massiv in das Robotergeschäft einstieg. Seit dem gehtdie Entwicklung und der Einsatz von Industrierobotern steil bergauf.

1 Hesse S. : Golems Enkel, Urania Verlag Leipzig/Jena/Berlin 1986



Herkunft des Begriffs „Roboter“:

Roboter [zu tschechisch robota „Frondienst“], eine erstmals 1921 von K.Čapek (1890 – 1938) in seinem Roman „Rossum's Universal Robots“ verwendete Be-zeichnung für selbstbewegliche Automaten, deren äußere Form mehr oder wenigerstark der menschlichen Gestalt nachgebildet ist (Maschinenmensch, Android) und diegewisse manuelle Funktionen eines Menschen ausführen können.2

2 Mayers Großes Taschenlexikon



2. Beispiele



3. RobotergesetzeIn den 40er Jahren des 20. Jahrhunderts formulierte der Science-Fiction-Autor IsaacAsimov in einem seiner zahlreichen Romane seine Robotergesetze.

Asimovs „Robotergesetze“:

§1 Ein Roboter darf keine Menschen verletzen oder durchUnterlassen die Verletzung eines Menschen zulassen.(Sicherheit)

§2 Ein Roboter muss den Anweisungen von Menschengehorchen, außer sie stehen in Konflikt mit §1(Verlässlichkeit)

§3 Ein Roboter muss seine eigene Existenz schützen,außer diese steht im Konflikt zu §1 oder §2.(Verfügbarkeit)

Diese erfreuen sich bis heute großer Bekanntheit (z.B. auch im Hollywood-Film „I, Ro-bot“ mit Will Smith), besitzen jedoch eine weitaus größere Bedeutung als man auf denersten Blick vermuten würde. Jeder Roboter, vom Industrieroboter bis zum Lego-Fuß-ballroboter, muss für seine Anwender und die Menschen in seiner Umgebung sicher,verlässlich und verfügbar im Sinne der Asimov'schen Gesetze sein.

Deutlich wird dies z.B. bei einem schlichten Lego-Fußballroboter schon dadurch, dass erso gebaut sein muss, dass man sich nicht daran verletzen kann, z.B. muss man daraufachten, dass man sich nicht die Finger im Dribbler einklemmen kann oder, dass dieSchussmechanik zu stark ist.

Immer wieder wird darauf hingewiesen, dass diese Gesetze zu Paradoxien führen undinnere Widersprüche aufweisen. Zahlreiche Bücher und Filme greifen die daraus ent-stehenden Konflikte auf, um daraus spannende und zum Nachdenken anregende Plotszu konstruieren. Auf diese Widersprüche möchten wir aber an dieser Stelle nicht einge-hen.



4. TestenWarum testen?

Große Projekte oder Programme werden oft aus verschiedensten Gründen in kleinereUntereinheiten aufgeteilt. Um die reibungslose Funktion auch nach dem Zusammen-fügen zu gewährleisten, sollten alle Untereinheiten ausführlich getestet werden.

Prinzipiell sollte ein Roboter vor einem Einsatz, z.B. auf dem RoboCup ausführlich ge-testet werden!

Durch mangelhaftes Testen kam auch die europäische RaketeAriane 5 zum Absturz. Die Entwickler haben Software des Vor-gängermodells Ariane 4 verwendet. Diese Software war abernicht auf die größeren Ausmaße der Rakete ausgelegt. Daherkam es zu einem Variablenüberlauf, was den Bordcomputerund die Backupsysteme zum Absturz brachte. Da die Raketenun manövrierunfähig war, musste sie gesprengt werden.Wäre die Software für die Ariane 5 ausführlich getestetworden, hätte dieser Absturz verhindert werden können.

Was ist Testen?

Testen ist nicht: „Schau mer mal ob es funktioniert“! Man kann nie mit 100% Sicherheitsagen, ob der Roboter oder das Programm funktioniert. Testen ist die gezielte Suchenach Fehlern und deren Behebung.

Wie teste ich richtig?

• Versuche unabhängige Tester zu finden (Es sollte nach Möglichkeit nicht derjenigetesten, der das Programm geschrieben hat...)

• Überlege dir Testfälle und probiere sie aus.

• Dokumentiere deine Tests und die Ergebnisse.

• Speichere getestete und funktionierende Programme ab und hebe sie auf, um even-tuell später darauf zurückgreifen zu können.


RoCCI e.V. Almanach 1. AuflageKaptiel IV Hardware

Kapitel IV: HardwareInhaltKapitel IV: Hardware..................................................... .................................17

1. Hardware allgemein.........................................................................................181.1. Sensorik.......................................................................................................... ....18

1.1.1. Einführung........................................................................... ........................181.1.2. analog vs. digital................................................................................ ..........191.1.3. aktiv vs. passiv................................................................................... ..........201.1.4. Beispiele........................................................................................ ..............20

1.2. Effektoren........................................................................... ................................211.2.1. Motoren allgemein..................................................................... ..................211.2.2. Antriebsarten..................................................................... ..........................22

1.3. Stabiler Bau.............................................................................. ..........................241.4. Zahnräder, Getriebe, Riemen......................................................... ....................25

2. Hardware Lego.................................................................................................272.1. Das RCX..................................................................................................... ........272.2. Legosensoren..................................................................................... ................28



1. Hardware allgemein1.1. Sensorik

1.1.1. Einführung

Ein Sensor nimmt physikalische Phänomene seiner Umwelt wahr und wandelt diese inelektrische Signale um.

Die vom Sensor erzeugten elektrischen Signale werden an die angeschlossene Rechen-einheit (z.B. RCX) weitergeleitet.

Alle Sensoren können in aktiv oder passiv und in analog oder digital eingeteiltwerden.


Sensor wie zum Beispiel:Lichtsensor, Bumper,

Lichtschranke, ...

Physikalisches Phänomen wie zum Beispiel: Licht, Schall,Temperatur, Gewichtskraft,

Magnetfelder, ...

Elektrisches Signal


1.1.2. analog vs. digital

Digitale Sensoren haben nur zwei Zustände. Ein Bumper ist zum Beispiel entweder ge-drückt oder nicht gedrückt.

Im Zeit-Spannungsdiagramm ist zu sehen, dass am Ausgang eines digitalen Sensorsentweder die maximale Spannung oder gar keine Spannung anliegt.

Analoge Sensoren dagegen haben eine unbegrenzte Anzahl von Zuständen, die le-diglich durch das Abtastungsverfahren (Quantisierung) limitiert werden. Ein Lego-Lichtsensor zum Beispiel gibt je nach Helligkeit verschiedene Werte an den Controllerweiter.

Das Zeit-Spannungsdiagramm zeigt, dass am Ausgang des analogen Sensors eine Viel-zahl von Spannungen anliegen kann.


Vcc

WiderstandSignal

Sensor

USignal

Vcc

WiderstandSignal

Sensor

USignal

0

12 3

4


1.1.3. aktiv vs. passiv

Unabhängig davon, ob ein Sensor analog oder digital ist, lässt er sich weiter unter-scheiden:

Aktive Sensoren verändern ihre Umwelt aktiv (z.B. durch einen Sender), um die ge-wünschte Messung durchzuführen.

Passive Sensoren nehmen Umweltphänomene auf, ohne auf diese einzuwirken.

1.1.4. Beispiele

Beachte: „aktiv vs. passiv“ hat nichts mit „analog vs. digital“ zu tun!


Umgebung

Empfänger

Sender

Umgebung Empfänger

BumperLichtschrankedigital

TemperatursensorMagnetfeldsensor

Lego-IR-SensorAbstandsmesser

analog

passivaktiv


1.2. Effektoren

1.2.1. Motoren allgemein

Gleichstrommotor

Je nach Anschluss des Plus- bzw. Minuspols dreht sich der Motor links oder rechts her-um. Die Drehgeschwindigkeit hängt von der angelegten Spannung ab.

Diese Art von Motoren zeichnet sich besonders durch einfache Ansteuerung, hohe Leis-tungsfähigkeit, ein großes Angebot an verschiedenen Motoren und den relativ günstigenPreis aus. Einen Nachteil stellt jedoch die sehr geringe Präzision dar. Außerdem gibt eskeine Möglichkeit der Wegkontrolle. Der Motor kann nur eine gewisse Zeit ein-, bzw.ausgeschaltet werden. Wenn er in dieser Zeit blockiert wird oder durchdreht wird diesnicht berücksichtigt. Man bekommt keine Rückmeldung, ob der gewünschte Weg auchtatsächlich zurückgelegt wurde.

Schrittmotor


Abbildung 1. Schema eines Gleichstrommotors

Abbildung 2. Schema eines Schrittmotors - ist invier Schritten fertig


Ein Schrittmotor ist ein Gleichstrommotor, bei dem der Rotor (drehbares Motorteil mit derWelle) bei geschickter Wahl der angesteuerten Statorspulen (nichtdrehbarer Motorteil)gezielt um einen Winkel gedreht werden kann. Auf diese Weise kann man in mehrerenSchritten jeden Drehwinkel, wenn er ein Vielfaches des minimalen Drehwinkels ist,anfahren.

Da Schrittmotoren (solange sie nicht überlastet werden) exakt dem außen angelegtenFeld folgen, können sie ohne Sensoren zur Positionsrückmeldung (Encoder, Drehgebero.ä.) genutzt werden (Synchronmotorverhalten). Daher können sie im Gegensatz zu Ser-vomotoren gesteuert betrieben werden. Servos müssen auf Position geregelt werden.

Der Schrittmotor weist die selben positiven Eigenschaften wie der Gleichstrommotor auf.Zusätzlich besteht die Möglichkeit die gewünschte Position sehr präzise anzusteuern.

Servomotor

Ein Servomotor ist ein Elektromotor, der nur bestimmte vorgegebene Winkel ansteuernkann und diese Winkelpositionen auch bei Gegendruck halten kann. Dies wird über einspezielles Getriebe realisiert. Damit ist eine sehr präzise und auch sehr schnelle An-steuerung der gewünschten Position möglich.

1.2.2. Antriebsarten

Roboter mit Rädern:

Autoantrieb

Tricycle


Lenken + FahrenLeerlauf

LenkenFahren


Synchronantrieb

Omnidirektionaler Antrieb

Roboter mit Ketten:

● Auf unebenem Gelände besser einsetzbar

● Höhere Reibung

● Schwieriger zu bauen

● Kann keine Treppen steigen

Roboter mit Beinen:

● Können Treppen steigen

● Sehr viel größerer Konstruktionsaufwand

● Schwieriger zu kontrollieren und zu programmieren


120°

Alle Räder

lenken und fahren


1.3. Stabiler BauEine wesentliche Eigenschaft eines guten Roboters ist seine Stabilität. FolgendeRatschläge können Dir helfen deinen Roboter zu verbessern.

• Bauteile so verbauen, dass sie nicht abbrechen oder wegfallen können

• Einzelne Bauteile nicht direkt übereinander, sondern versetzt anbringen

• Querverbindungen von Trägern schaffen zusätzliche Stabilität (Abb. 3)

• Plattformen bilden stabile Strukturen (Abb. 4)

• Falls möglich den Roboter mit einem Griff zum Hochheben versehen

„10 cm Test“

Zur schnellen Überprüfung der Stabilität eines Roboters kann der „10 cm Test“ dienen.Hierbei wird der Roboter angehoben und muss einen freien Fall aus 10 cm Höhe unbe-schadet überstehen.


Plattform

Abbildung 4Abbildung 3


1.4. Zahnräder, Getriebe, RiemenZahnräder:

Bei einer Untersetzung nimmt die „Geschwindigkeit“ ab, die „Kraft“ jedoch zu.

Bei einer Übersetzung nimmt die „Geschwindigkeit“ zu, die „Kraft“ jedoch ab.

Getriebe:

Es können auch mehrere Zahnräder miteinander kombiniert werden; dann spricht manvon einem Getriebe.


Untersetzung

Zahnrad (8 Zähne) der Motorachse

Zahnrad (24 Zähne) der Radachse

Zahnrad der Radachse

Übersetzung

Zahnrad der Motorachse


Riemen:

• Man kann die Riemenscheiben wie Zahnräder benutzen.

• Während zwei Zahnräder immer entgegengesetzte Drehrichtung haben, drehen sichzwei Riemenscheiben, die durch einen Keilriemen verbunden sind, immer in die glei-che Richtung.

• Im Gegensatz zu den Zahnrädern kann man bei den Riemenscheiben aufgrund desSchlupfes (zwischen Riemenscheibe und Keilriemen) kein Übersetzungsverhältnisangeben.

Vorteil der Riemenscheibe-Keilriemen-Konstruktion gegenüber Zahnrädern:

Kann der Motor, aus welchem mechanischen Grund auch immer, sich nicht weiter dre-hen, obwohl er angeschaltet ist, so wird der Motor bei der Zahnräder-Konstruktion sehrstark belastet (Abwürgen des Motors). Bei der Riemenscheibe-Keilriemen-Konstruktionverhindert der Schlupf eine zu große Belastung des Motors.

Nachteil der Riemenscheibe-Keilriemen-Konstruktion gegenüber Zahnrädern:

Aufgrund des Schlupfs bei der Riemenscheibe-Keilriemen-Konstruktion kann die Bewe-gung nicht genau vorausbestimmt werden. Bei der Zahnräder-Konstruktion kann die Be-wegung vorausbestimmt werden.


Riemenscheibe

Keilriemen


2. Hardware Lego2.1. Das RCX

Infra-Rot-Schnittstelle: Mit dieser Schnittstelle, kann das Programm über den USB-Tower auf das RCX geladen werden.

View Taste: Hiermit können die Werte der Sensoren ausgelesen werden. Ein kleinerPfeil im Display zeigt an, welcher Sensorwert ausgewählt ist.

Prgm Taste: Hiermit kann zwischen den auf dem RCX gespeicherten Programmen ge-wechselt werden. Das momentan ausgewählte Programm wird auf dem Display ange-zeigt. Auf dem RCX können bis zu 5 Programme gleichzeitig gespeichert werden;abhängig von Firmware und Programmgröße.

Run Taste: Startet das ausgewählte Programm.

Motor-Ausgänge: Die Motoren werden an den Motorausgängen (A,B,C) ange-schlossen.

Sensor-Eingänge: Die Eingänge der Sensoren sind mit 1, 2 und 3 bezeichnet.



2.2. Legosensoren

Misst ... Art Werte Besonderheit

IR-Lichtsensor Infrarotlicht Aktiv, Analog 0 % bis 100 %

IR-Lichtsensorohne Sendediode

Infrarotlicht Passiv, Analog 0 % bis 100 % Sendet keinIR-Licht mehr

Bumper Berührung Passiv, Digital 0 oder 1

Rotationssensor Umdrehung/ Rotation

Passiv, Analog -∞ bis +∞

Temperatursensor Temperatur Passiv, Analog -20°C bis +50°C

Magnetfeldsensor Erd-magnetfeld

Passiv, Analog 0 bis 79 Muss richtiggepolt ange-

schlossenwerden


RoCCI e.V. Almanach 1. AuflageKaptiel V Software

Kapitel V: SoftwareInhaltKapitel V: Software........................................................................................29

1. Software Allgemein..........................................................................................301.1. Umgang mit dem Laptop und dem Rechner............................................. ..........301.2. Was ist ein Compiler?......................................................................................... 301.3. Flussdiagramme................................................................... ..............................31

2. Software RoboLab............................................................................................322.1. Allgemeine Bedienung................................................................................ ........322.2. Firmware..................................................................................................... ........322.3. Motoren....................................................................................................... ........332.4. Sensoren........................................................................ ....................................35

2.4.1. Allgemeines................................................................................. ................352.4.2. Tastsensoren............................................................................................. ..352.4.3. Lichtsensoren.................................................................... ..........................362.4.4. Rotationssensoren................................................................................. ......36

2.5. Kontrollstrukturen............................................................................................ ....372.5.1. Sprünge (Jumps)....................................................................... ..................372.5.2. Verzweigungen................................................................................ ............382.5.3. Wiederholungen............................................................ ..............................39

2.6. Tasks.......................................................................................... ........................392.7. Variablen/Container.......................................................................... ..................40

3. Software NQC..................................................................................................423.1. Allgemeine Bedienung des NQC Editors............................................ ................423.2. Kurzübersicht NQC vs. RoboLab.................................................................. ......423.3. Befehlsübersicht NQC.......................................................... ..............................473.4. Firmware..................................................................................................... ........493.5. Motoren....................................................................................................... ........503.6. Kontrollstrukturen............................................................................................ ....51

3.6.1. Boolsche Operatoren (Bedingungen).................................. ........................513.6.2. Schleifen...................................................................................................... 52

3.6.2.1. while.......................................................................... ...........................523.6.2.2. do while..................................................................... ...........................533.6.2.3. for..................................................................................... ....................53

3.6.3. if-Abfrage......................................................................................... ............543.6.3.1. Einfache Einführung................................................................. ............543.6.3.2. if-else-Konstrukte........................................... ......................................553.6.3.3. switch............................................................ .......................................56

3.7. Sensoren........................................................................ ....................................583.7.1. Definieren............................................................................ ........................583.7.2. Auslesen.................................................................................................... ..593.7.3. Polly'sche Kombination........................................................................ ........59

3.8. Makros................................................................................................ ................593.9. Funktionen............................................................................................ ..............603.10. Tasks........................................................................................ ........................61



1. Software AllgemeinSoftware bezeichnet alle nichtphysischen Funktionsbestandteile eines Computers bzw.Roboters. Dies umfasst vor allem Computerprogramme sowie die zur Verwendung mitComputerprogrammen bestimmten Daten.

Mit Software wird die Logik, die durch die Hardware ausgeführt werden soll, realisiert.Sie steuert die Hardware an.

1.1. Umgang mit dem Laptop und dem Rechner• Mit Notebooks und Rechnern allgemein behutsam umgehen

• Keine Tasten herausbrechen

• Steckverbindungen behutsam ein- und ausstecken und auf die Pins achten (z.B. beiMaus, Tastatur und USB-Tower)

• Nicht mit den Fingern auf den Notebookbildschirmen herumfahren

• Essen und Trinken in Nähe der Notebooks und Rechnern ist untersagt

• Diskettenlaufwerke und CD-ROM Laufwerke sind nur für Disketten bzw. CDs da

• Computer nicht während des Betriebs ausschalten

• Die Bildschirme der Notebooks sind nicht zum ständigen Auf- und Zuklappen da

• Notebooks ausschalten bevor sie aufgeräumt werden

• Notausschalter im Robotikraum wird nur von Lehrkräften oder im Notfall betätigt

Bei grober Zuwiderhandlung erfolgt der Ausschluss aus dem Verein!

1.2. Was ist ein Compiler?Ein Compiler (auch Kompilierer oder Übersetzer) ist ein Computerprogramm, das einin einer Quellsprache geschriebenes Programm in eine für den Prozessor verständlicheSprache, die Maschinensprache, übersetzt. Es gibt für unterschiedliche Programmier-sprachen entsprechende Compiler.

Beispiele für Compiler sind C/C++ Compiler unterschiedlicher Hersteller oder auch derNot Quite C Compiler (NQC). Wobei der NQC Compiler nicht nur ein Compiler ist, son-dern auch die Aufgabe des Downloads übernimmt.



1.3. FlussdiagrammeMit Hilfe eines Flussdiagramms kann man den Ablauf eines Programms grafisch dar-stellen. Es besteht aus Aktionen (Kästchen) und Verzweigungen (Rauten). Diese werdenmit Pfeilen verbunden, die die Ablaufrichtung, den Fluss, anzeigen. Die einzelnen Ak-tionen können wieder mit Flussdiagrammen spezifiziert werden, was die Diagrammesehr übersichtlich macht, da nur die nötigen Aktionen und Verzweigungen für den ent-sprechenden Teilabschnitt des Programms benötigt werden.

Der Text einer Aktion beschreibt die Aktion in einem oder mehreren markanten Worten.Eine Aktion kann mehrere eingehende Pfeile besitzen, aber nur einen ausgehenden.Eine Verzweigung besitzt als Text die Bedingung die erfüllt oder nicht erfüllt werden soll.Sie besitzt neben mehreren eingehenden Pfeilen auch mehrere ausgehende Pfeile, diemit den entsprechenden Verzweigungsbedingungen beschriftet sind.

Die Flussdiagramme geben die Logik, die das Programm verfolgt, an, ohne auf die Im-plementierungsdetails einzugehen.

Beispiel für ein Flussdiagramm:

Das folgende Programm soll einen Text nach dem Buchstaben „A“ durchsuchen undnach dem ersten gefundenen „A“ den Text „Gefunden“ ausgeben.

Flussdiagramme lassen sich sehr leicht in einen Quellcode übertragen.Eine einfache Beispiel-Implementierung:

int main(){

while (true){

if (BuchstabeAGefunden()){ // Buchstabe A gefunden: Ja

Ausgabe("Gefunden"); // Ausgabe von "Gefunden"break; // while verlassen um Programm zu beenden

}else{ // Buchstabe A gefunden: Nein

NaechsterBuchstabe();}

}}


Start

Ausgabe von„Gefunden“

NächsterBuchstabe

Buchstabe Agefunden

ja

nein


2. Software RoboLab2.1. Allgemeine Bedienung

Starten und weiter ... :

➔ Zum Starten Doppelklick auf die RoboLab-Verknüpfung aufdem Desktop

➔ Auf „Programmer“ klicken

➔ Inventorlevel wählen

➔ Fenster (das untere) maximieren

➔ Umschalten in den Standard-Maus-Modus(LEERTASTE)

➔ Musterprogramm markieren

➔ Musterprogramm löschen (Entf)

➔ Und jetzt kann losprogrammiert werden ...

Wichtige Tastenkombinationen:

➔ LEERTASTE: Umschalten zwischen der Standard-Maus und der „Kabeltrommel“

➔ Strg + C: Markierte Programmteile werden in die Zwischenablage kopiert

➔ Strg + V: Zuvor kopierter Programmteil wird ins Programm eingefügt

➔ Durch „kopieren“ und „einfügen“ können Programmteile vervielfältigt (also tat-sächlich kopiert) werden

➔ Entf: Markierten Programmteil löschen

2.2. FirmwareDie Firmware ist das Betriebssystem des RCX. Sie muss bei der ersten Inbetriebnahmedes RCX oder bei jedem Batteriewechsel auf das RCX übertragen werden.

TIPP: Dieser Vorgang nimmt einige Minuten in Anspruch. Bei Wettkämpfen daher immerfrühzeitig den Batterienstatus kontrollieren, weil zusätzlich zu der Zeit, die das Wechselnder Batterien kostet, auch noch die Firmware eingeplant werden muss.

Übertragen der Firmware:

➔ RoboLab starten

➔ Auf „Administrator“ klicken

➔ Auf „Download Firmware“ klicken

TIPP: Wenn mehrere Übertragungen gleichzeitig stattfinden, kann es sein, dass Stö-rungen auftreten. Daher kann es nötig sein, die Sichtverbindung zwischen den jeweiligenRobotern und Übertragungstowern abzuschirmen. Hier bieten sich z.B. der Deckel derLego-Kits-Verpackung an.



2.3. MotorenEinfache Anweisungen

Damit der Roboter Bewegungen vollziehen kann, müssen Motoren programmiertwerden. Dabei muss man noch unterscheiden, ob sich der Motor nach links oder nachrechts drehen soll. Das kann man zunächst recht einfach einstellen indem man die Mo-torstecker anders an das RCX steckt, oder im Programm die Drehrichtung festlegt.

Jeder Motor besitzt in RoboLab zwei Sym-bole, je eines für Rechts- und eines fürLinksdrehung. Welches davon den Motornach rechts drehen lässt, hängt davon abwie der Motor angesteckt ist.

Wird ein Motor einmal angeschaltet, bleibter unendlich lange an. Er muss daherwieder ausgeschaltet werden. Dies ge-schieht mit dem roten Stop-Symbol nebendem entsprechenden Motor.

Weitere Möglichkeiten

In Inventor 2 bietet sich die Möglichkeit, mehrere Motoren mit nur einer Anweisunglaufen zu lassen. Dazu einfach das Motorensymbol ohne Buchstabe verwenden unddann den Buchstaben nachträglich anheften. Beispiel:



Die Buchstaben für die Motoren sind zunächst versteckt. Klicke unten rechts auf „Modi-fiers“, dann öffnet sich ein neues Fenster mit den Motornamen.

Inventor 2 bringt uns einen weiteren Fortschritt. Nun ist es möglich, die Motorgeschwin-digkeit einzustellen. Klicke dazu wieder unten rechts auf das Symbol „Modifiers“ und estaucht eine neue Palette auf.

Die Geschwindigkeiten (von 1 bis 5) lassen sich am Motor unten rechts anheften. 1 be-deutet sehr langsam, 5 bedeutet maximale Power.

Es ist ratsam die Motorgeschwindigkeit behutsam zu drosseln, da der Motor sich da-durch nicht nur langsamer, sondern auch schwächer dreht.

In Inventor 4 gibt es noch die Möglichkeit, einen Motor „auslaufen“ zu lassen.

Float Motor (es muss durch einen Buchstaben angegeben werden welcher Motor!):

Unterscheide also:

Stop = Motor bleibt sofort stehen

Float = (nur Inventor 4!) Motor schaltet sich aus und dreht sich bis zum Stillstand weiter



2.4. Sensoren

2.4.1. Allgemeines

Die in den nachfolgenden Kapiteln aufgeführten Sensorsymbole werden wie folgt be-schaltet:

2.4.2. Tastsensoren

Beachte: Tastsensoren werden auch Bumper oder Berührungssensoren genannt.

Bei einem Berührungssensor gibt es genau zwei Zustände, gedrückt oder nicht ge-drückt. Diese werden mit Hilfe zweier Zahlenwerte vom Mikrocontroller verarbeitet. Es istein digitaler Sensor.

Zustand 1: Bumper wird gedrückt

Zustand 2: Bumper wird losgelassen (muss davor gedrückt sein!)


Zum vorherigenSymbol

An den blauen Anschlusskann man eineKonstante, aber auch denWert eines anderen Sen-sors oder den Inhalteines Containers an-schließen

Hier wird der Sen-soreingang fest ge-legt.

Hier geht es zumnächsten Sym-bol im Pro-grammablauf


2.4.3. Lichtsensoren

Auch IR-Sensoren genannt.

Der Lichtsensor ist der einzige aktive Lego-Sensor. Er emittiert und detektiert rotesLicht. Er ist analog und übermittelt Werte zwischen 0 und 100.

verschiedene Anwendungsmöglichkeiten mit den entsprechenden Symbolen:

Wartet, bis die Umgebung um einen bestimmten

Wert dunkler wird. (Level 2)

Wartet, bis die Umgebung um einen bestimmten

Wert heller wird. (Level 2)

Wartet, bis das Umgebungslicht unter einen

bestimmten Wert sinkt. (Level 4)

Wartet, bis das Umgebungslicht einen

bestimmten Wert übersteigt. (Level 4)

2.4.4. Rotationssensoren

Der Rotationssensor kommt sehr selten zum Einsatz, kann aber sehr nützlich sein, zumBeispiel bei der Positionsbestimmung.

Bei einer Drehung um 22,5° wird der Wert um 1 erhöht. Bei einer ganzen Umdrehungbeträgt der Wert dann also 16.



2.5. Kontrollstrukturen

2.5.1. Sprünge (Jumps)

Soll ein Programmteil mehrmals wiederholt werden, kommen Schleifen zum Einsatz. Ro-boLab unterscheidet zwischen zwei Arten von Schleifen.

Bei Loops (Wiederholungen) kann eingestellt werden, wie oft sich die Schleife wieder-holt. Näheres zu Loops in V.2.5.3

Die hier behandelten Schleifen werden auch Jumps (Sprünge) genannt. Wenn das RCXbei der Ausführung des Programms zu einer Absprungstelle (Pfeil nach oben) kommt,springt es zu der farblich passenden Landungstelle (Pfeil nach unten).

Achtung:

Teile des Programms, die sich hinter einer Absprungstelle befinden, werden in der Regelniemals ausgeführt!

Ein Beispielprogramm:

=> Wird unendlich oft wiederholt.



2.5.2. Verzweigungen

Je nachdem, welche Bedingung bei den Verzweigungen (bei RoboLab auch Forks ge-nannt) erfüllt wird, erfolgt eine entsprechende Anweisung. Aus diesem Grund kann manvon einer Art Fallunterscheidung sprechen.

Für den Bumper gilt folgendes Symbol:

Fall 1: Wenn Schalter nicht gedrückt ist, dann ...

Fall 2: Wenn Schalter gedrückt ist, dann ...

Ähnlich funktioniert die Verzweigung für den Lichtsensor

Fall 1: Wenn ein bestimmter Helligkeitswert überschritten ist, dann ...

Fall 2: Wenn ein bestimmter Helligkeitswert unterschritten ist, dann ..

Es gibt noch weitere Verzweigungen, die aber im Prinzip genauso funktionieren.

Beachte: Den obigen Forks fehlt noch eine Sensorzuweisung (1, 2 oder 3), außerdemmuss dem Fork des Lichtsensors noch ein Helligkeitswert angeheftet werden.

Die beiden Äste eines Forks müssen immer mit einem „Fork Merge“ wieder zu-sammengeführt werden.

Vereinigt die beiden Äste.



2.5.3. Wiederholungen

Wiederholungen (Loops) sind Schleifen, die im Grunde wie Jumps (siehe 2.5.1.)funktionieren. Einziger Unterschied: Man kann definieren, wie oft sich der jeweilige Pro-grammteil wiederholen soll.

Auch Loops bestehen aus zwei Symbolen, die den zu wiederholenden Programmteil um-schließen.

Hier ein Beispielprogramm: Der dunkelgraue markierte Bereich wird sechs mal wieder-holt.

2.6. Tasks

Tasks sind Anweisungseinheiten, die gleichzeitig ausgeführt werden. Der Ablauf derTasks wird von dem Betriebssystem gesteuert.

Ein Task wird definiert, indem das Programm mit Hilfe des folgenden Symbols aufgeteiltwird. Jeder der beiden neuen Zweige ist ein eigenständiger Task. Beide werden gleich-zeitig ausgeführt, (im Unterschied zu einer Verzweigung).

Achtung: Die beiden so entstehenden Zweige müssen nicht mehr zusammengeführtwerden, sondern jeder Zweig muss mit einer roten Ampel abgeschlossen werden.



2.7. Variablen/ContainerWenn man Werte oder Zustände von Sensoren ausliest, erhält man immer den aktu-ellen Wert.

Manchmal will man aber einen früheren Wert wissen, um z.B. zu sehen wie sich derWert verändert. Dazu muss der Roboter sich diesen Wert „merken“, er muss also ir-gendwo gespeichert werden. Dafür gibt es in Programmiersprachen spezielle „Speicher-plätze“ sogenannte Variablen. In RoboLab heißen diese Container

Bei RoboLab gibt es drei solche Container: einen roten, einen blauen und einen gelben.

Speichern:

Um einen Wert in einen Container zu tun, gibt es folgende Möglichkeiten:

Mit diesem Symbol speichert man den aktuellen Wert eines Sen-sors in einem Container.

Bsp: Speichert den Wert des Sensors 1 in dem roten Container.

Mit diesem Symbol speichert man einen festen Wert in einemContainer.

Bsp: Speichert „5“ im roten Container.

Mit diesem Symbol speichert man den aktuellen Wert einesLichtsensors in einem Container.

Bsp: Speichert den Wert des Lichtsensors an Eingang 1 in demblauen Container.

Verändern:

Man kann gespeicherte Werte in den Containern auch verändern. Dazu gibt es eineVielzahl von Möglichkeiten. Im folgenden Beispiel wird zu dem Wert im gelben Container5 addiert.



Auslesen:

Die im Container gespeicherten Werte können unter anderem wie folgt verwendetwerden:

Mit diesen Symbolen kann der Inhalt einesContainers an eine Vielzahl von anderenSymbolen, wie eine Konstante weitergelei-tet werden.

Hier wird zum Beispiel der Wert desLichtsensors an Eingang 2 mit dem Inhaltdes blauen Containers verglichen.

Man kann natürlich auch den Inhalt einesContainers mit einer Konstante direkt ver-gleichen.

Bsp: Hier wird geprüft, ob der Inhalt desblauen Containers größer oder kleiner-gleich 12 ist.



3. Software NQC3.1. Allgemeine Bedienung des NQC Editors

Der NQC Editor erleichtert den Umgang mit dem NQC Compiler, da er den gesamtenVerwaltungsaufwand abnimmt.

Er erlaubt den Download der RCX Firmware und kann mit Hilfe des Tastenkürzels F9das Programm kompilieren und danach auf das RCX übertragen.

3.2. Kurzübersicht NQC vs. RoboLabAllgemeines:

Beginn und Ende eines Programms task main()

{

// Befehle

}Befehle

Kommentar

(dient nur zur Orientierung oder alsInfo)

// Kommentar

/* Kommentar */

Motoren:

Motor läuft vorwärts OnFwd(OUT_A); oder

Motor läuft rückwärts OnRev(OUT_A); oder


Sensor-Eingänge1 SENSOR_1

2 SENSOR_2

3 SENSOR_3

Motor-AusgängeA OUT_A

B OUT_B

C OUT_C


Motor Anschalten

(ohne Richtungsangabe)

On(OUT_A);

Motor Ausschalten

(ohne Richtungsangabe)

Off(OUT_B); oder

Mehrere Motoren gleichzeitig An- undAusschalten

OnFwd(OUT_A + OUT_C);

Off(OUT_A + OUT_B +OUT_C);

oder

Motor wird auf Zeit Angeschaltet (x/100Sekunden)

OnFor(OUT_A,200);

oder

On(OUT_A);

Wait(200);

Off(OUT_A);Richtung auf „vorwärts“ gesetzt

(forward)

Fwd(OUT_B);

Richtung auf „rückwärts“ gesetzt

(reverse)

Rev(OUT_B);

Motor wird in Leerlauf geschaltet Float(OUT_C);

Motorleistung wird gesetzt; Leistungs-stufen von 0 bis 7 bei NQC, und von 0bis 5 bei RoboLab

SetPower(OUT_B,5); oder

Sensoren:

Definiert einen IR-Licht-Sensor

=> 0% bis 100%

SetSensor(SENSOR_1,SENSOR_LIGHT);



Definiert einen Be-rührungssensor(Bumper)

=> 0 oder 1

SetSensor(SENSOR_1,SENSOR_TOUCH);

Definiert einen „ent-prellten“ Berührungs-sensor

=> 0 oder 1

SetSensor(SENSOR_1,SENSOR_EDGE); _______________

Definiert einen Tem-peratursensor

=>Wert / 10 = °C

SetSensor(SENSOR_1,SENSOR_CELSIUS);

Definiert einen Rota-tionssensor

=>-32768 bis +32767

SetSensor(SENSOR_1,SENSOR_ROTATI-ON);

Setzt den Wert desSensors auf „0“;

Sinnvoll bei Rota-tionssensor.

ClearSensor(SENSOR_1);

Bedingte Anweisungen:

„Wenn der Lichtwert grö-ßer ist als 60%, dann ma-che Befehle A. Ansons-ten mache Befehle B.“

if (SENSOR_1 > 60)

{

// Befehle A

}

else

{

// Befehle B

}„Wenn der Wert desRotationssensors kleiner-gleich 15 ist, dann macheBefehle B.

Ansonsten mache Befeh-le A.“

if (SENSOR_1 <= 15)

{

// Befehle B

}

else

{

// Befehle A

}



„Wenn der Lichtwert 25%ist, dann mache BefehleA. Wenn nicht dann ma-che Befehle B.“

if (SENSOR_1 == 25)

{

// Befehle A

}

if (SENSOR_1 != 25)

{

// Befehle B

}

Schleifen/Loops

while - Schleife bzw. Jumper

„Wiederhole die Befehle in derSchleife unendlich oft.“

while (true)

{

// Befehle

}while - Schleife

„Die Befehle in der Schleifewerden so lange ausgeführt,wie die Bedingung, Taster ge-drückt, wahr ist.“

while (SENSOR_1 == 1)

{

// Befehle

}

while Schleife

„Die Befehle in der Schleifewerden so lange ausgeführt,wie die Bedingung, Lichtsen-sor > 60%, wahr ist.“

while (SENSOR_1 > 60)

{

// Befehle

}

do while Schleife

„Die Befehle in der Schleifewerden einmal ausgeführt unddann wie wie die Bedingung,Lichtsensor < 25%, wahr ist,wiederholt.“

do

{

// Befehle

}

while (SENSOR_1 < 25)repeat Schleife

„Wiederhole die Befehle in derSchleife 5 mal.“

repeat (5)

{

// Befehle

}



until Schleife

„Fahre so lange gerade ausbis Lichtsensor größer 25.“

OnFwd(OUT_A + OUT_C);

until (SENSOR_1 > 25)

{

}

Off(OUT_A + OUT_C);(Lichtsensor um 25% heller)

Variablen und Container:

Definiert eine Variable namensBlau bzw. einen Container (rot,blau, gelb).

int Blau;

Der Variablen namens Blau bzw.dem blauen Container wird derWert 40 zugewiesen.

Blau = 40;

Der Variablen Blau bzw. demblauen Container wird der Wertdes Lichtsensors zugewiesen.

Blau = SENSOR_2;

Vergleicht den Wert desLichtsensors 2 mit der VariablenBlau bzw. dem blauen Con-tainer.

if( SENSOR_2 > Blau)

{ }

if (SENSOR_2 <= Blau)

{ }Erhöht den Wert der VariablenBlau bzw. des blauen Containersum den Wert 5.

Blau = Blau + 5;



3.3. Befehlsübersicht NQCDie Liste ist bei weitem nicht vollständig. Sie können ein Tutorial (mit allen Befehlen) unddas NQC-Programm bei Dave Baum (englisch) herunterladen.http://www.baumfamily.org/nqc/

Übersetzung des Tutorials von Dave Baum: http://www.lug.mfh-iserloh.de/lego/

1. Motoren:Float(OUT_A); Motor A wird in den Leerlauf geschaltetFwd(OUT_A); VorwärtsOff(OUT_A); Motor A ist ausOn(OUT_A + OUT_C); Motor A und C werden gleichzeitig eingeschaltetOn(OUT_A); Motor A ist anOnFor(OUT_A,200); Der Motor A wird 200 * 1/100 Sekunde angeschaltet

Entspricht den Befehlen:

On(OUT_A);

Wait(200);OnFwd(OUT_A); Motor A wird angeschaltet und läuft vorwärtsOnRev(OUT_A + OUT_B); Motoren A und B werden angeschaltet und laufen rück-

wärtsRev(OUT_A); RückwärtsSetPower(OUT_A,5); Motorleistung des Motors A wird auf 5 gesetzt.

(Leistungsstufen zwischen 0 und 7)

2. Sensoren:SetSensor(SENSOR_1,SENSOR_LIGHT); Am Anschluss 1 ist ein Lichtsensor

angeschlossenRückgabewerte zwischen 0 und 100in %

ClearSensor(SENSOR_3); Setzt den Wert des Rotationssensorsauf 0.

SetSensor(SENSOR_1,SENSOR_CELSIUS); Am Anschluss 1 ist ein Tempera-tursensor angeschlossen.

Rückgabewert: Wenn man den vomRCX ausgegebenen Wert durch 10teilt, erhält man die Temperatur in °C.

SetSensor(SENSOR_2, SENSOR_EDGE); Am Anschluss 2 ist ein Berührungs-sensor

angeschlossen. Dabei werden Störsi-gnale herausgefiltert, indem das Si-gnal entprellt wird.

Hierbei werden nach einem Übergang300 ms lang weitere Übergänge igno-riert.

SetSensor(SENSOR_2,SENSOR_TOUCH); Am Anschluss 2 ist ein Berührungs-sensor angeschlossen



SetSensor(SENSOR_3,SENSOR_Mode_RAW);

Die Rohwerte werden ausgelesen.

SetSensor(SENSOR_3,SENSOR_ROTATION);

Am Anschluss 3 ist ein Rotationssen-sor angeschlossen.

Rückgabewert: Bei einer Drehung um22,5° wird der Wert um 1 hochgesetzt.Bei einer Volldrehung beträgt derWert dann 16. Es werden Werte zwi-schen – 32768 und +32767 angege-ben.

3. Makros, Kommentare Variablen und Ausdrücke:

Makro #define MotorLinks OUT_A Wir vor die task main() gesetzt. Inder task main() schreibt man dannanstatt OUT_A MotorLinks.

Kom-mentar

/* Kommentar im Block*/

//ZeilenkommentarVariablenund Aus-drücke

int Helligkeit; Variable Helligkeit wird definiert.

Die Werte sind ganzzahlig (alsokeine Kommazahlen).

Helligkeit = 40; Der Variablen wird der Wert 40zugewiesen.

Helligkeit = Lichtsensor; Der Variablen wird der momentaneWert des Lichtsensors zugewiesen.

Random(7); Es wird eine Zufallszahl zwischen 0und 7 erzeugt, wobei die 7 nicht auf-tritt.

Watch(); Gibt die Systemzeit seit Einschaltendes RCX an.

ClearTimer(1); Setzt den Timer 1 (Stoppuhr) auf 0.Es gibt die vier Timer 0, 1, 2 oder 3.Die Zeit wird in 0,1 SekundenSchritten angegeben.

Drehzeit =Timer(2); Gibt der Variablen „Drehzeit“ denWert des Timers 2.

SendMessage(5); Sendet die Nachricht: 5Nachricht = Message(); Weist der Variablen „Nachricht“ den

Wert der aktuellen IR-Meldung zu.Eine Nachricht kann nur dann auf-genommen werden, wenn die letzteNachricht gelöscht wurde.

ClearMessage(); Löscht die letzte Nachricht.



4. Auswahl und Wiederholung

Bedingte Anweisung:

if(Bedingung){ Befehle;}

Die Befehle werden nur ausgeführt, wenn die Bedingung in runden Klammern erfülltwird.

Auswahl:

if(Bedingung){ Befehle;}else{ Befehle;}

3.4. FirmwareDie Firmware für NQC entspricht der von RoboLab. Siekann mit Hilfe des NQC Editors auf das RCX übertragenwerden. Dazu wählt man im Menü RCX Kontrolle denMenüpunkt RCX Initialisieren aus.

Danach wird das RCX gelöscht und die Firmware auf dasRCX geladen.



3.5. MotorenJe nachdem, an welchem Steckplatz sie angeschlossen sind, haben die Motoren beiNQC verschiedene Namen:

OUT_A -> Steckplatz A

OUT_B -> Steckplatz B

OUT_C -> Steckplatz C

Es macht allerdings Sinn statt OUT_A, OUT_B und OUT_C im Programm naheliegendeNamen wie z.B. MotorRechts, MotorLinks und MotorMitte zu benutzen. Dadurch mussman nicht ständig umdenken, an welchem Steckplatz sich welcher Motor befindet, manhat also während dem Programmieren schon wieder ein wenig Denkarbeit gespart. (sie-he Makros Kapitel V.3.8)

Es gibt mehrere verschiedene Befehle, mit denen die Motoren angesteuert werdenkönnen:

On(OUT_A); Motor A wird angeschaltetOn(OUT_A + OUT_B); Motor A und Motor B werden angeschaltetFloat(OUT_A); Motor A wird in den Leerlauf geschaltetFwd(OUT_A); Motor A dreht sich vorwärts

Beachte:Hier wird nur die Richtung gesetzt, der Motor fängtnicht an zu drehen!

Rev(OUT_A); Motor A dreht sich rückwärts

Beachte:Hier wird nur die Richtung gesetzt, der Motor fängtnicht an zu drehen!

Off(OUT_A); Motor A wird ausgeschaltetOnFor(OUT_A, 200); Motor A wird für 200 * 1 /100 Sekunden einge-

schaltet

entspricht den Befehlen:

On(OUT_A);

Wait(200);

Off(OUT_A);OnFwd(OUT_A); Motor A wird angeschaltet und läuft vorwärtsOnRev(OUT_A); Motor A wird angeschaltet und läuft rückwärtsSetPower(OUT_A, 5); Motorleistung von Motor A wird auf 5 gesetzt

(Leistungstufen zwischen 0 und 7)



3.6. Kontrollstrukturen

3.6.1. Boolsche Operatoren (Bedingungen)

Boolsche Operatoren geben die Verknüpfung von Vergleichen oder boolschen Variablenan. Mit ihnen können die Bedingungen bei if-Anweisungen, while-Schleifen,... ausge-wertet werden.

Boolsche Operatoren:

&& Und-Verknüpfung.

if (A && B) Anweisung;

Die Anweisung wird nur ausgeführt, wenn A und B wahr sind

|| Oder-Verknüpfung

if (A || B) Anweisung;

Die Anweisung wird nur ausgeführt, wenn A wahr oder Bwahr, oder A und B wahr sind

^ Entweder-Oder-Verknüpfung

if (A ^ B) Anweisung;

Die Anweisung wird nur ausgeführt, wenn A wahr ist aber Bnicht, oder wenn B wahr ist aber A nicht.

Vergleichsoperatoren:

< Kleiner als

if (10 < 20) Anweisung;

<= Kleiner gleich

if (10 <= 20) Anweisung;

> Größer als

if (20 > 10) Anweisung;

>= Größer als

if (20 >= 10) Anweisung;

== Gleich

if (20 == 10) Anweisung;

!= Ungleich

if (20 != 10) Anweisung; if (20 <> 10) Anweisung;

Wie die „Punkt-vor-Strich“ Regel gilt bei Bedingungen „Vergleiche-vor-Boolsche-Opera-toren“. Wobei der Und-Operator (&&) vor dem Oder-Operator (||) durchgeführt wird.

Beispiele für Verknüpfungen von Vergleichsoperatoren und boolschen Operatoren:

if ( (10 < 20) && ScheintSonne() ) Anweisung;if ( Regnet() ^ ScheintSonne() ) Anweisung;if ( Regnet() || ScheintSonne() && IstTag() ) Anweisung;



3.6.2. Schleifen

Schleifen werden benutzt, um verschiedene Anweisungen oder Anweisungsblöckemehrfach auszuführen.

Bei allen Schleifen gibt es die Befehle „break“ und „continue“:

break: erlaubt es, die Schleife vorzeitig zu beenden. Dabei wird nur die innersteSchleife beendet.

continue: überspringt den restlichen Schleifen-Code und fängt den nächstenSchleifendurchlauf an.

Es gibt mehrere verschiedene Arten von Schleifen:

3.6.2.1. while

Die while-Schleife wird immer dann benutzt, wenn man verschiedene Anweisungen solange ausführen möchte, wie ein bestimmter Zustand herrscht.

Wir können sie zum Beispiel benutzen, um den Roboter so lange geradeaus fahren zulassen, bis ein Hindernis kommt.

Im Allgemeinen sieht die while-Schleife folgendermaßen aus:

while (Bedingung){

Befehle;}

Die Bedingung wird vor jedem Schleifendurchlauf überprüft. Da die Überprüfung statt-findet, bevor die Schleife durchlaufen wird, spricht man von einer „Kopfbedingung“. Istdie Bedingung schon vor dem ersten Schleifendurchlauf nicht erfüllt (also „false“), wirddie Schleife nicht durchlaufen.

Die while-Schleife eignet sich besonders gut, um Endlosschleifen zu programmieren.Dabei wird einfach eine Bedingung benutzt, die immer wahr ist:

while (true){

Befehle;}



3.6.2.2. do while

Die do-while Schleife ist ähnlich der while-Schleife. Einige Unterschiede bestehenallerdings.

Allgemein :

do{

Befehle;}while( Bedingung )

Statt der Bedingung werden bei dieser Schleife zuerst die Befehle geschrieben. Da diegeschweiften Klammern nicht einzeln stehen dürfen, werden sie durch das reservierteWort „do“ eingeleitet.

Bei dieser Schleifenart spricht man von einer „Fußbedingung“, da die Bedingung erstnach dem ersten Schleifendurchlauf überprüft wird. Dadurch muss die Schleife, auchwenn die Bedingung nicht erfüllt ist, mindestens einmal durchlaufen werden.

3.6.2.3. for

Die for-Schleife ist die komplizierteste unter den Schleifen. Sie bietet allerdings auch diemeisten Möglichkeiten.

Allgemein:

for ( Anweisung1; Bedingung; Anweisung2 ){

Befehle;}

Im Normalfall wird bei Anweisung1 eine Variable erstellt, die über Anweisung2 mit jedemSchleifendurchlauf erhöht bzw. verringert wird. Je nachdem, wie der aktuelle Wert derVariablen lautet, trifft die Bedingung zu oder nicht.

Beispiel:

for (int i = 0; i <= 3; i++) // Diese Schleife wird viermal { // durchlaufen

Befehle;}



3.6.3. if-Abfrage

3.6.3.1. Einfache Einführung

Die if-Abfrage ist eine Verzweigung, bei der ein Argument auf seine Richtigkeit überprüftwird. Sie wird benutzt, um unter verschiedenen Bedingungen verschiedene Aktionenauszulösen.

Eine if-Abfrage sieht bei NQC immer folgendermaßen aus:

if ( Bedingung ){

Befehle;}

Das reservierte Wort „if“ leitet die Verzweigung ein. Danach steht in runden Klammerndie Bedingung, die überprüft werden soll. Wenn die Bedingung 'true' ist, also „wahr“,werden die Befehle im Block ausgeführt. Ist die Bedingung 'false', also „falsch“ werdendie im Block stehenden Befehle nicht ausgeführt, sondern übersprungen. Das Pro-gramm geht dann unmittelbar nach dem Block weiter.

Beispiel:

int a = 2;if ( a >= 1){

PlayTone(440, 20);}

Bei diesem Beispiel wird mit

int a = 2;

eine Variable namens „a“ erstellt, welcher der Wert „2“ übergeben wird. In der darauffolgenden if-Abfrage wird überprüft, ob der Wert der Variable „a“ größer oder gleich „1“ist. Da diese Bedingung erfüllt ist, wird die Anweisung

PlayTone(440, 20);

ausgeführt.



3.6.3.2. if-else-Konstrukte

Bei if-else-Konstrukten kann zusätzlich zur if-Abfrage definiert werden, was passierensoll, wenn die Bedingung nicht erfüllt ist.

Ein solches Konstrukt sieht folgendermaßen aus:

if (Bedingung){Befehle; /*

Wird ausgeführt, wenn die Bedingung wahr ist*/

} else{Befehle; /*

Wird ausgeführt wenn die Bedingungfalsch ist*/

}

Wenn die Bedingung erfüllt ist, werden die Befehle im ersten Block ausgeführt. Ist dieBedingung allerdings falsch, werden die Befehle im zweiten Block ausgeführt.

Man kann auch mehrere if-else-Konstrukte ineinander verschachteln. Die Anzahl der in-einander verschachtelten Abfragen ist dabei beliebig:

if (Bedingung){

Befehle;}else{

if (Bedingung){

Befehle;}else{

if (Bedingung){

Befehle;}else{

//....}

}}



3.6.3.3. switch

Wenn man eine Variable auf mehrere Werte überprüfen möchte, sähe dies mit if-Abfragen ungefähr so aus:

int a = 0;if (a == 0){

Befehle;}if (a == 1){



Befehle;}

//...

Wenn es sich nun um zahlreiche verschiedene Werte handelt, die überprüft werdensollen, wäre das natürlich viel zu kompliziert, unübersichtlich und vor allem sehr sehr vielSchreibarbeit...

Deshalb gibt es die Möglichkeit, Variablen über die switch-Anweisung direkt auf unter-schiedliche Werte zu überprüfen:

Allgemein:

switch (Variable){

case Wert1:{

Befehle;} case Wert2:{

Befehle;}//...default:{

Befehle;}

}

Für Wert1, Wert2 usw. wird jeweils der gewünschte Variablenwert übernommen. Enthältdie Variable jetzt beispielsweise den Wert „Wert2“, so werden die Befehle ab dem ent-sprechenden case-Abschnitt ausgeführt. Dabei muss allerdings beachtet werden, dassauch alle nachfolgenden Befehle in folgenden case-Abschnitten ausgeführt werden.



Wenn man das verhindern will, schreibt man in die jeweiligen case-Abschnitte nach denBefehlen die Anweisung „break“.

Beispiel:

switch (MeineVariable){

case 1:{

Befehle;}case 2:{

Befehle;break;

}default:{

Befehle;}

}

Hat „MeineVariable“ den Wert 1, so wird sowohl der Block von „case 1:“ als auch von„case 2:“ ausgeführt. Der Block des default-Teils wird nicht abgearbeitet, da es vomBefehl break verhindert wird.

Hat „MeineVariable“ den Wert 2, so wird in diesem Fall nur der Block bei „case 2:“ be-handelt

Der default-Abschnitt wird immer dann ausgeführt, wenn es kein passendes „case“ fürden Wert gibt.



3.7. SensorenSensoren tragen bei NQC die Bezeichnung SENSOR_1, SENSOR_2 bzw. SENSOR_3.Wobei SENSOR_1 auch an Eingang 1 angeschlossen ist. Diese Namen können immerverwendet werden, wenn ein Sensor ausgelesen werden soll.

Bsp:

x=SENSOR_1; // lies den Sensorwert und speichere ihn in der Variable x

3.7.1. Definieren

SetSensor(Sensor, Sensorart);

Am RCX können verschiedene Sensoren angeschlossen werden. Diese müssen zuvorimmer erst definiert werden, damit das RCX die Werte des Sensors richtig ausliest. Esgibt verschiedene Sensorarten, die angeschlossen werden können.

Sensortyp Bedeutung Werte beim Auslesen

SENSOR_TOUCH Tastsensor Boolscher Wert (0;1)

SENSOR_LIGHT Lichtsensor Prozentwert (0 bis 100)

SENSOR_ROTATION Rotationssensor Drehlage (16 Schrittepro Umdrehung)

SENSOR_EDGE Entprellter Tastsensor Zählwert der Impuls-flanken

SENSOR_CELSIUS Temperatursensor Grad Celsius

SENSOR_FAHRENHEIT Temperatursensor Grad Fahrenheit

ClearSensor(Sensor, Typ);

Mit diesem Befehl wird der Sensorwert gelöscht - beeinflusst nur diejenigen Sensoren,die so eingestellt sind, dass sie einen Wert durch Weiterzählung messen (z.B. Rota-tionssensoren).

Bsp:

SetSensor(SENSOR_1, SENSOR_ROTATION); // SENSOR_1 ist ein RotationssensorClearSensor(SENSOR_1); // Der Wert des Sensors wird auf 0 gesetzt.



3.7.2. Auslesen

Sensorwerte können bei NQC grundsätzlich immer ausgelesen werden; auch in parallelablaufenden Tasks. Sie können entweder in Variablen kopiert werden oder zum Ver-gleich mit anderen Sensoren ausgelesen werden.

Bsp:

SetSensor(SENSOR_1, SENSOR_LIGHT);if(SENSOR_1 > 40){

OnFwd(OUT_A);}

3.7.3. Polly'sche Kombination

Da oftmals mehr Sensoren benötigt werden als Steckplätze vorhanden sind, gibt es dieMöglichkeit, einen Tastsensor auf einem Lichtsensor zu platzieren. Der Sensor wirddann als Lichtsensor definiert. Somit können die Werte des Lichtsensors normal ausge-lesen werden. Wird der Tastsensor gedrückt, liefert das RCX den Wert 100.

3.8. MakrosUm das Programm besser lesen zu können, ist es sinnvoll, anstatt der Benennungen wieOUT_A oder SENSOR_3 Bezeichnungen zu wählen, die angeben, welche Bestimmungder Ausgang bzw. der Sensor hat. Dazu benutzt man bei NQC den Präprozessor. Erwirkt auf das Programm bevor es vom Compiler bearbeitet wird. Befehlen, die auf denPräprozessor wirken, ist ein # voran gestellt. Man nennt sie Direktiven. Mit Hilfe der Di-rektive #define kann die Lesbarkeit des Programms deutlich erhöht werden.

Beachte: Am Ende von der #define-Zeile kommt kein ';‘ !

Bsp:

#define MotorLinks OUT_A#define MotorRechts OUT_B#define Drehzeit 400task main(){

Fwd(MotorLinks);Rev(MotorRechts);OnFor(MotorLinks+MotorRechts,Drehzeit);

}

Bevor das Programm mit dem Compiler übersetzt wird, wird nun z.B. überall im Pro-gramm „MotorLinks“ durch „OUT_A“ ersetzt.



3.9. FunktionenJe größer ein Programm wird, desto unübersichtlicher wird es, weil an mehreren Stellenimmer wieder ein und derselbe Quellcode steht. Manchmal unterscheiden sich einzelnePassagen nur durch sehr kleine Fragmente.Um diesen Missstand zu beheben, bieten Programmiersprachen das Konzept derFunktionen an. Eine Funktion besteht aus einem Funktionskopf und einem Funktions-rumpf. Der Kopf enthält den Rückgabewert, den Namen und optionale Parameter, durchdie die Funktion an kleinere Unterschiede dynamisch angepasst werden kann.Der Rumpf enthält den eigentlichen Code. Dort können wie im Hauptprogramm ( main() ), das übrigens auch eine Funktion ist, nur eben eine ganz besondere, alle Befehleausgeführt werden.In NQC beginnt jede Funktion mit dem Schlüsselwort "void", gefolgt vom Funktions-namen, dessen Groß- und Kleinschreibung immer einzuhalten ist, und der Parameterlis-te, die in runden Klammern eingeschlossen ist und immer angegeben werden müssen.

Beispiel:

void Geradeaus(int Geradeauszeit){

Fwd(OUT_A + OUT_B);OnFor(OUT_A + OUT_B,Geradeauszeit);

}

void Drehen(){

OnFwd(OUT_A);OnRev(OUT_B);

}

task main(){

while(true){

Geradeaus(Random(300)); /* Die Funktion Geradeauswird aufgerufen und erhält einen Wert zwischen 0 und 300 */Drehen();wait(200);

}}

Wie im Beispiel von "Geradeaus" zu sehen ist, wird dort der Parameter "Geradeauszeit",der ein Integer (int) ist, erwartet. Ruft man nun "Geradeaus" mit einem Zahlenwert auf,"Geradeaus(300);", dann wird in der Funktion die virtuelle Variable, deren Name in derFunktion eindeutig sein muss, der Wert 300 geschrieben und somit überall dort, wo "Ge-radeauszeit" steht der Wert 300 eingesetzt, solange die virtuelle Variable nicht verändertwird. Ruft man die Funktion mit einem anderen Wert auf, so enthält "Geradeauszeit"diesen anderen Wert.

Man spricht hierbei nicht von einer virtuellen Variablen, sondern von einem Parameter,da dieser die Funktion universeller einsetzbar macht.



3.10. TasksNeben der task main() können bis zu neun weitere Tasks verwendet werden. ZwischenFunktionen und Tasks besteht ein grundsätzlicher Unterschied. Funktionen sind Zu-sammenfassungen von Anweisungen zu einer Einheit.

Tasks hingegen sind Anweisungseinheiten, die gleichzeitig ausgeführt werden können.Der Ablauf der Tasks wird von der „Haupt-task“ (task main()) gesteuert. Taskseignen sich also zum Beispiel zum Überwachen der Sensoren.

Steuerbefehle für Tasks:

start Bande; // Schaltet die Task „Bande“ ein

stop Bande; // Schaltet die Task „Bande“ aus

stopalltasks() // Schaltet alle Tasks aus

taskpriority(1) /* Setzt die Priorität einer Task fest. Die Task mit derhöchsten Priorität (kleinste Zahl) hat die Kontrolle über die geradebenutzten Motoren.*/


RoCCI e.V. Almanach 1. AuflageKaptiel VI Übungsaufgaben

Kapitel VI: Übungsaufgaben

InhaltsverzeichnisKapitel VI: Übungsaufgaben..........................................................................62

1. Programmieraufgaben......................................................................................631.1. Aufgabe 1......................................................................... ..................................631.2. Aufgabe 2......................................................................... ..................................631.3. Aufgabe 3......................................................................... ..................................631.4. Aufgabe 4......................................................................... ..................................631.5. Aufgabe 5......................................................................... ..................................631.6. Aufgabe 6......................................................................... ..................................631.7. Aufgabe 7......................................................................... ..................................631.8. Aufgabe 8......................................................................... ..................................641.9. Aufgabe 9......................................................................... ..................................641.10. Aufgabe 10: Roboter-Fußball................................. ..........................................641.11. Aufgabe 11..................................................................... ..................................65

2. Mechanik..........................................................................................................662.1. Anfänger............................................................................................. ............662.2. Fortgeschrittene Anfänger.......................................................... ....................672.3. Fortgeschrittene.......................................................................................... ....68



1. Programmieraufgaben1.1. Aufgabe 1

a) Lasse deinen Roboter 2 Sekunden auf der Stelle drehen.b) Lasse deinen Roboter 2 Sekunden geradeaus fahren.

1.2. Aufgabe 2Lasse deinen Roboter nacheinander:

- 4 Sekunden drehen- Musik spielen- 2 Sekunden rückwärts laufen- 3 Sekunden rechts herum drehen- 10 Sekunden vorwärts laufen.

1.3. Aufgabe 3Lasse deinen Roboter nacheinander:

- Musik spielen- 4 Sekunden vorwärts laufen- 2 Sekunden rechts herum drehen- 6 Sekunden links herum drehen

1.4. Aufgabe 4Lasse deinen Roboter so lange geradeaus fahren, bis der Schalter 1 gedrückt wird.Dann soll er 4 Sekunden rückwärts fahren und anschließend noch etwas Musik spielen.(Schließe die Sensoren der Stoßfänger dazu beim Eingang 1 an.)

1.5. Aufgabe 5Lasse deinen Roboter erst anfahren, wenn der Schalter 1 gedrückt wird. Dann soll er solange geradeaus fahren, bis der Schalter 1 wieder gedrückt wird. Anschließend muss erstehen bleiben und zum Abschluss etwas Musik spielen.

1.6. Aufgabe 6Lasse deinen Roboter so lange langsam (Stufe 2) geradeaus fahren, bis der Schalter 3gedrückt wird. Dann soll er so lange schnell rückwärts fahren, bis der Lichtsensor 2 (aufden Boden gerichtet) eine schwarze Linie erkennt. Zum Abschluss muss er noch etwasMusik spielen.

1.7. Aufgabe 7Lasse deinen Roboter geradeaus fahren. Wenn er gegen die Wand fährt, soll er einStück zurückfahren, umdrehen und weiterfahren. Diese Aktionen muss er beliebig oftausführen können. (Stecke die Anschlüsse der beiden Bumper an den Sensoreingang1.)



1.8. Aufgabe 8Dein Roboter soll erst anfahren, wenn du eine Lichtquelle in die Nähe gebracht hast. An-schließend muss er zwischen 0 und 10 Sekunden geradeaus fahren und sich dann 2Sekunden um die eigene Achse drehen.

1.9. Aufgabe 9Schwarze Linie verfolgen: (Beachte Abb. 5)

a) Mit einem Sensor: Der Roboter soll eine schwarzeLinie entlangfahren, die entweder nur rechts oder linksKurven hat.

Tipp: Zur Orientierung wird entweder der Randschwarz-weiß oder weiß-schwarz hergenommen.

b) Linie verfolgen mit Hindernis:

Schreibe dein Programm so um, dass dein Robotereine schwarze Linie entlang fahren kann und stehenbleibt, wenn er auf ein Hindernis stößt.

c) Lass dein Roboter eine schwarze Linie entlang fahren, die links und rechts Kurvenhat. Dazu benötigst du zwei Lichtsensoren, die auf den Boden gerichtet sind.

1.10. Aufgabe 10: Roboter-FußballBaue einen einfachen Fußballroboter:

Der Lichtsensor wird nach vorne ausgerichtet und ist auf Eingang 2 des RCX ange-steckt.

Die Bumper werden so hoch (über dem Lichtsensor) aufgebaut, dass der Ball noch dar-unter passt.

a) Aufsuchen des Balls

Lasse deinen Roboter einen Ball/Lichtquelle suchenund darauf zufahren. Dazu muss er folgende Befehleausführen:

• Wenn der Roboter den Ball/Lichtquelle nicht sieht,soll er sich drehen

• wenn er den Ball/Lichtquelle erkennt, muss er ge-rade aus fahren und Musik spielen.

Diese Aufgabe soll er immer wiederholen.

b) Schreibe dein Programm nun so um, dass der Ro-boter vor der Lichtquelle stoppt. Dazu benötigst duzwei Verzweigungen.


Abbildung 5

Wenn Lichtsensorwert

über 45 %unter 45 %

Roboter muss im Kreis drehen

Roboter muss gerade aus fahren.

Wenn Lichtsensorwert



Wenn Lichtsensorwert Wenn Lichtsensorwert



Roboter muss gerade aus fahren.

Abbildung 6


c) Baue in dein Fußballprogramm noch den Teil ein,der bestimmt, was der Roboter tunsoll, wenn er gegen die Wand fährt.

1.11. Aufgabe 11Der Roboter soll dreimal folgende Bewegungen wiederholen:2 Sekunden geradeaus fahren, dann 4 Sekunden drehen



2. Mechanik2.1. Anfänger



2.2. Fortgeschrittene Anfänger



2.3. Fortgeschrittene


RoCCI e.V. Almanach 1. AuflageKaptiel VII Musterprüfungen

Kapitel VII: Musterprüfungen



RoCCI Anfängerkurs. Name, Vorname: ____________, _____________

T E S T

1.) Wörter zuordnen. Gib zu jeder Erklärung den entsprechenden Fachbegriff an. (5Punkte)

a) Die zentrale Steuereinheit eines Lego-Roboters _______________

b) Ein Computer besitzt sowohl Hardware als auch _______________

c) Das Betriebssystem des RCX _______________

d) Übersetzt ein Programm in Robotersprache _______________

e) Die Software, mit der wir zurzeit programmieren _______________

2.) Folgende Skizze zeigt das Symbol eines Motors wie er beim Programmierenerscheint. Schreibe a, b, c, d in das richtige Kästchen (4 Punkte):Wo verbindet man:a) Beginb) Power Levelc) Motorname (A, B, C)d) End

3.) Beschreibe, wie aus einer Idee ein programmierter Roboter entsteht. FolgendeWörter solltest du dazu in einen geordneten Zusammenhang bringen. (6 Punkte)Idee – Firmware – Interface – Software – fertiger Roboter – Compiler

4.) Betrachte folgendes Programm und kreuze alle richtigen Aussagen an.Tipp: Ganz am Anfang fährt der Roboter die 2 Sekunden vorwärts (6 Punkte)

__ Das Programm läuft unendlich lang (es sei denn man schaltet den Roboter aus).__ Wenn kein Bumper (Tastsensor) gedrückt wird, fährt der Roboter gerade aus.__ Der Roboter fährt auch mal rückwärts.__ Der Roboter fährt auch mal eine Kurve.__ Wenn einer der beiden Bumper für 10 Sekunden dauergedrückt wird, steht er absolut



still__ Wird Bumper 1 gedrückt, passiert das Gleiche als wenn Bumper 2 gedrückt wordenwäre

5.) Erkläre, was der Roboter macht, nachdem er 2 Sekunden geradeaus gefahrenist. (2 Punkte)

6.) Was bewirkt folgendes Symbol? (1 Punkt)

Viel Erfolg!



RoCCI Anfängerkurs. Name, Vorname: ____________, _____________

T E S T

1.) Welche Werte liefert ein Lichtsensor im Vergleich zu einem Tastsensor? (2Punkte)

Lichtsensor: ____________________ Tastsensor: ____________________

2. Klassifiziere (=ordne ein, unterscheide) folgende Sensoren (6 Punkte):

analog oder digital? aktiv oder passiv?

___________ Tastsensor ___________

___________ Lichtsensor ___________

___________ Temperatursensor ___________

Tipp: Der Temperatursensor besitzt nur einen Empfänger und kann mehrere Zuständeauslesen.

3. Lückentext – Einfach ausfüllen (4 Punkte)

Ein Sensor ist ein Gerät, welches Reize aus der _______________ wahrnimmt und diese

dann in _______________ Signale umwandelt. Diese Signale werden an das _____

gesendet. Solche Signale bestehen aus _____ und Bytes.

4. Erkläre den Unterschied zwischen aktiven und passiven Sensoren (2 Punkte) )

5. Beantworte die Fragen zur Polly'schen Kombination. (4 Punkte)

a) Welchen Vorteil hat die Kombination?

_______________________________________________________________________

b) Welche dieser Sensorkombinationen haben Sinn? (ja/nein)Bumper/Lichtsensor ____ Bumper/Temperatursensor ____Lichtsensor/analoger Sensor ____

6. Betrachte das Programm an der Tafel und beantworte folgende Fragen (6 Punkte)Leider nicht verfügbar!



RoCCI Anfängerkurs. Name, Vorname (1 Punkt): ____________, _____________

T E S T1. Wörter zuordnen. Gib den entsprechenden Fachbegriff an (4 Punkte)

a) Eine Umdrehung (z.B. eines Rades) ________________

b) Für Lego-Lichtsensoren sichtbar, für Menschen nicht: ________________

c) Roboter, die selbständig und alleine funktionieren sind: ________________

d) Übersetzt ein Programm in Zahlen wie 0 1 0 0 1 0 ________________

2. Übersetzung, Untersetzung oder direkter Antrieb? (5 Punkte)

a) Das Rad dreht sich schneller als der Antriebsmotor. _______________

b) Das Rad dreht sich stärker als der Motor. _______________

c) Das Rad dreht sich gleich schnell wie der Motor. _______________

d) Der Roboter muss eine Steigung hochfahren; er braucht _______________

e) Der Roboter will ein Wettrennen gewinnen; er braucht _______________

3. Wie kann man einen Roboter schneller machen? (3 Punkte)

a) O Übersetzung oder O Untersetzungb) O große Räder oder O kleine Räderc) O mehr Motoren am RCX oder O weniger Motoren am RCX

4. Welches ist die sinnvollste Reihenfolge zum Roboter bauen (2 Punkte)?O RCX-Fahrwerk-SensorenO Fahrwerk-Sensoren-RCXO Sensoren-RCX-Fahrwerk5. Betrachte folgende Getriebe.a) Zeichne für jedes Rad dieDrehrichtung ein (2 Punkte)b) In welche Richtung dreht sich dasRad X? ____ (2 Punkte)c) Handelt es sich um eine Über- oderUntersetzung (1 Punkt)____________

a) Zeichne für jedes Rad die Drehrichtung ein(2 Punkte)b) Welche Räder drehen sich in die gleicheRichtung wie das Antriebsrad? ___ und ___(2 Punkte)

Bonus: Welche Räder drehen sich schnellerals das Antriebsrad? __________


RoCCI e.V. Almanach 1. AuflageKaptiel VIII : Fachbegriffe

Kaptiel VIII: FachbegriffeGrundbegriffe

RCX Die zentrale Steuereinheit eines Lego-Roboters (wie das Gehirn beieinem Menschen)

Software Oberbegriff für Programme, Spiele und andere Anwendungen imPC

Firmware Das Betriebssystem des RCX

Compiler Übersetzt (kompiliert) ein Programm in für Roboter lesbare Bits undBytes.

Bit, Byte Kleine elektrische Einheiten, die zwei Werte annehmen können: 0oder 1. [F] Acht Bits sind ein Byte. Ein Byte kann dezimale Zahlenvon 0 bis 255 darstellen.

RoboLab Eine grafische Programmieroberfläche

NQC „Not Quite C“, eine textorientierte Programmiersprache

Sensoren unterscheide zwischen aktiv, passiv, analog und digital (dazu nochnäheres)

Laptop/

Notebook Tragbarer Computer

Interface Ermöglicht die Übertragung von Daten zwischen PC und RCX

Mechanik

Autonom Selbstständig, ohne Anweisung anderer

Direkter Antrieb Der Motor wird direkt (= ohne Übersetzung) an das Rad gekoppelt

Übersetzung Das Rad dreht sich schneller (aber schwächer) als der Motor

Untersetzung Das Rad dreht sich langsamer (aber stärker) als der Motor

Rotation Umdrehung (z.B. eines Rades)

Infrarotlicht „Wärmelicht“, das heißt für Menschen unsichtbares Licht

RoboCup Roboter-Fußball-Wettbewerb

Elektrik

Spannung Gibt an, wie viel elektrischer „Druck“ in einer Batterie steckt und wirdin Volt (V) gemessen. Die Spannung eines RCX beträgt im Optimal-fall 9V. Je weniger Spannung desto schwächer drehen sich zum Bei-spiel Motoren. Ist die Spannung zu niedrig, müssen die Batterien ge-wechselt werden

Polarität Jede Spannungsquelle (Batterie, etc.) hat 2 Pole, Plus (+) und Minus(-). Beim Einlegen der Batterien ins RCX muss auf die richtige Polari-tät geachtet werden.



Elektronik Die Gesamtheit der Geräte durch die Strom fließt, z.B. Motoren undSensoren.

Gleichstrom (DC) Die Polarität bleibt konstant. Beispiel: Batterie

Wechselstrom (AC) Die Pole wechseln sehr schnell. Beispiel: Steckdose

Variabel Sich verändernd, immer neue Werte annehmend (Werte einesLichtsensors sind variabel). Das Gegenteil von konstant(gleichbleibend).

Variable Kann verschiedene Zahlenwerte annehmen.



Stichwortverzeichnis#define 59

AAblaufrichtung 31aktiv 20analog 19Antriebsarten 22Asimov 15

B

Bedingungen 51Befehlsübersicht NQC 47Boolsche Operatoren 51break 52Bumper 19

CClearSensor 58Compiler 30Container 46continue 52

Ddigital 19do while 53

EEffektoren 21

F

Firmware 32, 49Flussdiagramme 31for 53Funktionen 60

G

Getriebe 25Gleichstrommotor 21

H

Handhabungshinweise 9Hardware 17

I

if-Abfrage 54if-else 55

K

Kontrollstrukturen 37, 51

LLaptop 30Legosensoren 28Lichtsensor 19Lichtsensoren 36Logik 31Loops 45

MMakros 59Maschinensprache 30Motoren 21, 42, 50Musterprüfungen 69

NNot Quite C Compiler 30NQC 42NQC Editors 42

P

passiv 20Polly'sche Kombination 59Positionsbestimmung 36Programmieraufgaben 63Programmiersprachen 30

RRaumregeln 10RCX 27Rechner 30Riemen 25f.RoboLab 32Roboter 11f.Robotergesetze 15Rotationssensoren 36

SSchleifen 45, 52Schrittmotor 21SENSOR_CELSIUS 58SENSOR_EDGE 58SENSOR_FAHRENHEIT 58SENSOR_LIGHT 58SENSOR_ROTATION 58SENSOR_TOUCH 58Sensoren 18, 43, 58



Sensorik 18Servomotor 22SetSensor 58Sicherheit 15Software 29Sprünge 37switch 56

T

Tasks 39Tastsensoren 35Testen 16

UÜbersetzung 25Übungsaufgaben 62

Untersetzung 25

V

Variablen 40, 46Verfügbarkeit 15Verlässlichkeit 15Verzweigungen 31, 38

W

while 52Wiederholungen 39

Z

Zahnräder 25Zeit-Spannungsdiagramm 19


Almanach - rocci.net · Almanach Das Nachschlagewerk für den Robotik Unterricht herausgegeben vom...

Documents

Transcript of Almanach - rocci.net · Almanach Das Nachschlagewerk für den Robotik Unterricht herausgegeben vom...