ASURO mit Java steuern

Zitat:

---

Allgemein solltest du dir die Objektorientierung mal etwas näher anschauen -- einfach alle Methoden static zu machen entspricht eigentlich nicht dem Gedanken der objektorientierten Programmierung

---

Jaja, ich weis schon: mit langer Erfahrung in der nicht-objektorientierten Programmierung hat man etwas Probleme mit der Denkweise.

Aber um es zu lernen habe ich jetzt eine Zwischenklasse "AsuroKommandos" eingeführt. Damit wird das Main Programm ziemlich gut lesbar:

int n;

AsuroKommandos asuro=new AsuroKommandos();

asuro.schnittstelleOeffnen("COM10");

for(n=0;n<10;n++) asuro.verbindungOk() ; // Prüfen und zeigen, ob Verbindung
for(n=0;n<10;n++) asuro.liniensensorLinks(); // Liniensensor anzeigen

asuro.schnittstelleSchliessen();

Allerdings: Ich frage mich, warum ich überhaupt die AsuroKommandos als Objekt benötige. Die Kommanos gibt es ja nur einmal. Ich könnte 100 AsuroKommandos-Objekte erzeugen, aber ich kann nur eines gebrauchen.

Hier die zugehörige AsuroKommandos Klasse:

Code:

---

/**
 *  Kommandos zur Kommunikation mit einem ASURO
 * 
 *  Programm zur einfachen Kommunikation des PC mit dem ASURO
 *        über die Infrarot Schnittstelle
 *
 *        Kommandos:
 *       
 *        t: Testkommando, Asuro sendet xASUROy zurück
 *        l: Abfrage des linken Liniensensors, Asuro sendet xZAHLy zurück
 *
 *
 * @author robo.fr ( Nickname ) christoph(at)roboterclub-freiburg.de
 *
 * Feb.2008
 *
 */

public class AsuroKommandos
{
        private static boolean debug = true;
        private Rs232 irSchnittstelle=new Rs232();
       
        public void AsuroKommandos()
        {
                irSchnittstelle.ports_available();       
        }
        public void schnittstelleOeffnen(String port)
        {
                irSchnittstelle.open(port) ;
        }
        public void schnittstelleSchliessen()
        {
                irSchnittstelle.close() ;
                if(debug) System.out.println("beendet");
        }
        // Nachbau von Msleep aus der AsuroLibV261 für Java
        // ( leider müssen Methoden in Java klein geschrieben werden )
        public void msleep(int millisekunden)
        {
                long stop,current;
               
                java.util.Date zeit=new java.util.Date();
                stop=zeit.getTime()+millisekunden;
               
                current=0;
                while(current<stop)
                {
                        java.util.Date zeit2=new java.util.Date();
                        current=zeit2.getTime();
                }
        }
       
        /**
        * public boolean verbindungOk()
        *
        * sende das Testzeichen 't' zum ASURO und warte auf die
        * korrekte Antwort: "xASUROy"
        * falls der ASURO richtig antwortet, return true
        *
        * @author robo.fr ( Nickname ) christoph(at)roboterclub-freiburg.de
        *
        * Feb.2008
        *
        */

