pi4j und die serielle Schnittstelle

Arno Nym · Jan 27th 2014

Hallo Leute,

nachdem ihr bei meinem letzten Problemchen schon so gut geholfen habt, hier mal mein aktuelles Problemchen.

Ich möchte gern Daten vom µC per RS232 in den Pi einlesen. Dafür benutzt ich die "pi4j" Lib. Das Beispiel was dabei ist funktioniert auch super. Daten senden und empfangen geht damit problemlos. Aber ich möchte die Daten ja nicht per Konsole ausgeben, sondern im Programm weiter verarbeiten.

Also habe ich das Beispiel einfach etwas angepasst.
Original sah es so aus:

Code

// create an instance of the serial communications class
        final Serial serial = SerialFactory.createInstance();


        // create and register the serial data listener
        serial.addListener(new SerialDataListener() {
            @Override
            public void dataReceived(SerialDataEvent event) {
                // print out the data received to the console
                System.out.print(event.getData() + System.getProperty("line.separator"));
            }            
        });

Display More

Dann habe ich für die Konsole eine globale Variable eingefügt

Code

public String readData;

und den entpsrechenden Code in der Schleife:

Code

readData = (event.getData() + System.getProperty("line.separator"));

ersetzt.

Das funktioniert scheinbar irgendwie, nur leider wird kein Event mehr ausgelöst der in die Variable was reinschreibt. Es wird also nur "null" zurück gegeben. Ausserdem wird kein Datum mehr gesendet. Also wird die komplette Funktion der Seriellen Schnittstelle irgendwie blockiert.

Nach etwas Suchen bin ich im Forum von pi4j auf ein Beitrag gestoßen, wo jemand das selbe Problem hat. Beitrag im pi4j Forum
Dort wurde empfohlen, als "quick and dirty" Methode, der Klasse einfach eine public Variable anzufügen. Was ich ja bereits gemacht habe. Da wird auch darauf hingewisen, dass im Fall von lange laufenden Schleifen, es zu Empfangsprobleme auf der Schnittstelle kommen kann. Ich habe allerdings nur eine Schleife die sekündlich durchläuft und das serial.readData einfach nur aufruft.

Edit: Oder liegt das daran, dass ich den Sekundentakt mittels Thread.sleep(1000); erzeuge? Weil das heißt ja, dass er einfach mal 1000ms nichts tun soll. Mist, ich glaube den Fehler habe ich gerade selber gefunden :s.

Als super Lösung wird darauf hingewisen, dass man einen eigen Thread für den Empfang bauen soll und den dann syncronisieren muss. Und hier bin ich total überfragt, weil ich das noch nie gemacht habe. Ich habe mal ein Thread Beispiel gebastelt wo zwei Threads einfach Variablen hoch zählen. Aber das mit dem Syncronisieren raff ich irgendwie noch nicht.

Aber mal als Frage, hat jemand ein Beispiel, wie man das Problem lösen kann und würde das mal posten. Dann habsch mal ein funktionierendes Beispiel wie es geht

Danke,
Arno

Tell · Jan 27th 2014

[font="Tahoma, Verdana, Arial, sans-serif"]> Edit: Oder liegt das daran, dass ich den Sekundentakt mittels Thread.sleep(1000); erzeuge?[/font]
[font="Tahoma, Verdana, Arial, sans-serif"]Genau das ist das Problem. Der Main-Thread holt keine Events mehr aus der Event-Queue.[/font]

[font="Tahoma, Verdana, Arial, sans-serif"]> Als super Lösung wird darauf hingewisen, dass man einen eigen Thread für den Empfang bauen[/font]
[font="Tahoma, Verdana, Arial, sans-serif"]> soll und den dann syncronisieren muss.[/font]
[font="Tahoma, Verdana, Arial, sans-serif"]Stimmt, ABER Threads sind nichts fuer Anfaenger !![/font]

[font="Tahoma, Verdana, Arial, sans-serif"]Die sind zwar in Java leicht zu machen, aber die Synchronisation braucht einiges Hintergrundwissen.[/font]
[font="Tahoma, Verdana, Arial, sans-serif"]Threads NUR WENN NOETIG ![/font]

[font="Tahoma, Verdana, Arial, sans-serif"](Ich weiss, gleich geht ein Storm los, dass fast alle von Euch die Threads voll im Griff[/font]
[font="Tahoma, Verdana, Arial, sans-serif"]haben und nur absolut Thread-sicheren Code schreiben. Vergesst es: ich weiss was[/font]
[font="Tahoma, Verdana, Arial, sans-serif"]ich schreibe)[/font]

