Erste Schritte mit dem Phidgets RFID-Reader

Erste Schritte mit dem Phidgets RFID-Reader

 

 

In diesem Tutorial werden wird Schritt für Schritt  eine erste Anwendung für den RFID Reader 1023 von Phidgets entwickeln. Als Programmiersprache wählen wir Java, da das Beispiel so auf alle Betriebssysteme übertragbar ist. Außerdem ist das Vorgehen so allgemein gültig, das ein Umstieg z. B. auf C# kein Problem sein sollte. Wie immer geht bei den Tutorials Verständnis vor Eleganz, deshalb wird auf besonders elegante aber schwer nachvollziehbare Programmiertechniken verzichtet.

 

Zunächst einmal müssen wir den Phidgets-Treiber installieren und außerdem benötigen wir noch die Java-Bibliotheken. All das können Sie für Ihr Betriebssystem hier herunterladen. 

 

Für die Erstellung des Beispielprogramms verwende ich die Entwicklungsumgebung NetBeans in der Version 7.2. Wenn Sie mit Eclipse oder in einer reinen Editor/Compiler-Konfiguration lässt sich das Vorgehen aber problemlos nachvollziehen. Falls trotzdem Fragen auftreten, helfen wir Ihnen ger per Mail weiter. 

 

Die grafische Oberfläche

 

Wir erstellen ein neues Projekt mit einer leeren Java Application:

 

new_project.png
 

 

Da wir später ein JForm hinzufügen werden, das unsere Main Class darstellt, verzichten wir auf die automatische Erstellung einer solchen und entfernen das eventuell vorhandene Häkchen vor dieser Option:

 

new_project_2.png
 

Der Eintrag im "projects" Fenster von NetBeans sollte nun so aussehen:

 

project_window.png

 

Damit NetBeans die Phidgets-Bibliotheken findet, fügen wir unserem Projekt mit einem Rechtsklick auf den Eintrag "Libraries" und dem Menüpunkt "Add JAR/Folder" die entsprechende Datei "phidgets21.jar" hinzu:

 

project_window2.png

 

Fehlt noch das Fenster für unsere Oberfläche, das wir über einen Rechtsklick auf den Projektnamen "RFID_test" -> "new" -> "JFrameForm" einfügen:

 

new_jframe.png

 

Für unsere erste Funktionalität benötigen wir 2 Button, ein JPanel und 2 Textfelder mit 2 Labeln. Im Properties-Fenster legen wir bei "Code" -> "Variable Name" die folgenden Variablennamen fest:

 

variable_name.png
 

1. Button: JBut_LED

2. Button: JBut_connect

1. Textfeld: JTF_devNr

2. Textfeld: JTF_Name

 

Das Fenster sollte danach in etwa wie folgt aussehen:

 

jframe1.png
 

Nun geht es endlich ans Programmieren. Um mit einem Phidget-Board arbeiten zu können, benötigen wir eine Instanz der jeweiligen Phidgets-Klasse, in unserem Fall also ein Objekt der Klasse "RFIDPhidget". Dieses Objekt ist, wie könnte es auch anders sein, in der Phidgets-Bibliothek definiert. Deshalb führen wir am Anfang unseres Programmcodes drei Import-Aufrufe durch:

 

import_1.png
 

Der erste Phidgets-Import stellt uns die speziellen Phidgets-Execptions zur Verfügung, die für die Fehlerbehandlung benötigt werden, mit dem 2. Import machen wir das RFIDPhidget-Objekt verfügbar. Den 3. Aufruf brauchen wir zwar für das erste Beispiel noch nicht, aber damit wir ihn später nicht vergessen, führen wir ihn jetzt schon durch. In den .event-Klassen werden wir die Ereignisse definiert, die der RFID-Reader auslösen kann und auf die wir ja auch reagieren wollen.

 

Um die Methoden zu erzeugen, die für das Anklicken der Button "LED" bzw. "Verbinden" notwendig sind, können wir in NetBeans einfach einen Doppelklick auf das jeweilige Element durchführen und der Methodenrumpf wird erzeugt. Der Source-Code unseres Startfensters sieht nun folgendermaßen aus:

 

jframe_2.png


