# RS232 mit Java



## Icevarta (28. Februar 2008)

Hallo,
ich programmiere im Moment einen Roboter und muss dazu die RS232 Schnittstelle über Java ansprechen. Ich hab die RXTX Erweiterung runtergeladen und mir diesen Code genommen und und etwas umgeschrieben:


```
import java.util.*;
import gnu.io.*; 
import java.io.*;
import java.nio.*;
public class Kommunikator implements Runnable, SerialPortEventListener 
{
    //needed for both read and write
    static Enumeration portList;
    static CommPortIdentifier portID;
    //needed for write
    static SerialPort serialPort;
    static OutputStream outputStream;
    //needed for read
    private InputStream inputStream;
    private Thread readThread;
    private String readedString;
    private Schlange hatSchlange;
    
    
    /** Creates a new instance of transmitter */
    public Kommunikator(Schlange pSchlange) 
    {
       hatSchlange = pSchlange; 
    }
    
    
    
    public boolean send(String sendstring){
        //send Code
        boolean isSended = false;
            try{
                
            portID = CommPortIdentifier.getPortIdentifier("COM1");
            serialPort = (SerialPort)portID.open("PortOpener",10);
            //set the parity
            //sets the Serialport Parameters
            serialPort.setSerialPortParams(9600,SerialPort.DATABITS_8,SerialPort.STOPBITS_1,SerialPort.PARITY_NONE);
            outputStream=serialPort.getOutputStream();
            outputStream.write(sendstring.getBytes());
            outputStream.flush();
            serialPort.close();
            isSended = true;
        }catch(NoSuchPortException e){
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }catch(UnsupportedCommOperationException e){
            e.printStackTrace();
        }catch(PortInUseException e){
            e.printStackTrace();
        }
        return isSended;
    }
    
    public void receive(){
        try{
            portID= CommPortIdentifier.getPortIdentifier("COM1");
            serialPort = (SerialPort)portID.open("PortOpener", 10);
            serialPort.setSerialPortParams(
                9600,SerialPort.DATABITS_8,
                SerialPort.STOPBITS_1,SerialPort.PARITY_NONE);
            inputStream = serialPort.getInputStream();
            serialPort.setFlowControlMode(3);
            serialPort.addEventListener(this);
            serialPort.notifyOnDataAvailable(true);
            readThread = new Thread(this);
            readThread.start();
        }catch(NoSuchPortException e){
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }catch(UnsupportedCommOperationException e){
            e.printStackTrace();
        }catch(PortInUseException e){
            e.printStackTrace();
        }catch(TooManyListenersException e){
            e.printStackTrace();
        }
        
    }
    
    public void closeSerialPort(){
        serialPort.close();
    }
    
    public void run() {
       try{
            Thread.sleep(2000);
       }catch(InterruptedException e){
            e.printStackTrace();
        }
    }
    
    public void serialEvent(gnu.io.SerialPortEvent serialPortEvent) {
        switch (serialPortEvent.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:
                byte[] readBuffer=new byte[2048];
                try{
                    while (inputStream.available()>0){
                        int numBytes=inputStream.read(readBuffer);
                    }
                    readedString=new String(readBuffer);
                    hatSchlange.haengeAn(readedString);
                }catch(IOException e){
                    System.out.print(e);
                    break;
                }
        }
    }
}
```

