kommunikation zw. objekten

[originalflo]

hi folks,

ich arbeite momentan an einem projekt bei dem ich bidirektionale serielle kommunikation benötige.
ich benutze die java comm api 2.0 für windows.
die serielle kommunikation klappt gut, allerdings habe ich ein verständnis-/design- problem.

ich habe zum test eine klasse TestSerialConnection in mit einer Main methode, in der der Programmfaden abläuft, anglegt.

in der main methode instanziere ich erst die parameterklasse, setze comport parameter und instanziere anschließend die SerialConnection. die objekte sind da und ich kann z.B. was auf die Serielle rausschreiben.

Wenn daten reinkommen wirft die comm api einen event und die daten sind im SerialConnection objekt verfügbar. momentan gebe ich sie über system.out.println aus.

ich will allerdings mit den inputdaten in meinem TestSerialConnection objekt arbeiten und intelligent auf die inputdaten antworten!

und hier meine eigentliche frage:

ist es möglich dass das SerialConnection objekt ein event an die TestSerialConnection schickt und sagt: "ich hab daten für dich, mach damit was du willst!" oder geht es nur in dem ich das SerialConnection objekt immer vom TestSerialConnection objekt aus frage: "hast du daten?"

anbei der quellcode

danke für eure hilfe!
flo

public class TestSerialConnection {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SerialParameters serialProps = new SerialParameters();
		serialProps.setPortName("COM2");
		serialProps.setBaudRate(9600);
		serialProps.setDatabits(8);
		serialProps.setStopbits(1);
		
	    SerialConnection serialConn = new SerialConnection(serialProps);
	    try {
	    	serialConn.openConnection();	
	    } catch (SerialConnectionException e2) {
	    	System.out.println("Error open COM: " + serialProps.getPortName());
	    }
	    
	    serialConn.write("teststring\r\n");
	}
}

public class SerialConnection implements SerialPortEventListener, CommPortOwnershipListener {	
    private SerialParameters parameters;
    private OutputStream os;
    private InputStream is;

    private CommPortIdentifier portId;
    private SerialPort sPort;

    private boolean open;
    
    public SerialConnection(SerialParameters parameters) {
    	this.parameters = parameters;
    	this.open = false;
    }

   public void openConnection() throws SerialConnectionException {

	try {
	    portId = CommPortIdentifier.getPortIdentifier(parameters.getPortName());
	} catch (NoSuchPortException e) {
	    throw new SerialConnectionException(e.getMessage());
	}

	try {
	    sPort = (SerialPort)portId.open("SerialConnection", 30000);
	    System.out.println(portId.getName() + " opened for serial communication");
	} catch (PortInUseException e) {
	    throw new SerialConnectionException(e.getMessage());
	}

	try {
	    setConnectionParameters();
	} catch (SerialConnectionException e) {	
	    sPort.close();
	    throw e;
	}

	try {
	    os = sPort.getOutputStream();
	    is = sPort.getInputStream();
	} catch (IOException e) {
		// ignore this because often the serial port will be idle
	    //sPort.close();
	    //throw new SerialConnectionException("Error opening i/o streams");
	}

	// Add this object as an event listener for the serial port.
	try {
	    sPort.addEventListener(this);
	} catch (TooManyListenersException e) {
	    sPort.close();
	    throw new SerialConnectionException("too many listeners added");
	}

	// Set notifyOnDataAvailable to true to allow event driven input.
	sPort.notifyOnDataAvailable(true);

	// Set receive timeout to allow breaking out of polling loop during
	// input handling.
	try {
	    sPort.enableReceiveTimeout(30);
	} catch (UnsupportedCommOperationException e) {
	}

	// Add ownership listener to allow ownership event handling.
	portId.addPortOwnershipListener(this);

	this.open = true;
    }

    /**
    Sets the connection parameters to the setting in the parameters object.
    If set fails return the parameters object to origional settings and
    throw exception.
    */
    public void setConnectionParameters() throws SerialConnectionException {

		// Set connection parameters, if set fails return parameters object
		// to original state.
		try {
		    sPort.setSerialPortParams(parameters.getBaudRate(),
					      parameters.getDatabits(),
					      parameters.getStopbits(),
					      parameters.getParity());
		} catch (UnsupportedCommOperationException e) {
		    throw new SerialConnectionException("Unsupported parameter");
		}

		// Set flow control.
		try {
		    sPort.setFlowControlMode(parameters.getFlowControlIn() 
				           | parameters.getFlowControlOut());
		} catch (UnsupportedCommOperationException e) {
		    throw new SerialConnectionException("Unsupported flow control");
		}
    }

    /**
    Close the port and clean up associated elements.
    */
    public void closeConnection() {
    	// If port is alread closed just return.
    	if (!this.open) return;

		// Check to make sure sPort has reference to avoid a NPE.
		if (sPort != null) {
		    try {
			// close the i/o streams.
		    	os.close();
		    	is.close();
		    } catch (IOException e) {
		    	System.err.println(e);
		    }
	
		    // Close the port.
		    sPort.close();
	
		    // Remove the ownership listener.
		    portId.removePortOwnershipListener(this);
		    System.out.println(portId.getName() + " closed");
		}
		this.open = false;
    }

