View
3
Download
0
Category
Preview:
Citation preview
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: vorstand@rocci.net
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
RoCCI e.V. Almanach 1. Auflage
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
Copyright: RoCCI e.V. www.rocci.net Seite 7
RoCCI e.V. Almanach 1. Auflage
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
Copyright: RoCCI e.V. www.rocci.net Seite 8
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
Copyright: RoCCI e.V. www.rocci.net Seite 9
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!
Copyright: RoCCI e.V. www.rocci.net Seite 10
RoCCI e.V. Almanach 1. AuflageKaptiel III Roboter
Kapitel III: RoboterInhaltKapitel III: Roboter.........................................................................................11
1. Definition Roboter.............................................................................................122. Beispiele...........................................................................................................143. Robotergesetze................................................................................................154. Testen..............................................................................................................16
Copyright: RoCCI e.V. www.rocci.net Seite 11
RoCCI e.V. Almanach 1. AuflageKaptiel III Roboter
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
Copyright: RoCCI e.V. www.rocci.net Seite 12
RoCCI e.V. Almanach 1. AuflageKaptiel III Roboter
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
Copyright: RoCCI e.V. www.rocci.net Seite 13
RoCCI e.V. Almanach 1. AuflageKaptiel III Roboter
2. Beispiele
Copyright: RoCCI e.V. www.rocci.net Seite 14
RoCCI e.V. Almanach 1. AuflageKaptiel III Roboter
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.
Copyright: RoCCI e.V. www.rocci.net Seite 15
RoCCI e.V. Almanach 1. AuflageKaptiel III Roboter
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.
Copyright: RoCCI e.V. www.rocci.net Seite 16
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
Copyright: RoCCI e.V. www.rocci.net Seite 17
RoCCI e.V. Almanach 1. AuflageKaptiel IV Hardware
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.
Copyright: RoCCI e.V. www.rocci.net Seite 18
Sensor wie zum Beispiel:Lichtsensor, Bumper,
Lichtschranke, ...
Physikalisches Phänomen wie zum Beispiel: Licht, Schall,Temperatur, Gewichtskraft,
Magnetfelder, ...
Elektrisches Signal
RoCCI e.V. Almanach 1. AuflageKaptiel IV Hardware
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.
Copyright: RoCCI e.V. www.rocci.net Seite 19
Vcc
WiderstandSignal
Sensor
USignal
Vcc
WiderstandSignal
Sensor
USignal
0
12 3
4
RoCCI e.V. Almanach 1. AuflageKaptiel IV Hardware
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!
Copyright: RoCCI e.V. www.rocci.net Seite 20
Umgebung
Empfänger
Sender
Umgebung Empfänger
BumperLichtschrankedigital
TemperatursensorMagnetfeldsensor
Lego-IR-SensorAbstandsmesser
analog
passivaktiv
RoCCI e.V. Almanach 1. AuflageKaptiel IV Hardware
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
Copyright: RoCCI e.V. www.rocci.net Seite 21
Abbildung 1. Schema eines Gleichstrommotors
Abbildung 2. Schema eines Schrittmotors - ist invier Schritten fertig
RoCCI e.V. Almanach 1. AuflageKaptiel IV Hardware
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
Copyright: RoCCI e.V. www.rocci.net Seite 22
Lenken + FahrenLeerlauf
LenkenFahren
RoCCI e.V. Almanach 1. AuflageKaptiel IV Hardware
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
Copyright: RoCCI e.V. www.rocci.net Seite 23
120°
Alle Räder
lenken und fahren
RoCCI e.V. Almanach 1. AuflageKaptiel IV Hardware
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.
Copyright: RoCCI e.V. www.rocci.net Seite 24
Plattform
Abbildung 4Abbildung 3
RoCCI e.V. Almanach 1. AuflageKaptiel IV Hardware
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.
Copyright: RoCCI e.V. www.rocci.net Seite 25
Untersetzung
Zahnrad (8 Zähne) der Motorachse
Zahnrad (24 Zähne) der Radachse
Zahnrad der Radachse
Übersetzung
Zahnrad der Motorachse
RoCCI e.V. Almanach 1. AuflageKaptiel IV Hardware
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.
Copyright: RoCCI e.V. www.rocci.net Seite 26
Riemenscheibe
Keilriemen
RoCCI e.V. Almanach 1. AuflageKaptiel IV Hardware
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.
Copyright: RoCCI e.V. www.rocci.net Seite 27
RoCCI e.V. Almanach 1. AuflageKaptiel IV Hardware
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
Copyright: RoCCI e.V. www.rocci.net Seite 28
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
Copyright: RoCCI e.V. www.rocci.net Seite 29
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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.
Copyright: RoCCI e.V. www.rocci.net Seite 30
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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();}
}}
Copyright: RoCCI e.V. www.rocci.net Seite 31
Start
Ausgabe von„Gefunden“
NächsterBuchstabe
Buchstabe Agefunden
ja
nein
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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.
Copyright: RoCCI e.V. www.rocci.net Seite 32
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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:
Copyright: RoCCI e.V. www.rocci.net Seite 33
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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
Copyright: RoCCI e.V. www.rocci.net Seite 34
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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!)
Copyright: RoCCI e.V. www.rocci.net Seite 35
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
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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.
Copyright: RoCCI e.V. www.rocci.net Seite 36
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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.
Copyright: RoCCI e.V. www.rocci.net Seite 37
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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.
Copyright: RoCCI e.V. www.rocci.net Seite 38
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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.
Copyright: RoCCI e.V. www.rocci.net Seite 39
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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.
Copyright: RoCCI e.V. www.rocci.net Seite 40
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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.
Copyright: RoCCI e.V. www.rocci.net Seite 41
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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
Copyright: RoCCI e.V. www.rocci.net Seite 42
Sensor-Eingänge1 SENSOR_1
2 SENSOR_2
3 SENSOR_3
Motor-AusgängeA OUT_A
B OUT_B
C OUT_C
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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);
Copyright: RoCCI e.V. www.rocci.net Seite 43
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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
}
Copyright: RoCCI e.V. www.rocci.net Seite 44
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
„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
}
Copyright: RoCCI e.V. www.rocci.net Seite 45
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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;
Copyright: RoCCI e.V. www.rocci.net Seite 46
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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
Copyright: RoCCI e.V. www.rocci.net Seite 47
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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.
Copyright: RoCCI e.V. www.rocci.net Seite 48
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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.
Copyright: RoCCI e.V. www.rocci.net Seite 49
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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)
Copyright: RoCCI e.V. www.rocci.net Seite 50
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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;
Copyright: RoCCI e.V. www.rocci.net Seite 51
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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;}
Copyright: RoCCI e.V. www.rocci.net Seite 52
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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;}
Copyright: RoCCI e.V. www.rocci.net Seite 53
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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.
Copyright: RoCCI e.V. www.rocci.net Seite 54
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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{
//....}
}}
Copyright: RoCCI e.V. www.rocci.net Seite 55
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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;}if (a == 2){
Befehle;}if (a == 3){
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.
Copyright: RoCCI e.V. www.rocci.net Seite 56
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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.
Copyright: RoCCI e.V. www.rocci.net Seite 57
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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.
Copyright: RoCCI e.V. www.rocci.net Seite 58
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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.
Copyright: RoCCI e.V. www.rocci.net Seite 59
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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.
Copyright: RoCCI e.V. www.rocci.net Seite 60
RoCCI e.V. Almanach 1. AuflageKaptiel V Software
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.*/
Copyright: RoCCI e.V. www.rocci.net Seite 61
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
Copyright: RoCCI e.V. www.rocci.net Seite 62
RoCCI e.V. Almanach 1. AuflageKaptiel VI Übungsaufgaben
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.)
Copyright: RoCCI e.V. www.rocci.net Seite 63
RoCCI e.V. Almanach 1. AuflageKaptiel VI Übungsaufgaben
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.
Copyright: RoCCI e.V. www.rocci.net Seite 64
Abbildung 5
Wenn Lichtsensorwert
über 45 %unter 45 %
Roboter muss im Kreis drehen
Roboter muss gerade aus fahren.
Wenn Lichtsensorwert
über 45 %unter 45 %
Roboter muss im Kreis drehen
Wenn Lichtsensorwert Wenn Lichtsensorwert
über 45 %unter 45 %
Roboter muss im Kreis drehen
Roboter muss gerade aus fahren.
Abbildung 6
RoCCI e.V. Almanach 1. AuflageKaptiel VI Übungsaufgaben
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
Copyright: RoCCI e.V. www.rocci.net Seite 65
RoCCI e.V. Almanach 1. AuflageKaptiel VI Übungsaufgaben
2. Mechanik2.1. Anfänger
Copyright: RoCCI e.V. www.rocci.net Seite 66
RoCCI e.V. Almanach 1. AuflageKaptiel VI Übungsaufgaben
2.2. Fortgeschrittene Anfänger
Copyright: RoCCI e.V. www.rocci.net Seite 67
RoCCI e.V. Almanach 1. AuflageKaptiel VI Übungsaufgaben
2.3. Fortgeschrittene
Copyright: RoCCI e.V. www.rocci.net Seite 68
RoCCI e.V. Almanach 1. AuflageKaptiel VII Musterprüfungen
Kapitel VII: Musterprüfungen
Copyright: RoCCI e.V. www.rocci.net Seite 69
RoCCI e.V. Almanach 1. AuflageKaptiel 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
Copyright: RoCCI e.V. www.rocci.net Seite 70
RoCCI e.V. Almanach 1. AuflageKaptiel VII Musterprüfungen
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!
Copyright: RoCCI e.V. www.rocci.net Seite 71
RoCCI e.V. Almanach 1. AuflageKaptiel VII Musterprüfungen
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!
Copyright: RoCCI e.V. www.rocci.net Seite 72
RoCCI e.V. Almanach 1. AuflageKaptiel VII Musterprüfungen
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? __________
Copyright: RoCCI e.V. www.rocci.net Seite 73
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.
Copyright: RoCCI e.V. www.rocci.net Seite 74
RoCCI e.V. Almanach 1. AuflageKaptiel VIII : Fachbegriffe
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.
Copyright: RoCCI e.V. www.rocci.net Seite 75
RoCCI e.V. Almanach 1. AuflageKaptiel VIII : Fachbegriffe
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
Copyright: RoCCI e.V. www.rocci.net Seite 76
RoCCI e.V. Almanach 1. AuflageKaptiel VIII : Fachbegriffe
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
Copyright: RoCCI e.V. www.rocci.net Seite 77
RoCCI e.V. Almanach 1. AuflageKaptiel VIII : Fachbegriffe
Copyright: RoCCI e.V. www.rocci.net Seite 78
Recommended