Inhalt


Java ASURO Control - ASURO mit Java fernsteuern

Ein einfaches Java-Programm, um den ASURO-Roboter über die IR-Schnittstelle zu steuern.

Der ASURO von Maria Was kann das Programm:

  • Motoren steuern
  • LEDs steuern
  • Batteriespannung auslesen
  • Liniensensordaten auslesen
  • Odometriesignalverlauf sichtbar machen (nützlich zur Fehlersuche bei Odometrieproblemen)
  • Die Beschleunigungskurve beim Anfahren kann gemessen werden

Was wird zur Ausführung benötigt:

Vorkompilierte und SourceCode-Version: V6 neu: mit Geschwindigkeitsdiagramm ( Zip-Datei)

Das Programm ist sehr nützlich zur Fehlersuche. Da es oft Probleme mit den Encodern des ASURO gibt, ist es sehr hilfreich, die Signale aufzunehmen und anzeigen zu lassen.
Mit diesem Programm kann das mit einem Tastendruck erledigt werden.
Encodersignalverlauf:
Encodersignalverlauf

Bei vielen ASURO-Robotern ist es der Fall, dass die Motoren unterschiedlich schnell laufen. Das kann verschiedene Gründe haben. Meistens liegt es daran, das die Zahnräder auf beiden Seiten unterschiedlich stark aufeinanderdrücken.
Die Zahnräder sollten sich möglichst nur berühren, ohne Druck aufeinander auszuüben.
Mit dem Programm kann der Geschwindigkeitsverlauf beim Beschleunigen dargestellt werden und so eventuell vorhanden Ungleichmässigkeiten sichtbar machen.
Geschwindigkeitsdiagramm beim Anfahren:
Geschwindigkeitsdiagramm beim Anfahren

Die IR-Schnittstelle des ASURO-Roboters wird als serielle Schnittstelle angesprochen. Um mit Java die serielle Schnittstelle benutzen zu können, braucht man einen Treiber.
Die von SUN angebotene COM-Schnittstelle scheint nur Linux und Mac zu unterstützen. Deshalb wird ein anderer Treiber benötigt: RXTX

Installation

Windows:
Falls die Java-Runtime-Engine ( JRE ) schon installiert ist, muss man nur noch RXTX installieren.
Dazu müssen nur zwei Dateien an die richtigen Stellen kopiert werden.

  1. RXTXcomm.jar muss in JAVA_HOME\jre\lib\ext
  2. rxtxSerial.dll muss in JAVA_HOME\jre\bin

Beispielsweise ist bei meinem Rechner JAVA_HOME das Verzeichnis c:\Programm\Java\jre1.6.0_03
Das heißt, in diesem Fall muss man
RXTXcomm.jar nach c:\Programm\Java\jre1.6.0_03\jre\lib\ext
und
rxtxSerial.dll nach c:\Programm\Java\jre1.6.0_03\jre\bin
kopieren.

Das Programm kann danach einfach mit einem Doppelklick auf das Jar-File gestartet werden.

Allgemeines zu Java

Für Java gibt es eine Entwicklungsumgebung (JDK) mit der man Programme entwickeln kann und eine Laufzeitumgebung (JRE), mit der man ein Programm ausführen kann.
Wenn das Programm nur benutzen will und keine neues Programm schreiben will, muss nur die Java-Laufzeitumgebung JRE) installiert werden.
JRE bedeutet übrigens "java runtime enviroment" und wird für die Ausführung von Java-Programmen benötigt.

JRE kann von der Sun-Homepage heruntergeladen werden.

Da es immer wieder Neuerungen bei Java gibt, wird bei einer Neuinstallation die neue Laufzeitumgebung installiert und die alte Version nicht gelöscht. Es kann dann sein, dass sich mehrere Versionen im Java-Ordner befinden. In diesem Fall muss RXTXCOMM.JAR natürlich in den richtigen Ordner kopiert werden.

Eine Diskussion und Code zum Java Asuro Control Programm befindet sich hier.


Der sprechende ASURO

Hier wird ein Programm vorgestellt, welches es ermöglichen soll, dass der ASURO spricht.

Die besondere Herausforderung dabei ist, dass der ASURO keinen Lautsprecher, wenig Speicher und wenig Rechenleistung besitzt.
Der erste Versuch, dem Roboter das Sprechen beizubringen, stammt vermutlich von Arrex-Henk von Arexx-Engineering.
Dort hat der ASURO über die IR-Verbindung Befehle an den PC-gesandt und diesen zur Sprachausgabe veranlasst.

Mit dem hier vorgestellten Programm spricht der ASURO allerdings wirklich. Das Wort "Hallo" wird über die Motoren ausgegeben.

Will man eigene Worte erzeugen, kann man dies mit Hilfe des Programms Srecord tun.

Download: Source code ( Zip-Datei)

Neu: Zweistimmige Tonerzeugung mit den ASURO-Motoren ( Zip-Datei)