        public boolean verbindungOk()
        {
                irSchnittstelle.read(); // Empfangsbuffer leermachen durch lesen
                irSchnittstelle.write((byte)'t'); // Testkommando senden
                msleep(200);
                String text=irSchnittstelle.read();
                if(debug) System.out.println(text);               
                if(text.contains("x") && text.contains("y"))
                {
                        //if((text.indexOf("ASURO")-text.indexOf('x'))==1)
                        if(text.indexOf("xASUROy")!=-1)
                        {
                                if(debug) System.out.println("Test OK");
                                return true; // Test OK, der ASURO antwortet korrekt
                        }
                }

                if(debug) System.out.println("No ASURO");
                return false;       
        }
        /**
        *        public double liniensensorLinks(
        *
        *        Wert des linken Liniensensors lesen
        *
        * @author robo.fr ( Nickname ) christoph(at)roboterclub-freiburg.de
        *
        * Feb.2008
        *
        */
        public double liniensensorLinks()
        {
                irSchnittstelle.read(); // Empfangsbuffer leermachen durch lesen
                irSchnittstelle.write((byte)'l'); // Liniensensor Lesekommando
                msleep(500);
                String text=irSchnittstelle.read();
                if(debug) System.out.println(text);               
                double x;
                if(text.contains("x") && text.contains("y"))
                {
                        String s=text.substring(text.indexOf("x")+1,text.indexOf("y"));

                        x=Double.parseDouble(s);
                               
                        if(debug) System.out.println(x);
                        return x; // Test OK, der ASURO antwortet korrekt
                }

                if(debug) System.out.println("No Number");
                x=Double.NaN; // return Not a Number
                return x;       
        }
}

---

Warum? Datenkapselung, Lesbarkeit, Wiederverwendbarkeit, ...

In deinem Mini-Programm kommt dir das vielleicht noch nicht besonders sinnvoll vor - aber wenn du die ASURO Kommunikation mal in einem größeren Umfeld benötigst, kannst du einfach deine Klasse (die dann evtl. X Methoden und eine Menge von Member-Variablen hat) nehmen und benutzen, völlig unabhängig vom Rest der Anwendung.

Abgesehen davon könntest du so 2 Asuros gleichzeitig an 2 Schnittstellen bedienen.

Was mir auf die Schnelle noch aufgefallen ist:

- der Konstruktor der Klasse darf keinen Rückgabewert (also auch kein "void") definieren

- im Kopf der for-Schleifen kann man direkt eine Zählvariable anlegen, also einfach

for (int i=0; i<10; i++) ... ;

- du musst mit dem Datentyp "byte" aufpassen. Der ist in Java immer "signed"! Darum wird in der Java API fast immer, wenn es um "richtige" Bytes geht, ein "int" verwendet.

Zitat:

---

Was mir auf die Schnelle noch aufgefallen ist:

- der Konstruktor der Klasse darf keinen Rückgabewert (also auch kein "void") definieren

---

Vielen Dank für den Hinweis. Der war sehr nützlich, in meiner neuen Klasse habe ich nämlich den selben Fehler gemacht und ich konnte ihn nicht finden, bis ich den Post gelesen habe.

Zitat:

---

Warum? Datenkapselung, Lesbarkeit, Wiederverwendbarkeit, ...
...
Abgesehen davon könntest du so 2 Asuros gleichzeitig an 2 Schnittstellen bedienen.

---

Ist schon klar. Mir scheint die Objektorientierung eher für Graphik-Anwendungen nützlich. Deshalb habe ich versucht, eine Klasse zu schreiben, welche die Messwerte der IR-Schnittstelle als Graph darstellt. Im ersten Schritt sind hier die Kommunikationsfunktionen noch nicht eingebunden und es werden einfach nur Zufallswerte dargestellt.

Leider flackert das Fenster immer, wenn ein neuer Punkt gezeichnet wird. Die Kurve wurde nur aktualisiert, wenn ich das Fenster mit "visible" ein-und ausschalte. Da müsste es eine andere Methode geben. Leider habe ich keine gefunden.

Code:

---

import java.awt.Graphics;
import java.awt.Point;
import javax.swing.*;
import java.lang.Math;
import ch.Timer;
/**
 * Graph Klasse zur Darstellung von Kurvenverläufen
 *
 * @author robo.fr ( Nickname ) christoph(at)roboterclub-freiburg.de
 *
 * Feb.2008
 *
 */
public class Graph extends JPanel // ein Graph ist ein Fensterobjekt
{
        public String fenstername;
        private Point fensterDimension; // Point ist hier kein Punkt, sondern Länge und Breite
        private Point[] daten;
        private final int datenLaenge;
        private int datenIndex;
       
