Eclipse und Roboter Simulation

Die Bibliothek EV3JLIB enthält zusätzlich einen Simulations-Modus. Mit dem Simulation-Modus könnt ihr eure EV3-Programme auf eurem Rechner ohne den EV3 laufen lassen. Der EV3 wird dann per Software simuliert und die Bewegung wird in einem Java-Fenster graphisch dargestellt. Hier möchte ich euch zeigen, wie ihr euer EV3-Java-Programm im Simulations-Modus zum laufen bringt.

RobotSim – Dateien in den Eclipse-Workspace kopieren

Damit ihr den Simulation-Modus der EV3JLIB – Bibliothek nutzen könnt, müsst ihr euch eine zusätzliche Bibliothek herunterladen, die in dem Paket JGameGrid enthalten ist. JGameGrid könnt ihr euch von hier herunterladen: Download JGameGrid.

Nach dem Download solltet ihr die Dateien noch in euren Eclipse-Workspace für eure EV3-Projekte kopieren. Auch diese Dateien aus JGameGrid hab ich wieder in das Lib-Verzeichnis von leJOS kopiert.

Euer aktuelles leJOS-Verzeichnis findet ihr z.B. unter den Einstellungen für das EV3-Plugin in Eclipse unter: Eclipse -> Einstellungen -> leJOS EV3 -> EV3_HOME

Auf der gleichen Ebene des EV3_HOME-Verzeichnis hab ich dann wieder ein neues Verzeichnis mit dem Namen JGameGrid angelegt und den gesamten Inhalt aus der heruntergeladenen JGameGrid-ZIP-Datei in das neue Verzeichnis kopiert.

Im Verzeichnis robotsim/lib befindet sich das Package RobotSim.jar, welches ihr für eure Java-Programme benötigt um die EV3-Simulation zu verwenden. Dann gibt es im Verzeichnis robotsim u.a. noch diese Verzeichnisse:

• javadoc: Die Dokumentation für RobotSim im HTML-Format
• examples: Java-Beispiele für RobotSim
• src: Der gesamte Quellcode der Bibliothek RobotSim

Neues Projekt anlegen

Ein neues Projekt müsst ihr in diesem Fall nicht unbedingt anlegen. Ihr könnt auch einfach, wie weiter unten beschrieben, die beiden benötigen Bibliotheken robotsim.jar und JGameGrid.jar in eure bestehende Projekte einfügen. Zum erklären und verstehen der Funktionsweise der Roboter-Simulation ist es aber übersichtlicher mit einem neuen Projekt zu starten.

Als nächstes legen wir in dem gleichen Eclipse-Workspace, wie das Projekt leJOS, ein neues EV3-Projekt mit  File -> New -> Project.. -> leJOS EV3 Project an. Unter Projekt-Name geben wir den Namen des EV3-Projekts ein. Ich nenne das diesmal robotsim. Unter JRE wählen wir wieder Use a project specific JRE aus. Und als JRE wählen nehmen wir das im vorherigen Schritt konfigurierte JDK 1.8.

Nach dem Klick auf den Finish – Button wird das Projekt angelegt und enthält bereits wieder die für leJOS benötigten JAVA-Bibliotheken.

Zusätzlich benötigt ihr zum Programmieren mit RobotSim jetzt noch die Bibliotheken robotsim.jar und JGamegrid.jar (für die grafische Darstellung im Java-Fenster) im Build-Path eures Projekts. Die Bibliotheken könnt ihr in Eclipse mit einem Klick der rechten Maustaste auf euer neues robotsim-Projekt im Package-Explorer -> Properties -> JAVA Build Path -> Libraries -> Add External jars.. hinzufügen.

Zuerst navigiert ihr zu der Bibliothek robotsim.jar im Verzeichnis von JGameGrid unter robotsim/lib und wählt sie aus.

Danach wählt ihr auf die gleiche Weise noch die Bibliothek JGameGrid.jar im Pfad lib im Verzeichnis JGameGrid aus.

Danach sollten die Bibliotheken robotsim.jar und JGameGrid.jar in eurem Build-Path und im Package-Explorer von Eclipse auftauchen.

Zur graphischen Darstellung des Roboters, von Hindernissen oder Hintergründen im Java-Fenster benötigt die Bibliothek robotsim.jar noch kleine Grafiken und Hintergründe, sogenannte Sprites. Die Hintergründe werden z.B. zur Darstellung von Bahnen, auf denen der Roboter entlang fahren soll, verwendet. Ihr könnt die vorgefertigten Hintergründe aus dem Sprites-Verzeichnis verwenden oder euch eigene erstellen.

Die Sprites für robotsim.jar befinden sich im Verzeichnis von JGamesGrid unter spritepictures/robot-raspi-sim.

Die Sprites müsst ihr in euer Eclipse-Projekt-Verzeichnis robotsim in ein neues Verzeichnis mit dem Namen sprites kopieren, damit die Bibliothek robotsim.jar die Sprites beim Programmstart findet. Nach dem kopieren müsst ihr sehr wahrscheinlich in Eclipse erst mal einen Refresh (Rechte Mausklick auf das Projekt robotsim -> Refresh oder einfach F5 drücken) im Package-Explorer durchführen, damit euch Eclipse die Sprites auch anzeigt.

Wenn ihr in Eclipse ein JDK größer als 1.7 verwendet, müsst ihr die Compiler-Einstellung diesmal nicht unbedingt auf die Compiler-Version 1.7 umstellen. Die Simulation läuft auch mit neueren JDK-Versionen.

BorderFollower