Wir deklarieren eine Veriable "bLED", die wir zum Ein- und Ausschalten der LED benötigen und die schon erwähnte RFIDPhidget-Instanz. Im Konstruktor werden lediglich die Variablen für die Fensterdarstellung definiert, deshalb blende ich den Code aus, ebenso wie die Main-Funktion, die unser Programm startet. Für uns sind nur die beiden Funktionen in Zeile 116 (jBut_connectActionPerformed) und 131 (jBut_LEDActionPerformed) von Interesse:

 

connect_1.png

 

Wenn der Button "Verbinden" (jBut_connect) angeklickt wird, erfolgt zuerst die Instanziierung des RFIDPhidget-Objekts "rfid_reader". Mit openAny() wird der Reader nun geöffnet. Es gibt hier zahlreiche weitere Möglichkeiten z. B. können Sie mit open(int serialID) einen bestimmten Reader unter Angabe seiner Seriennummer öffnen. Die open-Methoden arbeiten asynchron, aus diesem Grund müssen wir warten bis sich der RFID-Reader auch tatsächlich angemeldet hat. Dies tun wir mit der Methode "waitForAttachment", der wir als Parameter den timeout-Wert 1000 (Millisekunden) übergeben. Wenn alles fehlerfrei abgelaufen ist, lassen sich über die beiden Methoden "getDeviceType()" und "getDeviceName()" Produkttyp und Name ermitteln und diese werden dann den jeweiligen Textboxen zugeordnet. Bliebe noch zu erwähnen, dass wir alles in einen try-catch-Block setzen, um auf mögliche Fehler reagieren zu können. Die Reaktionen auf die Exceptions sind hier lediglich symbolhaft durchgeführt. 

 

Nun zur zweiten Methode, die beim Klicken auf den Button "LED" ausgeführt wird:

 

LED_1.png
 

Eigentlich selbsterklärend: Beim Drücken der LED wird in Abhängigkeit vom Zustand der Variable "bLED" die Funktion "setLEDOn" aufgerufen und als Parameter "true" (LED ein) bzw. "false" (LED aus) übergeben. Auch hier fangen wir wieder über eine try-catch-Block ab.

 

Wenn Sie nun das Programm starten und auf den Button "Verbinden" drücken, meldet sich der RFID-Reader mit Typbezeichnung und Namen und wenn Sie den Button LED betätigen, sollten Sie die Reaktion auf dem Board auch sehen können:

 

RFID_test_1.png
 

Das Programm lässt allerdings noch sehr zu wünschen übrig. Auf der einen Seite ist die Verbindungsaufnahme über den Button etwas hinderlich, ein automatischer Verbindungsaufbau wäre schon sehr vorteilhaft, auf der anderen Seite kann der RFID-Reader das Wichtigste ja noch nicht: RFID Tags erkennen.

 

Aber wie am Anfang versprochen, wollen wir uns der Thematik ja schrittweise nähern und das werden wir auch tun.

 

Schlüssel der Kommunikation: Events und Listener

 

In Java läuft die Kommunikation zwischen Objekten über Ereignisse (Events), die ausgelöst werden und über Listener, die auf diese Ereignisse "lauschen". Die Erfassung eines RFID Tags (Schlüsselanhänger, Scheckkarte, Klebepad etc.) erfolgt über die entsprechende Hardware, den RFID Reader, dieser löst über den Treiber ein Ereignis aus und übermittelt die Identifikationsdaten. Ähnliches passiert, wenn das RFID Tag den Empfangsbereich des RFID Readers wieder verlässt. 

 

Wie dies genau geschieht, müssen wir gar nicht wissen, denn Phidgets stellt uns sowohl einen "TagGainListener" (RFID Tag erscheint im Empfangsbereich) als auch einen "TagLossListener" (RFID Tag verlässt den Empfangsbereich) zur Verfügung. Bei diesen Objekten handelt es sich um Interfaces mit jeweils nur einer Methode "tagGained()" bzw. "tagLost()". Da ein Interface lediglich die Methodendeklarationen liefert, müssen wir uns zwei Klassen erstellen, und dort die Methoden definieren. Das tun wir zunächst für das TagGain-Event:

 