        private Graph()
        {
                fenstername="Graph";
                fensterDimension=new Point();
                fensterDimension.x=320;
                fensterDimension.y=240;
                datenLaenge=64;
                daten=new Point[datenLaenge]; // Punkte der Kurve
                datenIndex=0;
        }
        /**
        * Wert aus dem Datenarray graphisch darstellen
        *
        * @author robo.fr ( Nickname ) christoph(at)roboterclub-freiburg.de
        *
        * Feb.2008
        *
        */

        @Override
        protected void paintComponent(Graphics g)
        {
                super.paintComponent(g); // original paintComponent aus JPanel aufrufen
                if(datenIndex>0)
                {
                        for(int n=0;n<(datenIndex-1);n++)
                        {
                                int k=fensterDimension.y/2;
                                g.drawLine(daten[n].x,k-daten[n].y,daten[n+1].x,k-daten[n+1].y);
                        }
                }
        }
        /**
        *
        *        Fügt dem Graph einen neuen Wert hinzu
        *  der interne Index wird automatisch erhöht
        *
        * @author robo.fr ( Nickname ) christoph(at)roboterclub-freiburg.de
        *
        * Feb.2008
        *
        */
        public void addWert(int wert)
        {
                Point a=new Point();
                a.x=datenIndex;
                a.y=wert;
                if(datenIndex<(datenLaenge)) // noch Platz im Array vorhanden
                {
                        daten[datenIndex]=a;
                        datenIndex++;
                }
                else // Array voll, Kurve verschieben
                {
                        // Arraywerte nach unten verschieben
                        for(int n=0;n<(datenLaenge-2);n++)
                        {
                                daten[n]=daten[n+1];
                        }
                        daten[datenLaenge-1]=a;
                }
        }
        /**
        * Demo: langsam neue Datenpunkte zum Graph hinzufügen und darstellen
        */
        public static void main(String[] args)
        {
                JFrame graph1=new JFrame("Graph");
                graph1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
               
                Graph g=new Graph();

                graph1.setSize(g.fensterDimension.x,g.fensterDimension.y);
                graph1.add( g);

                Timer t=new Timer();

                for(int n=0;n<100;n++)
                {
                        g.addWert((int)(Math.random()*100));

                        graph1.setVisible(true);
                        t.msleep(200);
                        graph1.setVisible(false);                       
                }
                System.out.println("Ende");
        }
}

---

Du musst repaint() aufrufen!

Und nein, die OO Programmierung ist nicht nur für GUI gut, sondern für alles - der Code wird einfach viel besser benutzbar und lesbarer usw. Es dauert einfach ein wenig, sich umzustellen um sic alles als Objekte und deren Beziehungen, Vererbungen etc. vorzustellen. UML hilft ;-)

Zitat:

---

Du musst repaint() aufrufen!

---

Vielen Dank, damit sieht das ganze schon viel besser aus =P~

Jetzt versuche ich gerade, eine graphische Benutzeroberfläche mit 3 Buttons für das ferngesteuerte Einschalten der LED's des ASURO zu programmieren.

Code:

---

import java.awt.Image;
import java.awt.FlowLayout;
import java.awt.BorderLayout;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class AsuroControl
{

        public static void main( String[] args )
        {
         
        JFrame fenster = new JFrame("Java ASURO CONTROL");
    fenster.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
 
    //fenster.setLayout( new FlowLayout() );
    fenster.setLayout( new BorderLayout(5,5) );
   
    fenster.setSize(320,120);
   
    JPanel schalterPanel=new JPanel();
    schalterPanel.setLayout(new FlowLayout());
    JPanel bilder=new JPanel();
   
    Icon bild = new ImageIcon(AsuroControl.class.getResource( "/images/asuro.jpg" ) );
 
   
    final JButton button1 = new JButton("BACK_LED_R");
    final JButton button2 = new JButton( "BACK_LED_L" );
    final JButton button3 = new JButton( "FRONT_LED" );
    final JButton button4 = new JButton( bild );

    schalterPanel.add( button1 );
    schalterPanel.add( button2 );
    schalterPanel.add( button3 );
    bilder.add( button4);
   
    fenster.add(schalterPanel,BorderLayout.PAGE_END);
    fenster.add(bilder,BorderLayout.PAGE_START);
    /*
        AsuroKommandos asuro=new AsuroKommandos();
        asuro.schnittstelleOeffnen("COM10");
        asuro.verbindungOk() ; // prüfen und zeigen, ob Verbindung
        asuro.schnittstelleSchliessen();
    */ 
    fenster.pack();
    fenster.setVisible( true );
  }
}

