FAQ

Nein. Es muss mindestens ein Team-Mitglied bei den Veranstaltungen anwesend sein.

Das Verwenden von Teilen, die nicht in den Kästen vorhanden sind, ist nicht gestattet, sofern diese nicht explizit durch die Aufgabenstellung erlaubt sind! Dies gilt auch für zusätzliche Legoteile wie zum Beispiel extra Sensoren.

Es gibt verschieden Möglichkeiten den EV3 zu programmieren und hierzu macht das Roborace Team keinerlei Vorgaben.
Die gängigste Software zum programmieren des EV3, welche ebenso von Lego Mindstorms entwickelt wird, ist „LEGO MINDSTORMS EV3-Software“. Dies ist eine benutzerfreundliche und symbolbasierte Entwicklungsumgebung für den EV3 vor allem geeignet für SchülerInnen mit wenig Programmiererfahrung. Die LEGO MINDSTORMS EV3-Software sowie die Softwarepackete für die Sensoren sind hier zu finden.
Ebenso gängig ist die Software LeJOS. Diese ermöglicht ein objektorientiertes Programmieren des EV3 in Java. Für LeJOS gibt es jede Menge vorgefertigte Klassen und eine gut dokumentierte API, was auch Java AnfängerIn beim Einstieg in die Software hilft.
Das aus NXT-Zeiten bekannte, auf C basierende BricxCC wurde, soweit uns bekannt ist, bisher noch nicht für die Nutzung für die neuen EV3s angepasst. Alternativ dazu gibt es die MonoBrick Firmware mit welcher es möglich ist sowohl C als auch Python als Programmiersprache zu nutzen.
Eine kostenpflichtige Alternative ist die C basierte Roboterplattform „RobotC“, welche eventuell von einigen Schulen genutzt wird.

Kurzversion:

1. Erstellung der SD-Karte:
   Die im Kasten enthaltene SD-Karte auf FAT-32 formatieren.
   LeJOS hier (Version 0.9.1-beta) herunterladen, entpacken und auf SD Karte kopieren.
   Die SD-Karte in den EV3 Brick stecken
   Etwa 15 min warten, bis die LejOS Installation abgeschlossen ist
   Für dauerhaften Betrieb mit LejOS, SD-Karte nicht entfernen.
   ACHTUNG!! SD-Karte darf keine anderen Dateien als die oben gezeigten enthalten!! Selbst geschriebene Programme müssen mit dem USB-Kabel auf den Brick übertragen werden!!
2. Installation von LeJOS auf dem PC. Installationsdateien sind hier (Version 0.9.1-beta) zu finden.
3. Installation von Eclipse. Installationsdatei ist hier zu finden.
   Empfohlene Version ist "Eclipse IDE for Java Developers"
4. Eclipse-EV3 Plugin installieren
   In Eclipse das Help-Menü öffnen, dort auf "Install New Software" anklicken.
   Auf "Add..." klicken und folgende URL eingeben: http://www.lejos.org/tools/eclipse/plugin/ev3/
   Das Paket „leJOS EV3 support“ installieren
   In den Eclipse Einstellungen nun noch das EV3_HOME Verzeichnis auf das Installationsverzeichnis von LeJOS setzen

Eine ausführliche Schritt für Schritt Anleitung als Video (aktuelle Links sind oben im Text zu finden).

USB RNDIS Treiber Problem
Wenn Ihr EV3 nicht über USB erkannt wird, könnte das an einem fehlenden RNDIS-Treiber liegen. Falls der RNDIS-Treiber nicht installiert ist, macht Ihr PC nicht das gewohnte USB-Geräusch beim an- und abschließen des USB Kabels.  Außerdem kann beim Ausführen eines LeJOS-Programm in Eclipse kein EV3-Brick gefunden werden. Um den Treiber nachträglich zu installieren, können Sie dieser Anleitung folgen.
Falls trotz vorhandenem RNDIS Treiber kein EV3-Brick in Eclipse gefunden wird, ist der LEGO-Brick möglicherweise über eine USB COM-Schnittstelle angeschlossen. Dies kann im Gerätemanager überprüft werden. In diesem Fall muss manuell die Schnittstelle auf RNDIS gewechselt werden. Eine Anleitung ist hier zu finden. Außerdem kann es helfen die SD-Karte nochmals zu formatieren und LeJOS, wie in Schritt 1 beschrieben, auf die Karte zu kopieren.
Weiter kann die Übertragung des Programms über die Bluetooth-Verbindung Probleme mit der USB-Schnittstelle umgehen.