Fügen Sie dem Projekt eine neue Java-Klasse hinzu:

 

new_class_1.png

 

Wir nennen die neue Klasse "RFID_TGL" (TGL für TagGainListener) und ändern den automatisch erzeugten Code wie folgt ab:

 

RFID_TGL_1.png
 

Mit den beiden ersten Import-Anweisungen binden wir die notwendigen Bibliotheken ein und da wir eine leere Klasse erzeugt haben und in dieser ein "JTextField" benötigen, ist auch der dritte Import notwendig. Über die "implements"-Anweisung leiten wir die Klasse "RFID_TGL" vom Interface "TagGainListener" ab. 

 

Wenn wir später in unserem Programm eine Instanz von RFID_TGL erzeugen, dann übergeben wir ihr im Konstruktor als Parameter den Verweis auf ein Textfeld. Jedes Mal, wenn nun ein Tag erkannt wird, führt dies zum Aufruf der Methode "tagGained" und in dieser Methode tun wir nichts anderes als den Identifikationscode des Tags, den uns tagGainEvent.getValue() liefert, in das übergebene Textfeld zu schreiben. Dazu ändern wir das Layout unseres Hauptfensters wie folgt ab:

 

jframe_3.png
 

Wir ergänzen das Ganze um ein weiteres Label und ein weiteres Textfeld, dem wir den Variablennamen "jTF_id" geben.

 

Im Code nehmen wir folgende Ergänzungen vor:

 

1. Wir brauchen eine Objektvariable vom Typ RFID_TGL:

 

myTGL1.png

 

2. In der Methode, die beim Anklicken des "Verbinden"-Buttons ausgeführt wird, ergänzen wir die folgenden drei Codezeilen (140 bis 142):

 

new_connect.png
 

Mit diesen Zeilen wird die Instanz "myTGL" vom Typ RFID_TGL erzeugt und dem RFID-Objekt (rfid_reader) hinzugefügt. Anschließend wird noch die Antenne des RFID Readers aktiviert.

 

Wenn wir nun das Programm aufrufen, den Button "Verbinden" drücken und uns mit einem Tag dem Reader nähern, erfolgt die Ausgabe des Tag-Codes im Textfeld:

 

read_tag.png

 

Unser Reader erkennt nun, wenn sich ein Tag nähert, aber er kann noch nicht feststellen, wann es sich wieder entfernt. Dazu benötigen wir den "TagLossListener". Der Ablauf ist praktisch identisch wie beim "TagGainListener", also hier nur noch einmal in Zusammenfassung:

 

1. Wir fügen eine neue Klasse hinzu und nennen diese RFID_TLL.

2. Wir füllen diesen Klasse mit dem folgenden Code:

 

RFID_TLL1.png
 

Im Gegensatz zum RFID_TGL wird hier das übergebene Textfeld bei jedem Auftreten eines tagLost-Events gelöscht.

 

3. Im Hauptprogramm fügen wir die Instanz myTLL vom Typ RFID_TLL hinzu, erzeugen in der connect-Button-Methode eine Instanz davon und fügen sie dem rfid_reader-Objekt hinzu (Zeilen 12, 138, 139):

 

jframe_4.png
 

Nun reagiert das Programm auch auf das Ereignis "tagLost". 

 

Was uns jetzt noch stört, ist der connect-Button, denn der Reader soll sich beim Verbinden anmelden und beim Entfernen auch wieder abmelden. Dafür brauchen wir wiederum 2 Listener, die uns Phidgets mit "AttachListener" und "DetachListener" wiederum als Interfaces zur Verfügung stellt. Mit unserem bisherigen Wissen über die Funktionsweise der gerade behandelten Listener ist die Umsetzung kein Problem mehr.

 

Da wir die LED auch nur für den Test der ersten Verbindungsaufnahme benötigt haben, entfernen wir auch diesen Button.

 

Die gesamte Funktionalität geht nun vom Reader aus und deshalb müssen wir den Initialisierungs-Code, den wir ja in der Methode für den connect-Button untergebracht haben, verschieben. Gut geeignet ist dazu der Konstruktor selbst. Das so geänderte Programm folgt also dem Ablauf: 

 

