Hallo,
ich habe mir so eine nette kleine GPS-Maus gekauft, die mit dem mitgelieferten Treiber über einen virtuellen Com-Port ausgelesen werden kann. Das klappt auch soweit ganz gut mit folgendem Quelltext:
Das dumme ist, in der Konstellation werden recht immense 50% Systemlast beansprucht. Das auf einem flotten DualCore.
Ich habe auch die folgende Methode ausprobiert:
Mit oder ohne kurzem schlafenlagen, es kommt aufs gleiche hinaus. Ledeglich lange Wartezeiten schaffen Abhilfe, dann wird aber der Empfang verzerrt bzw. setzt in bestimmten Intervallen aus, das ist also keine gute Lösung.
Wie kann ich also das ganze effizient auslesen ?
Gruß tobi
ich habe mir so eine nette kleine GPS-Maus gekauft, die mit dem mitgelieferten Treiber über einen virtuellen Com-Port ausgelesen werden kann. Das klappt auch soweit ganz gut mit folgendem Quelltext:
Java:
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 = "COM7";
private BufferedReader br;
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{
System.out.println(br.readLine());
}catch(IOException ex){}
break;
}
}
}Das dumme ist, in der Konstellation werden recht immense 50% Systemlast beansprucht. Das auf einem flotten DualCore.
Ich habe auch die folgende Methode ausprobiert:
Java:
String line;
while((line = br.readLine()) != null){
System.out.println(line);
}Mit oder ohne kurzem schlafenlagen, es kommt aufs gleiche hinaus. Ledeglich lange Wartezeiten schaffen Abhilfe, dann wird aber der Empfang verzerrt bzw. setzt in bestimmten Intervallen aus, das ist also keine gute Lösung.
Wie kann ich also das ganze effizient auslesen ?
Gruß tobi