Für das erste Beispiel könnt ihr das Programm BorderFollower aus dem letzten Kapitel mit der EV3JLIB verwenden. Die Klassen- und Methoden-Namen für die Steuerung des EV3 sind in beiden Bibliotheken (ev3jlib.jar und robotsim.jar) gleich. D.h. Ihr könnt zunächst eure Algorithmen mit der Simulation testen und wenn alles gut funktioniert, tauscht ihr einfach die Import-Direktiven auf die Klassen in der robotsim.jar mit den Import-Direktiven aus der Bibliothek ev3jlib.jar aus. Danach läuft das Programm auf eurem EV3 ohne das ihr den Algorithmus umschreiben müsst. Cool oder nicht?

Mit dem Programm BorderFollower machen wir hier das Gleiche, nur umgedreht.

Zunächst legen wir eine neue Klasse an. Das geht wie gehabt über File -> New -> Class. Als Package-Namen hab ich diesmal z.B. com.lego.ev3.robotsim vergeben, weil das Programm diesmal mit den Klassen aus der Bibliothek robotsim zusammen laufen soll. Als Namen wähle ich wieder BorderFollower.

Mit Klick auf Finish wird die Java-Klasse angelegt.

Kopiert nun folgenden Beispiel-Code in eure neu angelegte Klasse:

package com.lego.ev3.robotsim;

// Imports aus der ev3jlib auskommentieren
//import ch.aplu.ev3.LegoRobot;
//import ch.aplu.ev3.LightSensor;
//import ch.aplu.ev3.SensorPort;
//import ch.aplu.ev3.Gear;

// Imports mit den gleichen Klassen aus robotsim nutzen
import ch.aplu.robotsim.LegoRobot;
import ch.aplu.robotsim.LightSensor;
import ch.aplu.robotsim.SensorPort;
import ch.aplu.robotsim.Gear;

import ch.aplu.robotsim.RobotContext;

class BorderFollower {
  BorderFollower() {
    // Java-Fenster für die Simulation initialisieren

    // Eine Navigations-Leiste am Fenster anzeigen
    RobotContext.showNavigationBar();
    // Start-Position des Roboters im Fenster setzen (x,y)
    RobotContext.setStartPosition(220, 460);
    // Start-Richtung des Roboters im Fenster setzen
    RobotContext.setStartDirection(-90);
    // Hintergrund mit einer Straße im Fenster anzeigen
    RobotContext.useBackground("sprites/black_white.gif");
	  
    // Eigentliche Roboter-Steuerung starten
    LegoRobot robot = new LegoRobot();
    // Lichtsensor an Eingang S1 des EV3-Bricks
    LightSensor ls = new LightSensor(SensorPort.S1);
    robot.addPart(ls);
    ls.activate(true);
    Gear gear = new Gear();
    gear.setSpeed(20);
    robot.addPart(gear);
    while (true) {
      if (ls.getValue() < 500)
        gear.leftArc(0.25);
      else
        gear.rightArc(0.25);
    }
  }

  public static void main(String[] args) {
    new BorderFollower();
  }
}

Hinweis:
Damit das Programm korrekt funktioniert, müsst ihr unter Eclipse das main-Programm als Java-Applikation starten.

Im Prinzip sind folgende Änderungen für die Simulation nötig gewesen (fett markiert):

• Die Imports auf die EV3-Bibliothek ch.aplu.ev3.* wurden ersetzt durch Imports auf die Bibliothek robotsom.jar ch.aplu.robotsim.*
• Beim Anlegen der Instanz der Klasse LegoRobot wurde die Angabe der IP-Adresse entfernt, da es diesen Konstruktor in der robotsim.jar nicht gibt (ist ja auch nicht nötig)
• Das Java-Fenster zur Darstellung der Simulation wird initialisiert

Das kleine Programm führt folgende Aktionen durch:

• Öffnen eines JAVA-Fensters mit dem angegebenen Hintergrund
• Im Fenster fährt der EV3-Sprite mit dem Beispiel-Algorithmus entlang des Pfades

ColorSensorTest

Im zweiten Beispiel fährt der Roboter über verschiedene Farbsensoren und zeigt in einer Statuszeile die Werte des Farbsensors an.

Legt wieder eine neue Java-Klasse an und gebt ihr den Namen ColorSensorTest. Kopiert nun folgenden Beispiel-Code in eure neu angelegte Klasse und startet es wie gehabt als Java Application.

package com.lego.ev3.robotsim;

import ch.aplu.robotsim.RobotContext;

import ch.aplu.robotsim.LegoRobot;
import ch.aplu.robotsim.SensorPort;
import ch.aplu.robotsim.Gear;
import ch.aplu.robotsim.ColorSensor;
import ch.aplu.robotsim.Tools;

public class ColorSensorTest {

  ColorSensorTest() {
    RobotContext.showNavigationBar();
    RobotContext.setStartPosition(250, 300);
    RobotContext.setStartDirection(-90);
    RobotContext.useBackground("sprites/colorbar.gif");
    RobotContext.showStatusBar(20);

    LegoRobot robot = new LegoRobot();
    Gear gear = new Gear();
    ColorSensor colorSensor = new ColorSensor(SensorPort.S1);
    robot.addPart(gear);
    robot.addPart(colorSensor);
    gear.setSpeed(20);
    gear.forward();
    int n = 0;
    while (true) {
      n++;
      System.out.println("Measure # " + n
	       	          + ": Intensity: " + colorSensor.getLightValue()
		          + " Color: " + colorSensor.getColor());
      Tools.delay(500);
    }
  }

  public static void main(String[] args) {
    new ColorSensorTest();
  }

}

Die hier vorgestellten und weitere Beispiele findet ihr im dem Verzeichnis robotsim/examples  oder auf der Webseite von Dr. Aegidus Pluess.