In den ausgegebenen Kästen sind 4 verschiedene EV3 Sensoren enthalten. Diese bilden die Schnittstelle zwischen Roboter und der Umwelt indem bestimmte Werte an den Roboter übermittelt werden. Im Folgenden werden die Sensoren kurz beschrieben:

• EV3 Touch Sensor
  Der EV3 Touch Sensor ist ein simples Werkzeug zum Erkennen von Berührungen. Wird der rote Knopf des Sensors betätigt so übergibt der Sensor den Wert 1. Bleibt er unbetätigt so ist der Wert des Sensors 0. Somit können zum Beispiel das Auffahren auf ein Hindernis erkannt werden oder ein Startknopf für das Programm realisiert werden.
• EV3 Color Sensor
  Der digitale Farbsensor kann acht verschiedene Farben (farblos, schwarz, blau, grün, gelb, rot, weiß, braun) erkennen. Darüber hinaus dient er als Lichtsensor, der die Lichtstärke erkennt. Zusätzlich befindet sich eine LED am Sensor durch die wahlweise rotes Licht oder ein RGB Strahl ausgesendet werden kann um verschiedene Untergründe zu erkennen. Diese kann auch komplett ausgeschalten werden um das Umgebungslicht zu messen. 
• EV3 Gyro Sensor
  Der digitale EV3-Gyrosensor misst die Drehbewegung und die Richtungsänderungen des Roboters. So können die Winkelgeschwindigkeit sowie der Winkel des Roboters bestimmt werden. Der Sensor kann für die Navigation des Roboters, das Ausbalancieren eines Gegenstandes oder des kompletten Roboters (Segway) genutzt werden.
• EV3 Ultrasonic Sensor
  Der EV3 Ultrasonic Sensor ermittelt über Ultraschall die Entfernung zu Objekten. Der Abstand darf jedoch nicht kleiner als 4 cm und nicht größer als 250 cm sein, sonst kommt es zu Messwertverfälschungen. Gemessen werden kann sowohl in Zentimeter als auch in Inch. Störquellen des Ultraschallsensoren können schräge bzw. runde Objekte sein die den Schall nicht genug reflektieren oder andere Roboter mit Ultraschallsensoren. Der Ultraschallsensor bietet sich hauptsächlich dazu an Hindernisse berührungsfrei zu erkennen.

Da das Auslesen der Sensoren mit Hilfe von Lejos nicht ganz selbsterklärend ist, sind hier kommentierte Beispiele der verschiedenen Sensoren aufgelistet. Zeilen, welche mit // beginnen, stellen dabei die Kommentare dar und sind nur zum besseren Verständnis eingefügt. Natürlich müssen vor der Verwendung der EV3 Befehle die benötigten Imports zu Beginn des Programms gemacht werden. Diese werden jedoch von Eclipse vorgeschlagen. 

• EV3 Touch Sensor
  EV3TouchSensor touch_sensor = new EV3TouchSensor(SensorPort.S3);
// Erzeugen des Objektes touch_sensor am Port 3 (initialisieren)
float[] sample_touch = new float[touch.sampleSize()];
// Erzeugen des so genannten “samples” das zum Auslesen benötigt wird
while (true) {
touch.fetchSample(sample_touch, 0);
// Auslesen des Sensorwerts, die 0 beschreibt das Offset (hier immer 0)
touch_wert = sample_touch[0];
// Übergeben des Sensorwerts in die Variable touch_wert, diese ist nun 0 oder 1, was gedrückt oder nicht gedrückt bedeutet
}

• EV3 Color Sensor
  EV3ColorSensor color_sensor = new EV3ColorSensor(SensorPort.S1);
// Erzeugen des Objektes color_sensor am Port 1 (initialisieren)
SensorMode rgb_mode = color_sensor.getRGBMode();
// Hier wird das vom Sensor ausstrahlende Licht bestimmt (hier RGB), möglich ist auch rotes Licht (red) oder kein Licht(ambient)
float[] sample_licht = new float[rgb_mode.sampleSize()];
// Erzeugen des so genannten “samples” das zum Auslesen benötigt wird
while (true) {
rgb_mode.fetchSample(sample_licht, 0);
// Auslesen des Sensorwerts, die 0 beschreibt das Offset
lichtwert = sample_licht[0];
// Auslesen der Lichtintesität und zuweisen der Variable lichtwert
farbID = colorSensor.getColorID();
// Übergeben der Farbe zugewiesenen
}

• EV3 Gyro Sensor
  EV3GyroSensor gyro_sensor = new EV3GyroSensor(SensorPort.S4);