---

Das ganze sieht dann wie das Bild aus. Jetzt stellt sich mir die Frage, wie ich die Tastedrücke mit der AsuroKommandos-Klasse verbinde.

So bspw. :

Code:

---


//myAsuro ist das AsuroKommandos-Objekt
// - muss aber (bspw. als Member-Variable o.ä.) außerhalb
//der main()-Funktion bekannt sein.

button1.addActionListener(new ActionListener(){
                        public void actionPerformed(ActionEvent e){
                                myAsuro.xyz();
                               
                        }
                });

---

"Schöner" wird der Code übrigens, wenn man in main() nur bspw. das Anwendungsfenster erzeugt und das Fenster selbst weiß, wie es aussieht etc. Dazu lässt du AsuroControl von JFrame erben und die ganzen Initialisierungen des Fensters (erstellen der Buttons usw.) landen im Konstruktor der Klasse. In main() erstellst du nur noch ein Objekt von AsuroControl.

Wenn AsuroControl dann ein AsuroKommando-Objekt kennen muss, kannst du das der Klasse am besten direkt im Konstruktor mit übergeben.

Hallo trapperjohn,

leider habe ich Deinen Post jetzt ein wenig zu spät gelesen und mich inzwischenzeit ziemlich abgemüht, das Programm zum laufen zu kriegen ( sagt man eigentlich noch Programm zum laufen kriegen, oder eher Klasse zum laufen kriegen?).

Jetzt muss ich erst mal Deine Version genauer unter die Lupe nehmen.

Hier ist meine "Wurstelversion", die ich nicht besonders lesbar finde. Ich habe mich aber an das Buch "Java is auch ein Insel" gehalten. Da gab's eine ähnlich Konstruktion.

Code:

---

/**
 *  Einache Java Klasse mit graphischer Oberflaeche
 *  zur Steuerung eines ASURO-Roboters ueber die IR-Schnittstelle
 * 
 *  Funktionen: Leds ein und ausschalten
 * 
 * @author robo.fr ( Nickname ) christoph(at)roboterclub-freiburg.de
 *
 * March.2008
 *
 */