ASURO-Kamerasteuerung

ASURO-Bilddetektor Ein rot gekennzeichneter ASURO wird von einer Kamera am PC beobachtet.
Der PC sendet die Koordinaten des ASURO auf die IR-Schnittstelle.
Dadurch wird es dem ASURO ermöglicht, seine Position zu bestimmen.

Download: Source code ( Zip-Datei)

Entwicklungstools:


Multitasking für den ASURO-Roboter

Für einen Roboter kann es wichtig sein, mehrere Aufgaben gleichzeitig zu bearbeiten. Hier wird die grundlegende Strukur gezeigt, wie man das ohne Multitaskingbetriebssystem erreichen kann.
Das hier vorgestellte System entspricht der Struktur des Multitasking mit endlichen Automaten ( PDF Kap. 4.2.4 S.58 ).

//*******************************************************************
//
// Multitasking ohne Betriebsystem
//
// Beispiel fr ASURO Roboter
//
// In diesem Programm laufen mehrere Programmteile quasi "gleichzeitig"
// Oft ist es bei der Roboterprogrammierung notwendig, dass mehrere
// Aufgaben zur gleichen Zeit durchgefhrt werden sollen.
// Die Hauptschleife wird mit 1/10 Sekunde durchlaufen, daher können
// Reaktionszeiten von 0,1 Sekunden erreicht werden.
//
// Die Front-Led blinkt unabh?gig von den Rckwärtsleds
// Gleichzeitg werden die Motoren gestartet, wenn der Zeitgeber der
// RückwertsLED's einen bestimmten Wert errreicht.
//
// 17.5.2007 ch
//
//*******************************************************************
#include "asuro.h"

int main(void)
{
    uint32_t nextzeit=100; // Zeitgebervariable mit 32 Bit
    uint16_t funktion1_zeit=0; // Zeitgebervariable fr 1.Funktion
    uint16_t funktion2_zeit=0; // Zeitgebervariable fr 2.Funktion
    uint16_t funktion3_zeit=20; // Zeitgebervariable fr 3.Funktion

    Init();

    while(1)
    {
//*******************************************************************
// Funktion1: Statusleuchtdiode blinken lassen
//*******************************************************************

        if (funktion1_zeit==0)
        {
            StatusLED(GREEN);
        }
        if (funktion1_zeit==10) // Nach 1 Sekunde auf Rot umschalten
        {
            StatusLED(RED);
        }
        funktion1_zeit++;
        if (funktion1_zeit>20) funktion1_zeit=0;

//*******************************************************************
// Funktion1: Ende
//*******************************************************************
//*******************************************************************
// Funktion2: Rckwärtige Leuchtdioden abwechselnd schalten
//*******************************************************************

        if (funktion2_zeit==0)
        {
            BackLED(OFF,ON);
        }
        if (funktion2_zeit==15) // Nach 1,5 Sekunde auf Rot umschalten
        {
            BackLED(ON,OFF);
        }
        if (funktion2_zeit==49)
        {
            funktion3_zeit=0; // hiermit wird die Funktion3 gestartet
        }
        funktion2_zeit++;
        if (funktion2_zeit>50) funktion2_zeit=0; // 3 Sekunden

//*******************************************************************
// Funktion2: Ende
//*******************************************************************
//*******************************************************************
// Funktion3: Motoren benutzen
// Diese Funktion wird gestartet, wenn die Variable
// function3_zeit auf 0 gesetzt wird
//*******************************************************************

        if (funktion3_zeit==0)
        {
            MotorSpeed(255,255);
            MotorDir(FWD,FWD); // Motoren vorwäts
        }
        if (funktion3_zeit==5) // 0,5 Sekunden
        {
            MotorSpeed(255,255);
            MotorDir(RWD,FWD);
        }
        if (funktion3_zeit==10) // 0,5 Sekunden
        {
            MotorSpeed(0,0);
        }

        if (funktion3_zeit<15) funktion3_zeit++; // Funktion beenden, wenn 15 erreicht

//*******************************************************************
// Funktion3: Ende
//*******************************************************************

        // Schleifendurchlauf auf 0,1 Sekunden synchronisieren
        while(Gettime()<nextzeit); // warten, bis Zielzeit erreicht
        nextzeit=Gettime()+100; // Zeitgeber auf 100 Millisekunden= 0,1 Sekunde stellen
    }
}

Weitere Code-Beispiele:


Messung der Motordrehzahl

Motordrehzahlmessung Hier soll versucht werden ein Modell für die Motordrehzahl in Abhängigkeit des Drehmomentes und der PWM-Einstellung der ASURO-Motoren zu erstellen.

Das Messprogramm und die Dokumentation befinden sich hier (Zip-Datei).

Theorie

Die Drehzahl der ASURO Motoren ist von verschiedenen Bedingungen abhängig:

  • PWM Einstellung
  • Drehmoment am Motor
  • Batteriespannung