// Erzeugen des Objektes gyro_sensor am Port 4 (initialisieren)
SampleProvider sampleprovider_gyro = gyro_sensor.getAngleMode();
// Erzeugen des so genannten “sampleprovider” der entweder angibt das der Winkel ausgelesen wird (hier) oder die Winkelgeschwindigkeit (getRateMode)
float[] sample_gyro = new float[sampleprovider_gyro.sampleSize()];
// Erzeugen des so genannten “samples” das zum Auslesen benötigt wird
while (true) {
sampleprovider_gyro.fetchSample(sample_gyro, 0);
// Auslesen des Sensorwerts, die 0 beschreibt das Offset
winkel = sample_gyro[0];
// Übergeben des Winkels
}

• EV3 Ultrasonic Sensor
  EV3UltrasonicSensor ultrasonic_sensor = new EV3UltrasonicSensor(SensorPort.S2);
// Erzeugen des Objektes ultrasonic_sensor am Port 4 (initialisieren)
SampleProvider distanz= ultrasonic_sensor.getDistanceMode();
// Erzeugen des so genannten “sampleprovider” der entweder angibt das der Distanz ausgelesen wird (hier) oder nach anderen Ultraschallsensoren gehört wird (getListenMode)
float[] sample_ultrasonic = new float[distanz.sampleSize()];
// Erzeugen des so genannten “samples” das zum Auslesen benötigt wird
while(true) {
distanz.fetchSample(sample_ultrasonic, 0);
// Auslesen des Sensorwerts, die 0 beschreibt das Offset
abstand = sample_ ultrasonic [0];
// Auslesen des Winkels
}

Es gibt zwei verschiedene Arten an EV3 Motoren, den „EV3LargeRegulatedMotor“ und den „EV3MediumRegulatedMotor“. Natürlich müssen vor der Verwendung der EV3 Befehle die benötigten Imports zu Beginn des Programms gemacht werden. Diese werden jedoch von Eclipse vorgeschlagen. Die Ansteuerung in Lejos wird in folgendem Code verdeutlicht:

RegulatedMotor motor_klein = new EV3MediumRegulatedMotor(MotorPort.B);
RegulatedMotor motor_groß = new EV3LargeRegulatedMotor(MotorPort.C);
// Initialisieren der beiden Motortypen
motor_klein.setSpeed(100);
motor_groß.setSpeed(200);
// Setzten der Geschwindigkeiten der beiden Motoren in degree/sec.
motor_klein.forward();
Motor_groß.backward();
// festlegen der Drehrichtung, geht leider nicht über das Vorzeichen der Geschwindigkeit sondern muss davor durch eine if Schleife bestimmt werden.

Die Motoren enthalten zusätzlich Encoder, durch welche die Drehgeschwindigkeit sowie der Winkel des Motors ausgelesen werden kann. Darauf wird hier aber nicht näher eingegangen.

Ein häufiges Problem bei der Nutzung des Gyro Sensors ist dessen Drift. Dieser zeigt sich durch hochzählen (bzw. runterzählen) des Winkels, obwohl sich der Sensor in Ruhe befindet. Folgende Tipps können den Drift extrem verringern:

• Sensor bei absoluter Ruhe aus - und einstecken
• Wechseln des Modus von Winkelgeschwindigkeit (rate) zu Winkel (angle) kalibriert den Sensor. Dies muss auch in Ruhe geschehen
• Drift zu Beginn eines Programmes messen und während der Ausführung ständig zum Winkel addieren/subtrahieren
• Sensor exakt an der Drehachse befestigen
• Winkel selbst aus der Winkelgeschwindigkeit integrieren

Der PID-Regler ist ein weitverbreitetes regelungstechnisches Werkzeug um Maschinen aus ganz verschiedenen Bereichen zu regeln. Angefangen mit Robotern, Fahrzeugen bis hin zu Raketen. Das mathematische Modell eines PID-Reglers ist Bestandteil der Regelungstechnik Vorlesungen und soll hier nicht im Detail behandelt werden. Die verschiedenen Bestandteile des PID-Reglers sowie die möglichen Stellschrauben sollen im Folgenden anhand des Problems der Linienverfolgung erklärt werden.