Leider versteh ich nicht alles davon. Ich möchte nur das die Daten die ganze Zeit empfangen werden und an die Schlange angehängt werden und ich manchmal zwischendurch Daten senden kann. Funktioniert das so und welche Methode muss ich aus meinem Hauptklasse dazu Aufrufen? Die erste Methode "send" ist ja noch verständlich, danach wird es schon schwieriger. Was bedeutet z.B. "readThread = new Thread(this); readThread.start();" ? Wird damit public void run() aufgerufen? Aber diese Methode wartet doch nur und wozu braucht man public void serialEvent(gnu.io.SerialPortEvent serialPortEven ? 
Antworten wären schön vielen Dank im Voraus.


----------



## TheJadix (28. Februar 2008)

Hallo,

die Klasse Kommunikator implementiert das SerialPortEventListener interface.

Das Registrieren als Listener am Port mit serialPort.addEventListener(this); sorgt dafür, dass
wenn etwas am Port passiert, das die Methode public void serialEvent(gnu.io.SerialPortEvent serialPortEvent)
aufgerufen wird.

Dort wird mit der case-Struktur herausgefiltert ob es sich um eine DataAvailable-Event
handelt und entsprechend darauf reagiert.

Der Thread ist in der tat sehr seltsam, nach dem initialisieren und dem start wartet dieser einmalig
2 Sekunden um dann seine Arbeit einzustellen ! Very strange !

Wo hast denn den Code her ?

Gruß JAdix


----------



## Icevarta (28. Februar 2008)

Hallo danke für deine Antworten.
Also müsste  ich die Methode Recieve in einem Thread in einer Schleife aufrufen, und es werden dann alle Daten in die Liste gehängt. Zum Senden der Daten müsste ich das empfangen aber unterbrechen oder?
Den Code hab ich aus diesem Forum, der Link dazu versteckt sich oben hinter "diesen".


----------



## TheJadix (29. Februar 2008)

Hallo,

ich würde den Code noch etwas verändern, da es für mich keinen Sinn
macht jedesmal die Streams abzubauen und den Port freizugeben.

Deshalb einmal initialisieren, x-mal senden / empfangen, einmal schließen !


```
import java.util.*;
import gnu.io.*; 
import java.io.*;

public class Kommunikator implements SerialPortEventListener 
{
    //needed for both read and write
    static Enumeration portList;
    static CommPortIdentifier portID;
    //needed for write
    static SerialPort serialPort;
    static OutputStream outputStream;
    //needed for read
    private InputStream inputStream;
    private Thread readThread;
    private String readedString;
    private Schlange hatSchlange;
    
    private boolean initialized = false;
    
    
    /** Creates a new instance of transmitter */
    public Kommunikator(Schlange pSchlange) 
    {
       hatSchlange = pSchlange; 
    }
    
    public boolean init(String port) {
    	
    	if (initialized) return true; // if allready 
    	
        try {
     	     portID = CommPortIdentifier.getPortIdentifier(port);
	     serialPort = (SerialPort)portID.open("PortOpener",10);
      serialPort.setSerialPortParams(9600,SerialPort.DATABITS_8,SerialPort.STOPBITS_1,SerialPort.PARITY_NONE);
            serialPort.setFlowControlMode(3);
            serialPort.addEventListener(this);
            serialPort.notifyOnDataAvailable(true);
            outputStream=serialPort.getOutputStream();
            inputStream = serialPort.getInputStream();
			initialized = true;
        } catch (NoSuchPortException e) {
			e.printStackTrace();
		} catch(PortInUseException e){
            e.printStackTrace();
        } catch(UnsupportedCommOperationException e){
            e.printStackTrace();
        } catch(TooManyListenersException e){
            e.printStackTrace();
        } catch(IOException e){
            e.printStackTrace();
        }
        
        return initialized;
    }
    
    public boolean isInitialized() {
    	return initialized;
    }
    
    public boolean send(String sendstring){

    	if (!initialized) return false;
    	
        boolean isSended = false;
        try{
            outputStream.write(sendstring.getBytes());
            isSended = true;
        }catch(IOException e){
            e.printStackTrace();
        }
        return isSended;
    }
    
     
    public void close(){
 
    	try {
			inputStream.close();
        	outputStream.close();
	        serialPort.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
    }
    
    public void serialEvent(gnu.io.SerialPortEvent serialPortEvent) {
        switch (serialPortEvent.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:
                byte[] readBuffer=new byte[2048];
                try{
                    while (inputStream.available()>0){
                        int numBytes=inputStream.read(readBuffer);
                    }
                    readedString=new String(readBuffer);
                    hatSchlange.haengeAn(readedString);
                }catch(IOException e){
                    System.out.print(e);
                }
        }
    }
}
```

Ungetestet und ohne gewähr ! 

Gruß JAdix


----------