[font="Tahoma, Verdana, Arial, sans-serif"]Ein Timer ist viel einfacher in den Griff zu kriegen. Wenn ich mich richtig erinnere, gibt[/font]
[font="Tahoma, Verdana, Arial, sans-serif"]es in Java gleich mehrere Timer. Eine Suche nach Java und Timer sollte einiges zu[/font]
[font="Tahoma, Verdana, Arial, sans-serif"]Tage foerdern.[/font]

guenter · Jan 27th 2014

Versuch es mal wie folgt:
Eine globale Variable ist sicher OK, ich würde einen Vector nehmen (der synchronisiert seine Zugriffe):
Vector datenVecotor = new Vecotor();

Die Zuweisung dann wie folgt:
String readData = event.getData();
if (readData != null) datenVector.add(readData);

Ich unterstelle mal, dass getData() auch einen String liefert. Und hoffe, dass der Vector eine add-Methode hat (schreibe das nur mal so ohne auszuprobieren).

Idealerweise hast du einen Thread, der auf genau so ein Ereignis wartet. Alternativ eine Endlosschleife, etwa so:

while(true)
{
Thread.sleep(1000); // Eine Sekunde warten, Try/Catch unterschlage ich mal)
if (datenVector.isEmpty() == false)
{
// hier über den Vector iterieren, die Werte lesen und aus dem Vector löschen
// und irgend etwas damit machen
}
}

Hoffe, der Ansatz hilft etwas.

Arno Nym · Jan 29th 2014

Hallo Leute,

habe jetzt eine Version zusammen gebastelt, die erstmal funktioniert
Danke auch an die PN die ich mit einem Beispielprogramm bekommen habe. Das und viel lesen in Büchern hats am Ende doch gebracht

Ich weiß jetzt nicht ob das hier die beste Lösung ist, aber ich stell den trotzdem mal rein. Vielleicht haben auch noch andere Leute ein Problem damit
Für Verbesserungsvorschläge bin ich natürlich dankbar

Mein "Machwerk": }

Java

import java.util.Timer;
import java.util.TimerTask;


import java.util.Date;


import com.pi4j.io.serial.Serial;
import com.pi4j.io.serial.SerialDataEvent;
import com.pi4j.io.serial.SerialDataListener;
import com.pi4j.io.serial.SerialFactory;
import com.pi4j.io.serial.SerialPortException;


public class main_class {
    
    //-----------------------------------------------------------------------
    // Init glob. Variablen
    //-----------------------------------------------------------------------    
    public static String readData;
    
    
    //-----------------------------------------------------------------------
    // Main
    //-----------------------------------------------------------------------
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        System.out.println("Starte Programm ...");
        
        SerialInit("/dev/ttyAMA0", 38400); // Init serielle Schnittstelle
        
        Timer timer = new Timer();
        
        //Starte TimerTask direkt (0) und aller 250ms widerholen
        timer.schedule( new Blubb(), 0, 250);


    }
    
    
    //-----------------------------------------------------------------------
    // Init der seriellen Schnittstelle
    //-----------------------------------------------------------------------
    public static void SerialInit(String device, int baudrate) {
        
        System.out.println("Init Serialport");    
        
        // create an instance of the serial communications class
        final Serial serial = SerialFactory.createInstance();


        // create and register the serial data listener
        serial.addListener(new SerialDataListener() {
            @Override
            public void dataReceived(SerialDataEvent event) {
                // print out the data received to the console
                getSerialData(event);
            }            
        });
                
        try {
            // open the default serial port provided on the GPIO header
            serial.open(device, baudrate);
           }
        catch(IllegalStateException ex){
            ex.printStackTrace();                    
        }
    }


    
    //-----------------------------------------------------------------------
    // Methode wird bem Empfang eines Zeichens aus der Serielle aufgerufen
    //-----------------------------------------------------------------------
    public static void getSerialData(SerialDataEvent event) {
        readData = event.getData();
        //System.out.printf("Empfang:" + readData + System.getProperty("line.separator"));
    }
    


    //-----------------------------------------------------------------------
    // sendet Daten an die serielle Schnittstelle - noch nicht getestet
    //-----------------------------------------------------------------------
    public static void sendData(String DataToSend) {
        // write a formatted string to the serial transmit buffer
     //   serial.write("CURRENT TIME: %s", new Date().toString());


        // write a individual bytes to the serial transmit buffer
     //   serial.write((byte) 13);
     //   serial.write((byte) 10);       
    }


    
    //-----------------------------------------------------------------------
    // beendet die serielle Schnittstelle - noch nicht getestet
    //-----------------------------------------------------------------------
    public static void closeSerial() {
           System.out.println("closeSerial fehlt noch"); 
           com.pi4j.wiringpi.Serial.serialClose(0);
    }
    
}

Display More

und hier der TimerTask:

Java

import java.util.TimerTask;


public class Blubb extends TimerTask {


    @Override
    public void run() {
        // TODO Auto-generated method stub
        //System.out.println("Timer!");
        System.out.println("Var: " + main_class.readData);
    }
}