Hierzu betrachten wir einen einfachen Roboter mit zwei angetriebenen Rädern und einem Lichtsensor, dessen Aufgabe es sein wird einer schwarzen Linie auf einer weißen Oberfläche zu folgen. Die Räder des Roboters werden von zwei unabhängigen Motoren angetrieben, damit der  Roboter seine Fahrtrichtung ändern kann. Der Lichtsensor ist ganz vorne montiert und ist auf den Untergrund gerichtet. Mit diesem wird die Linie wahrgenommen, oder um genauer zu sein die Helligkeitsintensität des Untergrundes.
Der erste Trick den wir verwenden hat erst einmal nichts mit einem PID-Regler zu tun. Wir folgen zunächst nicht der Linie selbst, sondern deren Kante. Das vereinfacht die Aufgabe in sofern, das wir jetzt genau definieren können auf welcher Seite der Linie wir uns befinden. Folgen wir der linken Kante der Linie und der Lichtsensor sieht vermehrt Schwarz, so wissen wir, dass wir nach rechts abdriften und deshalb nach links gegen steuern müssen. Das gleiche gilt im umgekehrten Sinn für das Abdriften nach links. Das gleiche Spiel kann man natürlich auch auf der rechten Seite der Linie machen. Dann werden die soeben angesprochenen Gesetzmäßigkeiten jeweils umgekehrt.
Um nun herausfinden zu können, wohin wir abdriften, müssen wir herausfinden welche Werte unser Lichtsensor für weiße Oberflächen liefert und welche für schwarze. Ein Lichtsensor liefert in der Regel Werte von 0 bis 100 für die jeweilige Helligkeitsintensität. Es ist sinnvoll sich erst mal die Werte auf eine Skala einzuzeichnen und die Werte für Weiß und Schwarz zu markieren. Hat man diesen Wertebereich markiert, so halbiert man die Skala um festzulegen wann nach Links und wann Rechts gefahren wird. Dieser Ansatz hat zur Folge, dass der Roboter niemals geradeaus fahren wird, sondern immer nach links oder rechts lenken, je nachdem welchen Wert er gerade misst, außerdem wird es immer nur eine Art der Kurve geben die der Roboter fahren kann, dass einzige was sich ändert ist wie lang er diese fährt. Um das Problem der Geradeausfahrt zu verbessern, könnte man natürlich auch zusätzlich einen Bereich um die gesetzte Mitte definieren in dem der Roboter gerade aus fährt. Das würde allerdings nicht das Problem der festdefinierten Kurven lösen.
An dieser Stelle kommt der PID-Regler ins Spiel. Dieser besteht aus drei unterschiedlichen Komponenten: dem P, dem I und dem D Teil. Wir werden dieses der Reihe nach besprechen und auf unser Problem anwenden.

Der P-Teil

Das P in PID steht für "proportional" und bedeutet, dass die Steuergröße proportional zur Abweichung gewählt wird. Die Steuergröße steht in diesem Fall für die Stärke der Drehung des Roboters und die Abweichung ist die Differenz zwischen einem gewünschten (Linien-Kante) und dem gemessenen Helligkeitswert und wird im folgenden als "Fehler" bezeichnet.

Fehler = Soll_Wert - Ist_Wert

Die Proportionalität ist durch eine Gerade y = - mx gegeben. In der Geraden ist der Faktor m auschlaggebend dafür wie stark der Regler korrigieren soll. Die Steigung der Geradengleichung wird im Falle des PID-Reglers als „Kp“ bezeichnet. Der X-Wert steht für den Fehler. Der Y-Wert wird „Drehung“ genannt. Benutzen wir nun die neuen Namen für unsere Geradengleichung, so erhalten wir:

Drehung = Kp * Fehler

In Worten heißt das, dass die Intensität der Drehung gleich dem Produkt des Fehlers mit einer frei wählbaren Konstanten „Kp“ gewählt wird.
In dem Bild der Geraden hat man vielleicht bemerkt, dass die Gerade nicht weiter als +/-5 geht. Das liegt daran, dass sobald der Lichtsensor nur noch auf der weißen Oberfläche ist nur noch einen konstanten Wert für Weiß liefert und wir somit nicht mehr genau sagen können wie weit entfernt wir uns von der Linie befinden. Deshalb ist es an dieser Stelle sinnvoll die Y-Achse zu beschränken, damit nicht unendlich starke Korrekturen auftreten und der Roboter mit Vollgas über die Linie hinausschießt.
Wenden wir jetzt unseren P-Regler auf unseren Roboter an. Dazu muss der Y-Wert (Drehung) auf die Motoren gegeben werden. Zunächst wird jedoch eine Konstante "KG" festgelegt mit der sich beide Motoren langsam geradeausdrehen. Um jetzt die vom Regler berechnete Drehung auf die Motoren anzuwenden wird ein Motor mit der Geschwindigkeit „KG + Drehung“ und der andere mit „KG - Drehung“ angesteuert.
Zusammenfassend ist ein P-Regler sehr einfach aufgebaut. Man misst einen Ist-Wert, vergleicht diesen mit einem Soll-Wert und bildet die Differenz aus beiden. Das ist dann der Fehler. Diesen Fehler multiplizieren wir dann mit unserm „Kp“ Faktor und erhalten dann denn Korrekturwert für unsere Motoren.

