Übergabe Stringzeilen von serieller Schnittstelle in andere Klasse

[welle87]

Hallo,

brauche dringend Unterstützung, meine Lektüre hilft mir nicht weiter. Wahrscheinlich kapier ich
es ehrlichgesagt auch nicht. :rtfm:
Ich habe eine Klasse zum zeilenweisen Text auslesen von einer seriellen Schnittstelle.
Nun ich möchte die Variable "merker" (Zeile74) in meine Startklasse (bzw. Mainklasse) übergeben.
Kann ich nicht dafür einfach ein Setter schreiben um den String dann
mit einem Getter in der Startklasse zu holen?

import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Enumeration;
import java.util.TooManyListenersException;
 
public class GPS implements SerialPortEventListener{
 
    private CommPortIdentifier serialPortId;
    private Enumeration enumComm;
    private SerialPort serialPort;
 
        private final int baudrate = 4800;
        private final String portName = "COM12";
        private BufferedReader br;
        String merker="";

 
    public GPS(){
 
            if(openSerialPort()){
                try{
                    serialPort.addEventListener(this);
                    serialPort.notifyOnDataAvailable(true);
                }catch(TooManyListenersException ex){}
            }
    }
 
        public static void main(String[] args){
            new GPS();
        }
 
    public boolean openSerialPort(){
            boolean foundPort = false;
            enumComm = CommPortIdentifier.getPortIdentifiers();
            while(enumComm.hasMoreElements()) {
                    serialPortId = (CommPortIdentifier) enumComm.nextElement();
                    if(portName.contentEquals(serialPortId.getName())) {
                            foundPort = true;
                            break;
                    }
            }
            if(!foundPort)
                    return false;
 
            try{
 
                serialPort = (SerialPort) serialPortId.open(this.getClass().getName(),2000);
                serialPort.setSerialPortParams(baudrate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
                br = new BufferedReader(new InputStreamReader(serialPort.getInputStream()));
            }catch(Exception e){
                return false;
            }
            return true;
    }
   
        public void serialEvent(SerialPortEvent event){
            switch (event.getEventType()){
            case SerialPortEvent.BI:
            case SerialPortEvent.OE:
            case SerialPortEvent.FE:
            case SerialPortEvent.PE:
            case SerialPortEvent.CD:
            case SerialPortEvent.CTS:
            case SerialPortEvent.DSR:
            case SerialPortEvent.RI:
            case SerialPortEvent.OUTPUT_BUFFER_EMPTY: break;
            case SerialPortEvent.DATA_AVAILABLE:
            	try{
                    merker = br.readLine();
                    }	
                    
                }catch(IOException ex){}
                break;
            }
        }
        
}

 

[SlaterB]

du kannst fast alles, mehr ist so allgemein gefragt gar nicht zu antworten,

besteht denn irgendein Problem mit getter oder setter?

 

[Ralph-Uwe]

Hallo,

erstmal vorweg:
Du versuchst offensichtlich Daten aus einer GPS-Empfänger auszulesen, damit habe ich mich noch nicht beschäftigt, daher kann ich dazu wenig sagen.
Aber ich denke, dass bei der Empfänger, eine Schnittstellenbeschreibung beigelegen hat.
Aus den sollte hervorgehen, auf welche Art die Daten über die Schnittstelle geschickt werden.

Bei dem Drucker den ich angebunden habe, erfolgt die Übertagung immer als Einzelinformation
oder als Block und das ganze Byteweise. (Du versuchst oben eine komplette Zeile zulesen, ich
glaube das geht nicht).
Eine Einzelinformation kann z.B. sein : ACK oder NAK (ACKnowledge oder NotAcKnowledge).
Blöcke werden mit SOH (Start of Header) eingeleitet, dann folgen die Nutzdaten (meist ein String)
und enden mit EOT (End of Transmission)

Ich habe den Empfang in eine eigene Methode ausgelagert:

case SerialPortEvent.DATA_AVAILABLE: empfang();

private final static char SOH = 1;
private final static char EOT = 4;
private final static char ACK = 6;
private final static char NAK = 21;
	
...

	private static void empfang(){
		try {
			 nak = false;
			 byte b = (byte) in.read();
			 if (b == ACK) {
				 daten = "ACK";
			 }
			 else if (b == NAK ) {
				 daten = "NAK";
				 nak = true;
			 }
			 else {
				 if ((b != SOH) && (b != EOT)){ 
					daten += (char)b;
				 }
			 }
			 if((b==ACK)||(b==NAK)||b==EOT) 
			 {
				 // empfangende Daten Auswerten
				 
				 daten = "";
			 }
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

In den Beispiel werden einzelne Bytes eingelesen und geprüft, ob sich um ein
Steuerzeichen handelt.
Handelt es sich bei den Daten um kein Steuerzeichen, werden aus den gelesenen Bytes ein String
zusammengesetzt, der nach dem nächsten Steuerzeichen ausgewertet werden kann.


Ich hoffe ich konnte helfen.

Gruß

 

[welle87]

Ja genau versuche ein GPS-Empfänger auszulesen und möchte immer den letzten Wert, d.h. den aktuellsten Wert mit einem anderen Wert vergleichen.