Display More

Auf alle Fälle kann ich jetzt, aktuell zum testen, aller 250ms einen String per RS232 empfangen und auf der Konsole anzeigen.

:thumbs1::D
Arno

Tell · Jan 29th 2014

Verbesserungsvorschlag: die Daten gleich in getSerialData verarbeiten,
dann gibt es keine Zeitverzoegerung.

Die run()-Methode der Klasse Blubb kann dann leer bleiben und das Timer-
Intervall beliebig gross. (je groesser desto besser)

guenter · Jan 30th 2014

Schön dass es funktioniert und für deine Aufgabenstellung vielleicht auch OK.

In einem Java-Forum würde das nicht durchgehen - ich versuche mal zu erklären warum:
- der Timer wird ständig auf Verdacht aufgerufen, das kostet sehr viele Resourcen
- Wenn die Routine, die den String auswertet zu lange dauert, wirst du Probleme bekommen
- es können auch Eingaben verloren gehen

Besser ist es, das ganze in einem Thread zu machen. Der wird schlafen geschickt und geweckt, bis ein Ereignis kommt. Das handelt er ab (String-Verarbeitung) und legt sich wieder schlafen. Noch was gutes: auch eine Programm-Stop-Routine kann implementiert werden. Die stopt den Thread und schließt sauber die serielle Schnittstelle. Mal als Denkansatz zu sehen - falls eines der Probleme akut werden sollte.

Und noch was: die Verarbeitung in der getSerialData-Methode zu machen, ist weniger gut - vor allem, wenn die Verarbeitung etwas Zeit in Anspruch nimmt.

Arno Nym · Jan 30th 2014

Hallo Leute,

Quote

Und noch was: die Verarbeitung in der getSerialData-Methode zu machen, ist weniger gut - vor allem, wenn die Verarbeitung etwas Zeit in Anspruch nimmt.

Ja, so kenn ich es auch von den Mikroprozessoren und SPSen. Im Interrupt (Event) Case wird nur ein Flag gesetzt oder ein überschaubarer Teil Programm ausgeführt. Ebend wegen der Ausführungszeit.

Bin gerade dabei mich mit Threads und syncronisierung zu beschäfftigen. Habe da ein Befehl "Lock" gefunden. Damit geht es scheinbar bei einfachen Programmen mit dem syncronisieren.

Mit dem Timer auf verdacht geht so bei mir. Ich weiß wann ich Daten sende. Damit geht das. Aber wie ist das wenn ich im Thread.sleep bin und es kommt ein Event. Wacht der dann auf oder verpasse ich das das Ereigniss?

Quote

In einem Java-Forum würde das nicht durchgehen

Bin für jeden Hinweis dankbar .
Bin gerade beim einarbeiten in Java und die ganze Sache mit Multithreading, syncronisieren und so ist mir zur Zeit noch nicht ganz geheuer :D. Aber es kommt langsam Licht ins Dunkel :thumbs1:

Werde mein Lösung mal posten wenn ich es mal fertig habe

Arno

Tell · Jan 30th 2014

Warnung: Threads machen einige Dinge einfacher, aber man zahlt mit vielen Komplikationen !

Threads starten ist einfach, einen Thread sauber zu terminieren dagegen nicht ...

Und die ganzen Synchronisationsprobleme muss man erst begreifen und
den Code GANZ GANZ sauber implementieren.

Und kein Lock nehmen sondern einen synchronized-Block. Das
ist deutlich einfacher, weil Java das Lock verwaltet.

[hr]
Uebrigens gibt es in diesem Code schon ZWEI Threads, der Timer
laeft naemlich in einem eigenen Thread.

Halt, stop, es sind DREI. Der Garbage-Collector ist ja auch noch da.

(Oder vielleicht sogar noch ein vierter, je nachdem wie die Seriell-Klasse
implementiert ist)
[hr]
Einen Callback kann man nicht mit einem Interrupt-Handler vergleichen,
da das ganze von der Virtuellen Maschine verwaltet wird, hat man viel
mehr Zeit.

Arno Nym · Jan 31st 2014

Hallo Leute,

hatte ja geschrieben das man it "Lock" recht easy syncronisieren kann, habe das aber mit C# verwechselt:s.

Gerade im Netz gefunden.
http://tutorials.csharp-online…ock_and_Java_synchronized

Ich lese gerade mal bei Galileo openbooks über Java und Threads. Aktuell qualmt der Schädel

cu Arno

guenter · Jan 31st 2014

Quote from Arno Nym

Ich lese gerade mal bei Galileo openbooks über Java und Threads. Aktuell qualmt der Schädel

Ist gar nicht so schlimm wie es sich zunächst anfühlt - und im Zeitalter vom Multi-Core fast schon ein muss ...

Users Viewing This Thread