Der I-Teil

Um das Verhalten unseres P-Reglers zu verbessern fügen wir diesem einen so genannten I-Teil (Integralteil) hinzu. Der I-Teil bildet vereinfacht gesagt die Summe der Fehler über die Zeit ab und stellt somit eine Art Gedächtnis dar. Jedes Mal wenn wir den Lichtsensor auslesen errechnen wir einen Fehler. Diesen verwenden wir einerseits für den P-Regler und jetzt auch für unseren I-Regler. Und zwar addieren wir jeden neuen Fehler auf den alten auf. In der while-Schleife eines Programmes in der jedes mal der Fehler ausgelesen wird, kann man dass dann so ausdrücken:

Integral = Integral + Fehler

Die Formel besagt, dass wir zur alten Fehlersumme den neuen gemessenen Fehler addieren und diese als neue Fehlersumme abspeichern. Nun multiplizieren wir das "Integral" wie beim P-Teil mit einem Faktor "Ki“. Diese neue Formel addieren wir auf unsere alte P-Regler Formel und erhalten die Formel eines PI-Reglers.

Drehung = Kp * Fehler + Ki * Integral

Wie genau hilft uns das Integral denn nun? Wenn der Fehler eine Weile das gleiche Vorzeichen behält, summiert sich unser Integral auf. Z.B ist der Fehler beim ersten Lesen 1, beim nächsten und übernächsten 2. Damit ergibt sich ein Integral von 1+2+2=5. Die Korrektur die der Regler also vornimmt wird umso stärker je länger der Fehler das gleiche Vorzeichen hat. Dadurch wird erreicht, dass der Roboter nach genügend langer Zeit tatsächlich zur Linienkannte zurückfindet und nicht parallel versetzt fährt wie das bei einem reinen P-Regler vorkommen kann. Allerdings birgt der I-Teil auch Risiken. Bleibt der Roboter eine sehr lange Zeit auf einer Seite der Linie, so wir die Fehlersumme irgendwann sehr groß, da das Vorzeichen des Fehlers über längere Zeit gleich bleibt. Das führt dazu, dass das Integral zu groß wird und irgendwann dazu führt das der Roboter zu stark korrigiert und von der Bahn abkommt. Dies ist insbesondere der Fall wenn die Stellgröße beschränkt ist! Deshalb ist es ratsam, das Integral in gewissen Abständen immer mal wieder auf 0 zu setzen.

Der D-Teil

Der D-Teil ist der letzte Teil unseres PID-Reglers und bedeutet „derivative“ (Ableitung). Die Aufgabe des D-Teils ist es die Änderung des Fehlers zu nutzen um dadurch gewissermaßen in die Zukunft zu schauen und vorherzusagen wie sich der Fehler entwickeln wird.
Wie schaut der D-Teil in die Zukunft? Durch die Annahme, dass der nächste Fehler gleich dem aktuell gemessenem Fehler plus der vorgegangen Fehleränderung (Ableitung) sein wird. 

nächster Fehler = aktueller Fehler + aktuelle Ableitung

z.B.: der aktuelle Fehler ist 2 und der letzte war 5. Daraus folgt, dass die Änderung 2-5 = -3 ist. Dieses verwenden wir jetzt um den nächsten Fehler zu schätzen. Wir erwarten demnach einen Fehler von 2-3=-1 bei der nächsten Messung. Wir nutzen diese Schätzung nun um unseren Regler zu beeinflussen. Dafür wird die Ableitung wieder mit einem Faktor "Kd" multipliziert.
Damit haben wir das letzte Glied unseres PID-Reglers.

Drehung =  Kp * Fehler + Ki * Integral + Kd * Ableitung

Damit hätten wir einen vollständigen PID-Regler. Es bleibt nur noch die optimalen „K-Faktoren“ zu finden.

Hier

- Erfolgreiche Teilnahme an der Qualifikation
- Teilnahme an der Vorrunde
- Qualifikation für das Finale und Teilnahme am Finale
  oder Bericht (Aufgabenbeschreibung, Vorgehensweise, aufgetretene Probleme, Lösungsansätze) an Simon Lang (per Email).
- LEGO-Kästen SORTIERT zurückgegeben