import java.awt.Image;
import java.awt.FlowLayout;
import java.awt.BorderLayout;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class AsuroControl extends JFrame implements WindowListener
{
          private AsuroKommandos asuro=null;
          private static boolean debug=true;
               
        // Hier müssen alle Methoden zur Behandlung der Fenster-Events folgen
          public void windowClosing( WindowEvent event )
          {
                  asuro.schnittstelleSchliessen();
                  System.exit( 0 );
          }
          public void windowClosed( WindowEvent event ) { /*Empty*/ }
          public void windowDeiconified( WindowEvent event ) { /*Empty*/ }
          public void windowIconified( WindowEvent event ) { /*Empty*/ }
          public void windowActivated( WindowEvent event ) { /*Empty*/ }
          public void windowDeactivated( WindowEvent event ) { /*Empty*/ }
          public void windowOpened( WindowEvent event ) { /*Empty*/ }
       
          // das ganze Programm befindet sich im Konstruktor
          AsuroControl()
          {
            setSize( 400, 400 );
            addWindowListener( this );

           
            asuro=new AsuroKommandos();
                JPanel ledSchalterPanel=new JPanel();
            JPanel bilder=new JPanel();

            Action testAction = new AbstractAction( )
            {
                public void actionPerformed( ActionEvent e )
                {
                        if(debug&asuro.verbindungOk()) System.out.println("passt");
                }
            };
           
            Action FrontLedAction = new AbstractAction( "FrontLed" )
            {
                public void actionPerformed( ActionEvent e )
                {
                        if(debug) System.out.println("FrontLed ein");
                        asuro.ledsOff(); // Led's aus
                        asuro.frontLed() ; // frontLed einschalten
                }
            };

            Action BackLedLAction = new AbstractAction( "BackL" )
            {
                public void actionPerformed( ActionEvent e )
                {
                        if(debug) System.out.println("linke BackLed ein");
                        asuro.ledsOff(); // Led's aus
                        asuro.backLedL() ; // backLedL einschalten
                }
            };

            Action BackLedRAction = new AbstractAction( "BackR" )
            {
                public void actionPerformed( ActionEvent e )
                {
                        if(debug) System.out.println("rechte BackLed ein");
                        asuro.ledsOff(); // Led's aus
                        asuro.backLedR() ; //  backLedr einschalten
                }
            };

                  JButton buttonFrontLed = new JButton(FrontLedAction);
                  JButton buttonBackLedL = new JButton(BackLedLAction);
                  JButton buttonBackLedR = new JButton(BackLedRAction);
               
                  ledSchalterPanel.add(buttonBackLedL);
                  ledSchalterPanel.add(buttonFrontLed);
                  ledSchalterPanel.add(buttonBackLedR);
                             
            Icon bild = new ImageIcon(AsuroControl.class.getResource( "/images/asuro.jpg" ) );
            JButton buttonAsuroBild = new JButton( bild );
            buttonAsuroBild.addActionListener(testAction);
            bilder.add( buttonAsuroBild);
           
            this.setLayout( new BorderLayout(5,5) );
           
                  this.add(ledSchalterPanel,BorderLayout.PAGE_END);
                  this.add(bilder,BorderLayout.PAGE_START);
                 
                  this.setTitle("Java ASURO control");
            setVisible( true );     
           
                asuro.schnittstelleOeffnen("COM10");
          }

          public static void main( String[] args )
          {
            new AsuroControl();
          }
         
}
/***************************************************************************
 * 
 *  (c) 2008 robo.fr (Nickname) , christoph(at)roboterclub-freiburg.de
 *
 ***************************************************************************
 *  This program is free software; you can redistribute it and/or modify  *
 *  it under the terms of the GNU General Public License as published by  *
 *  the Free Software Foundation version 2 of the License,                *
 *  If you extend the program please maintain the list of authors.        *
 *  ( if there is no real name, the nick name has to be mentioned )
 *  If you want to use this software for commercial purposes and you      *
 *  don't want to make it open source, please contact the authors for    *
 *  licensing.                                                            *
 ***************************************************************************/

---

Morgen werde ich Deine Version mal genauer unter die Lupe nehmen und sehen, wie ich mein Konstrukt verbessern kann.

Gruß,
robo

Das sieht ja schon ungefähr so aus, wie ich vorgeschlagen hatte. Nur die ganzen ActionListener würde ich noch so wie in meinem Beispiel als anonyme Klasse erstellen - also keine extra Variablen dafür sondern direkt im Aufruf von addActionListener() zusammenbauen.

Zitat:

---

Zitat von robo.fr

den ASURO will ich mit einem kleine Java-Programm steuern.

---

ne dumme Frage:
warum mit Java? Was kann Java, was C nicht kann?
Gruss
M.

Plattformunabhängigkeit, Klassen und der Zugriff auf eine große Klassenbibliothek würde ich schon als großen Vorteil sehen ...

Mir fällt persönlich kein Grund ein, warum man heutzutage noch auf einem PC in Standard-C programmieren sollte, wenn C++, Java o.ä. zur Auswahl stehen. Aber das ist wieder eine typische Grundsatzdiskussion, die hier nix zu suchen hat ;-)