# RFID Chip auslesen



## nderim (29. Mrz 2010)

hallo zusammen,

ich sollte für n projekt ein RFID-Gerät auslesen können. 
Mit der RXTX (welches die JavaComm API ersetzt hat) habe ich auch eine verbindung zu meinem serialport hergestellt. 
das ganze zeug hab ich aus einem beispiel-programm und funktioniert auch wunderbar. Die ID des Chips wird ausgelesen usw...
Das Problem jedoch ist, dass das Programm nur über eine gewisse Zeit hinweg die Ports ausliest (in dem fall 200 sec)
Mein Programm sollte aber von Beginn an den SerialPort überwachen können und auslesen sobald ein Chip über das Lesegerät gezogen wird. Hat jemand einen Vorschlag wie ich dieses Problem gelöst bekomme. 

habe den Java-Quelltext mal angefügt dass ihr euch n bild machen könnt was ich da fürn zeugs gemacht hab.
(Dieses Programm liest alle Ports aus... das heißt auch Tastatureingaben usw. jedoch zum testen reicht es vorest)

Danke schon im Voraus nderim. 



```
package reader;


import java.io.*;



public class Read implements Runnable{


    public static void main(String[] args) {
        Runnable runnable = new Read();
        new Thread(runnable).start();
        System.out.println("Main fertig");
        
    }
    
    InputStream inputStream;
    

    Integer sec = 200;
    public void run() {
        while(sec>0){
            System.out.println("Sekunden verbleiben: " + sec.toString() );
			sec--;
			try {
				Thread.sleep(1000);
			} catch(InterruptedException e) { }
        }
    }
    
    void datenVerfuegbar(){
        try{
            byte [] data  = new byte [150];
            int num;
            while(inputStream.available() > 0){
                num = inputStream.read(data,0,data.length);
                System.out.print("RFID: " + new String(data, 0,num));
            }
        }
        catch (IOException e) {
            System.out.println("Fehler beim Lesen");
            
        }
    }
    

}
```


----------



## kama (30. Mrz 2010)

Hi,



nderim hat gesagt.:


> Das Problem jedoch ist, dass das Programm nur über eine gewisse Zeit hinweg die Ports ausliest (in dem fall 200 sec)


Wenn man sich den Quelltext anschaut ist das nicht verwunderlich....
Da gibt es eine Methode "run", die eine While-Schleife enthält, die mit einer Variablen sec auf 200 gesetzt ist....Ich würde einfach mal versuchen hier einen anderen Wert reinzuschreiben....Weiterhin scheint mir das auch nicht vollständige Quelltext zu sein...


```
Integer sec = 200;
    public void run() {
        while(sec>0){
            System.out.println("Sekunden verbleiben: " + sec.toString() );
			sec--;
			try {
				Thread.sleep(1000);
			} catch(InterruptedException e) { }
        }
    }
    
}
```
[/QUOTE]

Gruß
Karl Heinz Marbaise


----------



## nderim (30. Mrz 2010)

ich weiß dass die schleife abhängig von der variable ist und ich könnte den wert auch auf 10000000 setzen. 
jedoch würde mein problem dadurch nicht gelöst werden, weil es immer noch begrenzt ist. 
ich habe ja um einen vorschlag gebeten der es nicht von dieser variable abhängig macht sondern die komplette (programm)laufzeit über ausliest. 
hier ist der vollständige quelltext des beispielprogrammes das ich im internet gefunden habe. 


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

public class V1_0 implements Runnable{

    public static void main(String[] args) {
                Runnable runnable = new V1_0();
		new Thread(runnable).start();
		System.out.println("main finished");
    }
    
	CommPortIdentifier serialPortId;
	Enumeration enumComm;
	SerialPort serialPort;
	//OutputStream outputStream;
	InputStream inputStream;
	Boolean serialPortGeoeffnet = false;

	int baudrate = 9600;
	int dataBits = SerialPort.DATABITS_8;
	int stopBits = SerialPort.STOPBITS_1;
	int parity = SerialPort.PARITY_NONE;
	String portName = "COM7";
	
	int secondsRuntime = 30;

	public V1_0()
	{
		System.out.println("Konstruktor: EinfachSenden");
	}
	