    /**
    Send a one second break signal.
    */
    public void sendBreak() {
	  sPort.sendBreak(1000);
    }

    /**
    Reports the open status of the port.
    @return true if port is open, false if port is closed.
    */
    public boolean isOpen() {
	  return this.open;
    }

	    /**
	    Handles SerialPortEvents. The two types of SerialPortEvents that this
	    program is registered to listen for are DATA_AVAILABLE and BI. During 
	    DATA_AVAILABLE the port buffer is read until it is drained, when no more
	    data is availble and 30ms has passed the method returns. When a BI
	    event occurs the words BREAK RECEIVED are written to the messageAreaIn.
	    */

    public void serialEvent(SerialPortEvent e) {
	 	// Create a StringBuffer and int to receive input data.
		StringBuffer inputBuffer = new StringBuffer();
		int newData = 0;
	
	    // Read data until -1 is returned. If \r is received substitute
	    // \n for correct newline handling.
		while (newData != -1) {
	    	try {
	    	    newData = is.read();
			    if (newData == -1) break;
			    
			    if ('\r' == (char)newData) {
			    	inputBuffer.append('\n');
			    } else {
			    	inputBuffer.append((char)newData);
			    }
	    	} catch (IOException ex) {
	    	    System.err.println(ex);
	    	    return;
	      	}
		}

		// print input
		System.out.print(inputBuffer);
    }
    
    public void ownershipChange(int type) {
		if (type == CommPortOwnershipListener.PORT_OWNERSHIP_REQUESTED) {
			System.out.print("An other application tries to use the selected com-port: ignore it ;-)\n");
		}
    }

    public void write (String data) {
    	try {
    		byte sendbytes[] = data.getBytes();
    		
    		os.write(sendbytes);
    	} catch (IOException e) {
    		System.err.println("OutputStream write error: " + e);
    	}
    }
}

 

[Lex]

Morgen,

du kannst ein Interface definieren, das von TestSerialConnection implementiert wird.
Mit TestSerialConnection registierst du dich dann an SerialConnection, da brauchste dann nur noch die Methode des Interfaces aufrufen, wenn neue Daten da sind.

MfG
Lex

 

[originalflo]

hi lex,

danke für den tipp...

bin schon über observer/observable und custom listeners gestolpert aber noch nicht so wirklich weitergekommen.....

um zu deinem tipp zurückzukommen:

ich verstehe nicht ganz was du mit: "Mit TestSerialConnection registierst du dich dann an SerialConnection" gemeint hast.


danke

ciao
flo

 

[moormaster]

Zum Beispiel:

Die SerialConnection merkt sich ein Objekt, welches ein Interface (z.B. SerialDataReceiver genannt) implementiert.

In diesem Interface definierst du für jedes Ereignis eine Methode, welche jeweils auch Parameter entgegen nehmen kann (z.B. empfangene Daten).

 public class SerialConnection
 {
  SerialDataReceiver receiver;

  ...

  public void setReceiver(SerialDataReceiver rcv)
  {
   this.receiver = rcv;
  }
 }

Per setReceiver Methode kann nun ein Objekt, welches SerialConnectionReceiver implementiert, dort angemeldet werden.

Tritt nun in SerialConnection ein Ereignis auf, könntest du jeweils überprüfen, ob ein Receiver gesetzt wurde (receiver != null) und wenn ja, rufst du einfach die entsprechende Methode für das jeweilge Ereignis auf und gibst die Daten so weiter.

[edit]
Das Ganze kann man auch noch weiter treiben, in dem man mehrere gleichzeitig registrierte Objekte zulässt. Dann würdest du eben statt eines SerialDataReceiver's einfach eine Collection aus SerialDataReveiver'n speichern.

Die Methode setReceiver würde dann natürlich entsprechend ersetzt durch add- bzw. remove- Methoden.
[/edit]

 

[Lex]

Die Methode zum übergeben der Daten ruft du auf wenn neue Daten da sind.
Mit moormasters Beispiel sähe das dann so aus:

/* Neue Daten empfangen */

receiver.postData(String data);

In deiner TestSerialConnection haste dann so was stehen:

public void postData(String data){
   System.out.println(data);
   /*oder was auch immer du noch machen willst */
}

MfG
Lex

 

[originalflo]

soweit einleuchtend und eine grosse hilfe - es funktioniert.

jetzt hab ich nur noch ne kleine verständnisfrage zum schluss....

weil's auf diese weise hats nicht geklappt hat:

serialConn.setReceiver(this); //Cannot use this in a static context

hab ich es folgendermaßen gelöst:

TestSerialConnection tsc = new TestSerialConnection(); // erster aufruf in main methode vno TestSerialConnection
serialConn.setReceiver(tsc);

ist meine variante auch der richtige weg oder ein workaround?

 

[Lex]

Die Registration von TestSerialConnection an SerialConnection würde ich im Construktor machen und in einer anderen Klassse dann die main-Mehtode implementieren, die dein Programm startet.

this funktioniert nicht da in der main-Methode kein Objekt der Klasse vorhanden ist auf das du referenzieren kannst.

MfG
Lex

 

[originalflo]

jetzt hats "klick" gemacht ;-)

danke für eure hilfe