Das Drehmoment am Motor hängt wiederum von verschiedenen Faktoren ab:

  • Drehmoment durch Reibung im Getriebe
  • Lastdrehmoment an den Rädern

Die Spannung am Motor ist von folgenden Faktoren abhängig:

  • Batteriespannung
  • Spannungsabfall an den Transistoren (möglicherweise vom Strom abhängig)
  • PWM-Einstellung
  • Spannungsabfall an den Batterien bei hohem Strom (hohes Drehmoment)

Für die Motorspannung eines Gleichstromnebenschlussmotors gilt (Taschenbuch der Elektrotechnik, Kories, Schmidt-Walter,6. erweiterte Auflage):

Ua = Ia · Ra + Uq

Ua: Ankerspannung
Ia: Ankerstrom
Ra: Ankerwiderstand
Uq: Gegeninduktion

Nach einigen Umformungen lässt sich die Gleichung für die Drehzahl gewinnen:

n: Drehzahl
Ua: Ankerspannung
INenn: Nennstrom
MNenn: Nenndrehmoment
B: magnetische Flussdichte
M: Drehmoment

PWM: Zahlenwert 0..255
UBat: Batteriespannung
UAbfall: Spannungsabfall an den Transistoren der Motorbrücke

Vernachlässigt man den Spannungsabfall der Motorbrücke, ergibt sich aus den Messungen folgende vereinfachte Gleichung:

n = 7.197 · UBat · PWM - kM

kM: Reibungsdrehmomentabhängige Konstante
PWM: Zahlenwert 0..255
UBat: Batteriespannung, ca. 5V

Untergrund kM
Freilauf 2300
Teppich 3300
ASURO mit Schnur festgebunden auf Teppich 4500

Messungen

Messungen

Motordrehzahlmessung - Die Messungen wurden auf verschiedenen Untergründen durchgeführt:

  • Teppichboden
  • Fliesenboden
  • PVC-Boden
  • Freilauf (Räder in der Luft)

Außerdem wurde der ASURO hinten mit einer Schnur festgebunden, um die Reibung der Räder auf den Untergründen zu testen (Messungsbezeichnung: "gebremst").

Zwischenzeitlich wurden die Batterien gewechselt,
UBat vorher: 5.03 Volt
UBat nachher: 5.24 Volt

Der ASURO ist mit AA-Batterien ausgestattet. Diese sind schwerer als die AAA-Batterien des Original-ASURO und erzeugen damit eine etwas erhöhte Reibung.

Ergebnis

Die Messergebnisse passen zum Modell der 2. Gleichung. Der Drehzahlverlauf auf den verschiedenen Untergründen Teppich, Fliesen, PVC zeigt kaum Unterschiede.
Die Änderung der Batteriespannung von 5.03V auf 5.24V wirkt sich beim Freilauf am stärksten aus.


Zufallszahlengenerator und sichere Tasterabfrage

  1. Ein Roboter kann den Eindruck der Intelligenz vermitteln, falls seine Handlungen nicht direkt vorhersehbar sind. Für diese Funktion wird ein Zufallsgenerator benötigt.
  2. Die Funktion Pollswitch in der beim ASURO mitgelieferten Software funktioniert nicht zuverlässig. Deshalb gibt es hier eine Funktion, die zuverlässig anzeigt, ob eine Taste gedrückt ist.
// uint8_t zufall()
//
// Liefert eine 8Bit Pseudozufallszahl zurück,
// die Zahlenfolge wiederholt sich spätestens nach 65535 Aufrufen
//
uint8_t zufall()
{
    static uint16_t startwert=0x0AA;

    uint16_t temp;
    uint8_t n;

    for(n=1;n<8;n++)
    {
        temp = startwert;
        startwert=startwert << 1;

        temp ^= startwert;
        if ( ( temp & 0x4000 ) == 0x4000 )
        {
            startwert |= 1;
        }
    }

    return (startwert);
}

//*******************************************************************
// uint8_t KeyPressed(void)
//
// zeigt, ob eine Taste des ASUROs gedrckt ist.
//
// Die Funktion nutzt nicht den AD-Wandler wie die Funktion Pollswitch,
// sondern fragt die Tasten direkt digital ab.
// Grund: Funktion Pollswitch arbeitet nicht zuverlaessig.
//
// 23.5.2007 ch
//
//*******************************************************************
uint8_t KeyPressed(void)
{
    uint8_t flag;

    DDRD &= ~SWITCHES; // High Impedance ( Input ) 
    DDRC |= (1<<PC4); // ADC-Switch-Pin to Output 
    PORTC |= (1<<PC4); // load capacitor / Pull up 
    Msleep(1);
    DDRC &= ~(1<<PC4); // Set ACD-Switch to Input 
    PORTC &= ~(1<<PC4); // High Impedance 

    Msleep(1);

    if(PIND&SWITCHES) flag=FALSE;
    else flag=TRUE;

    return flag;
}

Verschiedene weitere interessante ASURO-Themen