1. Im Konstruktor werden alle Listener deklariert, erzeugt und zugewiesen (RFID_AL als AttachListener und RFID_DL als DetachListener).

2. Beim Verbinden des Readers wird im Objekt RFID_AL ein "AttachEvent" ausgelöst und füllt die Textfelder. 

3. Nähert sich ein RFID-Tag wird im Objekt RFID_TGL ein "TagGainEvent" ausgelöst und übergibt den ID-Code des Tags.

4. Beim Entfernen des Tags löscht das TagLossEvent den Code wieder aus dem Textfeld.

5. Beim Entfernen des Readers werden alle Textfelder gelöscht.

 

Bliebe noch ein Problem: "Wo aktivieren wir die Antenne?". Im Konstruktor geht es nicht, weil der Reader ja eventuell noch gar nicht angeschlossen ist, bzw. beim Entfernen und erneuten Anschließen den Konstruktor kein weiteres Mal auslöst. Der richtige Ort dafür ist der AttachListener, denn der wird ja jedes Mal ausgeführt, wenn ein Reader mit dem USB-Kabel verbunden wird. 

 

Wir haben es jetzt also mit insgesamt fünf Klassen zu tun:

1. RFID_TGL

2. RFID_TLL

3. RFID_AL

4. RFID_DL

5. RFID_Reader

 

Da sich die beiden ersten nicht mehr geändert haben, folgen im Anschluss die drei Klassen 3 bis 5 in der Endversion:

 

RFID_AL:

 

RFID_AL.png
 

 

Das Prinzip ist das gleiche wie bei den bisher behandelten Listener. Neu ist nur die erste Zeile im "attached"-Event. Hier wird mit "ae.getSource()" der Reader ermittelt, der das Ereignis ausgelöst hat, um dann auf seine Funktionen zugreifen zu können. 

 

RFID_DL:

 

RFID_DL.png
 

Der Ablauf ist derselbe, wie in RFID_AL, nur diesmal werden die Texte wieder gelöscht. 

 

Und schließlich das Hauptprogramm mit der vereinfachten Oberfläche:

 

RFID_Reader_fin.png
 

RFID_Reader_fin_Code.png
 

Auch hier finden wir nichts mehr, das uns nicht bekannt sein dürfte. Nach dem Erzeugen der rfid_reader-Instanz werden alle fünf Listener hinzugefügt und der Reader am Schluss des Konstruktors geöffnet. 

Wichtig: Ein sehr häufiger Fehler entsteht durch den falschen Zeitpunkt für den Aufruf der open()-Methode. Überlegen wir kurz, was passieren würde, wenn wir diesen Aufruf direkt nach dem Erzeugen der Instanz platzieren. In diesem Fall öffnen wir den Reader und danach erzeugen wir die Listener. Schließen wir den Reader nach dem Aufruf des Programms an, läuft alles wunschgemäß. Anders sieht es allerdings aus, wenn wir das Programm bei angeschlossenem Reader starten. In diesem Fall würde die open()-Methode zwar ein attached-Event auslösen, es gibt aber noch keinen Listener, der darauf reagieren kann. Aus diesem Grund muss die open()-Methode nach dem Erzeugen aller Listener aufgerufen werden. 

 

Sagen Sie uns Ihre Meinung zu diesem Tutorial, damit wir noch besser auf Ihre Wünsche eingehen können. Das Feedback-Formular finden Sie hier. 

 

Für weitere Informationen und Bestellungen einfach auf nachfolgenden Link klicken:

Phidgets RFID Reader

Phidgets RFID Reader Starter-Kit

 

Falls Sie Fragen zum Thema haben, wenden Sie sich einfach an uns.

Wir helfen Ihnen gern weiter!

 

Ihr Team von Böcker Systemelektronik

Hinweis: Unser Tutorialangebot wird in unregelmäßigen Abständen erweitert. Wenn Sie sofort über eine Neuerscheinung informiert werden möchten, tragen Sie sich bitte hier in unsere Benachrichtigungsliste "Tutorials" ein. Sie können diesen unverbindlichen Service jederzeit in Ihrem Kundenkonto oder per E-Mail wieder abbestellen.  

 

Copyright © Böcker Systemelektronik