ASURO-Roboter

Inhalt:

• Java ASURO Control
• Der sprechende ASURO
• ASURO-Kamerasteuerung
• Multitasking für den ASURO-Roboter
• Messung der Motordrehzahl der ASURO-Motoren unter verschiedenen Bedingungen
• Zufallszahlengenerator und sichere Tasterabfrage
• Verschiedene weitere interessante ASURO-Themen

Java ASURO Control - ASURO mit Java fernsteuern

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

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:

• Java von Sun ( JRE ) Sun-Homepage
• RS232-Treiber RXTX
• Das Programm

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.



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.



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

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:

• Visual C++ 2005
• OpenCV

Download: Source code (Zip-Datei)

---

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 ).

Code:

  //*******************************************************************
//
// 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:

• Bewegungen wirken natürlicher, wenn sie nicht ruckartig sind: asuro_tasking_smooth.c
• Multitaskingbeispiel mit Starten und Stoppen verschiedener Tasks - In diesem Beispiel wird gezeigt, wie man verschiedene Tasks starten und stoppen kann.
  Der ASURO fährt mit pendelnden Bewegungen durch die Gegend. Trifft der ASURO auf ein Hindernis und werden die Schalter gedrückt, wird der Pendelttask gestoppt und der Rückfahrtask gestartet
• Echtes Multitasking-Betriebsystem für den ASURO

---

Messung der Motordrehzahl der ASURO-Motoren unter verschiedenen Bedingungen

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 [1]:

U_a = I_a * R_a + U_q

U_a: Ankerspannung
I_a: Ankerstrom
R_a: Ankerwiderstand
U_q: Gegeninduktion

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

n: Drehzahl
U_a: Ankerspannung
I_Nenn: Nennstrom
M_Nenn: Nenndrehmoment
B: magn. Flussdichte
M: Drehmoment


PWM: Zahlenwert 0..255
U_Bat: Batteriespannung
U_Abfall: 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 * U_Bat * PWM - k_M

k_M: Reibungsdrehmomentabhängige Konstante
PWM: 0..255
U_Bat: Batteriespannung, ca. 5V

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

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,
U_Bat vorher: 5.03 V
U_Bat 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.

[1] Taschenbuch der Elektrotechnik, Kories, Schmidt-Walter,6. erweiterte Auflage

---

Zufallszahlengenerator und sichere Tasterabfrage

Ein Roboter kann den Eindruck der Intelligenz vermitteln, falls seine Handlungen nicht direkt vorhersehbar sind. Für diese Funktion wird ein Zufallsgenerator benötigt.
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.

Code:

//
// 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

• Beispielprogramme für den ASURO (von Arrex Henk): ASURO-Programme
  Hier findet sich auch ein Programm zum Fernsteuern des ASURO mit einer Infrarot-Fernsteuerung (RC5 kompatibel).
• Film: mehrere ASUROs per Infrarot gesteuert
• Regelungstechnik: wie man das Gleichlaufproblem der ASUOR-Motoren in den Griff bekommen kann
• Ausführliche Anleitungen zum ASURO von einfachen Programmbeispielen bis zum PID-Regler
• Das ASURO-Handbuch, welches mitgeliefert wird (Download ganz oben)
• Typischer Projektablauf eines ASURO Zusammenbaus - Hier baut eine Fachhochschule einen ASURO-Roboter zusammen. Und wie man sieht: aller Anfang ist schwer!

---

Λ Seitenanfang

---