    public void run()
    {
        Integer secondsRemaining = secondsRuntime;
        if (oeffneSerialPort(portName) != true)
        	return;
        
		while (secondsRemaining > 0) {
			System.out.println("Sekunden verbleiben: " + secondsRemaining.toString() );
			secondsRemaining--;
			try {
				Thread.sleep(1000);
			} catch(InterruptedException e) { }
		}
		schliesseSerialPort();
    	
    }
    
	boolean oeffneSerialPort(String portName)
	{
		Boolean foundPort = false;
		if (serialPortGeoeffnet != false) {
			System.out.println("Serialport bereits geöffnet");
			return false;
		}
		System.out.println("Öffne Serialport");
		enumComm = CommPortIdentifier.getPortIdentifiers();
		while(enumComm.hasMoreElements()) {
			serialPortId = (CommPortIdentifier) enumComm.nextElement();
			if (portName.contentEquals(serialPortId.getName())) {
				foundPort = true;
				break;
			}
		}
		if (foundPort != true) {
			System.out.println("Serialport nicht gefunden: " + portName);
			return false;
		}
		try {
			serialPort = (SerialPort) serialPortId.open("Öffnen und Senden", 500);
		} catch (PortInUseException e) {
			System.out.println("Port belegt");
		}
/*
		try {
			outputStream = serialPort.getOutputStream();
		} catch (IOException e) {
			System.out.println("Keinen Zugriff auf OutputStream");
		}
*/
		try {
			inputStream = serialPort.getInputStream();
		} catch (IOException e) {
			System.out.println("Keinen Zugriff auf InputStream");
		}
		try {
			serialPort.addEventListener(new serialPortEventListener());
		} catch (TooManyListenersException e) {
			System.out.println("TooManyListenersException für Serialport");
		}
		serialPort.notifyOnDataAvailable(true);
		try {
			serialPort.setSerialPortParams(baudrate, dataBits, stopBits, parity);
		} catch(UnsupportedCommOperationException e) {
			System.out.println("Konnte Schnittstellen-Paramter nicht setzen");
		}
		
		serialPortGeoeffnet = true;
		return true;
	}

	void schliesseSerialPort()
	{
		if ( serialPortGeoeffnet == true) {
			System.out.println("Schließe Serialport");
			serialPort.close();
			serialPortGeoeffnet = false;
		} else {
			System.out.println("Serialport bereits geschlossen");
		}
	}
	
	void serialPortDatenVerfuegbar() {
		try {
			byte[] data = new byte[150];
			int num;
			while(inputStream.available() > 0) {
				num = inputStream.read(data, 0, data.length);
				System.out.println("Empfange: "+ new String(data, 0,num));
                        }
		} catch (IOException e) {
			System.out.println("Fehler beim Lesen empfangener Daten");
		}
                
	}

	class serialPortEventListener implements SerialPortEventListener {
		public void serialEvent(SerialPortEvent event) {
			System.out.println("serialPortEventlistener");
			switch (event.getEventType()) {
			case SerialPortEvent.DATA_AVAILABLE:
				serialPortDatenVerfuegbar();
				break;
			case SerialPortEvent.BI:
			case SerialPortEvent.CD:
			case SerialPortEvent.CTS:
			case SerialPortEvent.DSR:
			case SerialPortEvent.FE:
			case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
			case SerialPortEvent.PE:
			case SerialPortEvent.RI:
			default:
			}
		}
        }
        
        
}
```


----------



## kama (30. Mrz 2010)

Hi,

Dann musst Du die Schleife "Unendlich" machen...
	
	
	
	





```
while (true) do...
```
...aber hier muss dann eine Abbruch-Bedingung reingemacht werden (CTRL-C oder etwas ähnliches oder bestimmte Daten auf einem anderen Port )...habe ich in Java noch nicht gemacht...

Gruß
Karl Heinz Marbaise


----------



## HoaX (30. Mrz 2010)

Der größte Fehler dürfte erstmal sein, dass du eine Schleife mit InputStream#available() > 0 verwendest anstatt InputStream#read != -1.

Und wenn du dieses dann im Hauptthread ausführst, dann beendet sich das Programm auch erst wenn der Port geschlossen wird.

Was hat das Problem jetzt direkt mit RFID zu tun, so wie es der Titel andeutet?


----------

