Seite 1 von 1

Java: Neu: Java für den Bot

Verfasst: 16 Feb 2007, 19:10
von workwind
Hallo,

Ich habe die Java NanoVM erweitert und an den c't-Bot angepasst. Die NanoVM ist eine Java Virtual Machine für den Atmel AVR, insbesondere für den Asuro Roboter. Die aktuelle Version (1.5) inclusive den c't-Bot Anpassungen kann man unter der Adresse http://sourceforge.net/projects/nanovm/ herunterladen. Im Paket enthalten sind ein paar Java-Beispiele zur Steuerung des Roboters.

Viel Spaß :D !!

Gruß,
Nils

Javabeispiel

Verfasst: 16 Feb 2007, 23:56
von workwind
Hier noch ein Beispielprogramm:

[syntax="java"]
/*
DistTest.java

(c) 2007 Nils Springob <nils@nicai-systems.de>
*/

import nanovm.ctbot.drivers.*;
import nanovm.util.Formatter;
import ctbot.utils.FreeDist;

class DistTest {

public static void main(String[] args) {

Leds.set(Leds.WHITE);
Display.clear();
Display.gotoXY(0, 0);
Display.print("Dist Test");

while(true) {
FreeDist.update();
float distL = FreeDist.left;
float distR = FreeDist.right;

int rawL = DistanceSensor.getLeft();
int rawR = DistanceSensor.getRight();

Display.gotoXY(0, 1);
Display.print(Formatter.format(rawL, "raw L=%4d "));
Display.print(Formatter.format(rawR, " R=%4d "));
Display.gotoXY(0, 2);
Display.print(Formatter.format(distL, "dist L=%4.2f "));
Display.print(Formatter.format(distR, " R=%4.2f "));
Clock.delayMilliseconds(20);
}
}
}
[/syntax]

noch ein Beispiel

Verfasst: 21 Feb 2007, 09:33
von workwind
Hier noch ein Beispiel für eine statische Klasse, welche die aktuelle Position des Roboters anhand der Odometriedaten berechnent:

[syntax="java"]package ctbot.utils;

import nanovm.ctbot.drivers.*;
import nanovm.lang.Math;

public class Odometry {

public static final float M_PER_TICK = 0.002985f; // 2.985 mm/tick
public static final float M_WHEEL_DISTANCE = 0.0985f; // 98.5 mm

public static float ori;
public static float x;
public static float y;
public static float s;

/**
* normalize orientation to interval (PI, PI]
*/
public static float normalizeOri(float ori) {
while (ori>Math.PI)
ori-=2.0f*Math.PI;
while (ori<=-Math.PI)
ori+=2.0f*Math.PI;
return ori;
}

/**
* update the actual bot position data
*/
public static void update() {
int dsl = WheelEncoder.getLeftInc();
int dsr = WheelEncoder.getRightInc();
float dori = (dsl-dsr)*(M_PER_TICK/M_WHEEL_DISTANCE);
float ds = (dsl+dsr) * (0.5f * M_PER_TICK);
ori = normalizeOri(ori+dori);
s += Math.abs(ds);
x += ds * Math.cos(ori);
y += ds * Math.sin(ori);
}
}
[/syntax]

Wie Programme überspielen

Verfasst: 04 Mär 2007, 19:35
von LOBL
Hallo,

am Übersetzen der VM arbeite ich noch. Aber das hex-File rüberschaufeln klappt, das Demo-Programm läuft.
Jetzt wollte ich ein eigenes Programm überspielen. Geht das mit dem parallelen Programmieradapter oder brauche ich dazu das USB-2-Bot Kabel?

Gruß
LOBL

Re: Wie Programme überspielen

Verfasst: 06 Mär 2007, 16:28
von workwind
Hallo LOBL,

Du brauchst einen ganz normalen Programmieradapter :D (zB. einen parallelen Programmieradapter)...

Da es momentan noch keinen Bootloader für die NanoVM des ctBot's gibt :oops: , musst Du Dein eigenes Java Programm (bzw. den Bytecode) mit der VM zusammenlinken.
Am einfachsten ist das, wenn Du dein eigenes Java Programm im java/examples Verzeichnis speicherst und in der Datei vm/build/ctbot/Makefile das DEFAULT_FILE auf Deine eigene Datei umstellst. Danach reicht ein einfaches make avrdude um das Java Programm auf den AVR zu übertragen.

NanoVM 1.6

Verfasst: 09 Jul 2007, 15:41
von workwind
Hallo,

Es gibt eine neue Version der NanoVM:
The NanoVM Team today announced the immediate availability of the NanoVM
1.6, a Java VM running on Atmel AVR's. This release contains some new
features:

Version 1.6 (2007-07-07)
=================
* Nibo robot support
* Asuro ATmega168 support
* Virtual machine source folder cleanup
* New html class documentation (javadoc)
* updated install_avr_gcc script to install gcc-4.1.2, GDB=gdb-6.6,
avr-libc-1.4.6 and avrdude-5.4


The SF development pages with the download section are at

http://sourceforge.net/projects/nanovm/


Certainly, the vm was built with the avr-gcc... ;-)


Enjoy,

NanoVM Team

Verfasst: 09 Jul 2007, 16:26
von FireFox
Hallo,
was mich echt mal interessieren würde:
Ist das überhaupt performant?

Ich meine, man zwingt dem Bot eine komplette virtuelle Maschine auf, nur damit man JavaCode laufen lassen kann...?
Das ist doch viel zu viel Overhead zur Verwaltung der VM etc etc.

MfG
FireFox

Verfasst: 12 Jul 2007, 14:03
von workwind
Hallo FireFox,

Nicht so unperformat, wie man Anfangs denken würde. Bei 8 Bit Berechnung ist die VM natürlich weit abgeschlagen, aber im Bereich der 32 Bit und Floatingpoint Berechnungen kann sie durchaus mithalten! Dabei ist die Codedichte in diesem Bereich deutlich höher, man benötigt also weniger Flash Speicher, da komplette 32 Bit Operationen durch einen einzelnen 8-Bit Opcode durchgeführt werden.

Folgende Aufgabenteilung halte ich für sinnvoll:
Interruptverarbeitung, HW-Treiber -> C
Programmlogik, Berechnungen -> Java

Deshalb bietet sich der Bereich Robotik für die NanoVM an: Treiber für die Hardware in C fertig mitgeliefert, Programmlogik und Berechnungen in Java zum selberschreiben....

Gruß,
Nils

Verfasst: 12 Jul 2007, 14:25
von eax
Hi,

aber der ct-Bot-Code benutzt kaum 32 Bit-Integer- und float-Operationen, weil die auf dem AVR sowieso sehr langsam sind.

Was mich mal interessieren würde: Wie lange dauert denn beim Java-Code ein Bot-Zyklus bzw. wie oft kommt der Prozessor in der Hauptschleife "vorbei", wenn ungefähr die Komponenten aktiv sind, die auch per default im SVN aktiv sind?

Gruß Timo

Verfasst: 12 Jul 2007, 20:47
von workwind
Ich würde schätzen, dass für eine einzelne JVM Operation im Schnitt ca. 60 Zyklen benötigt werden, das würde bedeuten das bei 16 MHz ca. 250.000 Java Operationen pro Sekunde durchgeführt werden.
Wenn der Hauptloop aus 250 Operationen besteht, und 50% der Zeit in den Treiberroutinen verbracht wird, wären das 500 Loops pro Sekunde.
Das ist aber alles nur eine grobe Schätzung...!