Datenübertragung von einem Mikrokontroller-System zu...
78
HOCHSCHULE EMDEN-LEER Datenübertragung von einem Mikrokontroller-System zu einem Personal-Computer und anschließender Bereitstellung der Daten im Internet Verfasser: Karsten Dürschinger Betreuer: Erstprüfer: Prof. Dr.-Ing. Dirk Rabe Zweitprüfer: Dipl.-Ing. Harald Buß 14.10.2013
-
Upload
truongthuy -
Category
Documents
-
view
213 -
download
0
Transcript of Datenübertragung von einem Mikrokontroller-System zu...
HOCHSCHULE EMDEN-LEER
Datenübertragung von einem Mikrokontroller-System zu einem Personal-Computer
und anschließender Bereitstellung der Daten im
Internet
Verfasser:
Karsten Dürschinger
Betreuer:
Erstprüfer: Prof. Dr.-Ing. Dirk Rabe
Zweitprüfer: Dipl.-Ing. Harald Buß
14.10.2013
II
Inhaltsverzeichnis
1 Erklärungen ..................................................................................................................................... 5
1.1 Nutzungsrechte ....................................................................................................................... 5
1.2 Eidesstattliche Erklärung ......................................................................................................... 5
2 Einleitung ......................................................................................................................................... 6
2.1 Danksagung ............................................................................................................................. 6
2.2 Dokumentenstruktur ............................................................................................................... 6
3 Ausgangslage und Aufgabenstellung............................................................................................... 7
3.1 Ausgangslage ........................................................................................................................... 8
3.1.1 RFID-Tag-Lesegerät .......................................................................................................... 8
3.1.2 Datensender (Master) ................................................................................................... 11
3.1.3 Datenempfänger (Slave) ................................................................................................ 11
3.1.4 Applikation (Data-Receiver) .......................................................................................... 12
3.1.5 Applikation Teilnehmerliste .......................................................................................... 13
3.1.6 ZigBee ............................................................................................................................ 13
3.2 Aufgabenstellung ................................................................................................................... 14
4 Implementierung der ZigBee-Kommunikation .............................................................................. 15
4.1 Arbeitsumgebung .................................................................................................................. 15
4.2 Master ................................................................................................................................... 15
4.2.1 Anpassungen der ZigBee-Software ............................................................................... 15
4.2.2 Integration ZigBee in die Master-Software ................................................................... 17
4.3 Slave ...................................................................................................................................... 21
4.3.1 Anpassungen der ZigBee-Software ............................................................................... 22
4.3.2 Anpassung der Slave-Software ...................................................................................... 22
4.4 Inbetriebnahme des Gesamtsystems .................................................................................... 24
5 Erweiterung der USB-Kommunikation .......................................................................................... 25
5.1 Aufbau der USB-Kommunikation .......................................................................................... 25
5.2 Slave-Software ....................................................................................................................... 26
6 Entwicklung der PC-Applikation .................................................................................................... 28
6.1 Die Entwicklungsumgebung .................................................................................................. 28
6.2 Einführung in die WPF-Programmierung .............................................................................. 29
6.2.1 Trennung der Benutzeroberfläche vom Hintergrundcode ............................................ 29
III
6.2.2 Data-Bindings ................................................................................................................ 30
6.2.3 Frame und Pages ........................................................................................................... 31
6.3 Funktionen des Data-Receivers ............................................................................................. 32
6.4 Aufbau der Applikation ......................................................................................................... 33
6.5 Anpassungen der Funktionen des Data-Receivers 1.0 .......................................................... 34
6.5.1 Auslagerung der USB-Kommunikation .......................................................................... 35
6.5.2 Modifikation der Ausgabe ............................................................................................. 35
6.6 Live-Session ........................................................................................................................... 38
6.7 Teilnehmerliste importieren ................................................................................................. 40
6.8 RFID-Tag einem Namen zuweisen ......................................................................................... 42
6.9 Daten zum Webserver senden .............................................................................................. 43
6.9.1 Page WebOptionCreate ................................................................................................. 44
6.9.2 Übertragung der Daten zum Webserver ....................................................................... 45
7 Software auf dem Webserver ....................................................................................................... 49
7.1 Arbeitsumgebung .................................................................................................................. 49
7.2 Einführung in PHP und MySQL .............................................................................................. 49
7.2.1 Variablen und Strings in PHP ......................................................................................... 49
7.2.2 Empfangen von Daten ................................................................................................... 50
7.2.3 Daten in die Datenbank schreiben ................................................................................ 50
7.3 Aufbau des Websystems ....................................................................................................... 50
7.4 PHP-Skripte ............................................................................................................................ 51
7.4.1 konfiguration.php .......................................................................................................... 51
7.4.2 rest.php ......................................................................................................................... 53
7.4.3 output.php und refresh.php .......................................................................................... 54
8 Fehlersuche, Tests und Verbesserungsmöglichkeiten .................................................................. 57
8.1 Fehlersuche im übernommenen System............................................................................... 57
8.1.1 Fehler bei der UART-Übertragung ................................................................................. 57
8.1.2 Fehlerhafter Handshake beim Slave .............................................................................. 58
8.1.3 Fehlerhafter Handshake beim Master .......................................................................... 58
8.2 Tests der PC-Applikation und der Webanwendung .............................................................. 59
8.3 Verbesserungsmöglichkeiten ................................................................................................ 61
9 Bedienungsanleitung ..................................................................................................................... 62
9.1 Installation und Konfiguration der PC- und Web-Software .................................................. 62
9.2 Inbetriebnahme des Gesamtsystems .................................................................................... 63
IV
9.2.1 Teilnehmerliste importieren ......................................................................................... 64
9.2.2 Verbindung zum Webserver herstellen ......................................................................... 65
9.2.3 Verbindung zu einer Komponente über USB herstellen ............................................... 66
10 Projektmanagement .................................................................................................................. 68
10.1 Meilensteinplanung ............................................................................................................... 68
10.3 Arbeitszeitplanung ................................................................................................................ 69
10.4 Auswertung der Projektplanung ........................................................................................... 70
10.4.1 Meilensteintrendanalyse ............................................................................................... 70
10.4.2 Arbeitszeit ...................................................................................................................... 71
11 Fazit ........................................................................................................................................... 72
12 Abbildungsverzeichnis ...........................................................................................................LXXIII
13 Tabellenverzeichnis ............................................................................................................... LXXV
14 Literaturverzeichnis .............................................................................................................. LXXVI
15 Glossar und Abkürzungsverzeichnis ................................................................................... LXXVIII
5
1 Erklärungen
1.1 Nutzungsrechte
Ich, Karsten Dürschinger, übertragen die vollen Nutzungsrechte für alle eingereichten Unterlagen dieser Bachelorarbeit an die Hochschule Emden/Leer und deren Angehörigen. Dies gilt auch für die Weitergabe an Medien und die Nutzung im Rahmen öffentlicher Vorträge, Präsentationen und ähnlichem.
1.2 Eidesstattliche Erklärung
Hiermit versicher ich, Karsten Dürschinger, dass ich die vorliegende Arbeit selbstständig verfasst und keine anderen als die angegebenen Quellen und Hilfsmittel benutzt habe, dass alle Stellen der Arbeit, die wörtlich oder sinngemäß aus anderen Quellen übernommen wurden, als solche kenntlich gemacht sind und dass die Arbeit in gleicher oder ähnlicher Form noch keiner Prüfungsbehörde vorgelegt wurde. __________________________________________________________ Ort, Datum, Unterschrift von Karsten Dürschinger
6
2 Einleitung
Zum Abschluss des Bachelorstudienganges Informatik an der Hochschule Emden-Leer ist eine
Bachelor-Thesis zu verfassen. Diese Umfasst 12 ECTS-Punkte und ist in einem Zeitlichen Rahmen von
10-24 Wochen zu fertigen. Bei der Umsetzung der gestellten Aufgabe ist die Arbeit vom Studenten
selbständig zu lösen. In dieser Bachelorarbeit wird sich in ein bestehendes System eingearbeitet und
dieses anschließend den neuen Anforderungen angepasst. Bei dem System handelt es sich um ein
Zeitmesssystem für Freiwasser-Schwimmwettbewerbe. Das Zeitmesssystem ist eine
Eigenentwicklung der Hochschule Emden-Leer, die Zeiterfassung basiert dabei auf RFID-Tags. In
dieser Bachelorarbeit wird das Gesamtsystem zum ersten Mal in Betrieb genommen und um die
Bereitstellung der Ergebnisse im Internet erweitert.
2.1 Danksagung
Während der Bearbeitung meiner Bachelor-Thesis wurde ich von vielen Seiten unterstützt.
Mein besonderer Dank gilt folgenden Personen:
Prof. Dr.-Ing. Dirk Rabe – Projektgeber
Dipl.-Ing. Harald Buß – Projektbetreuer
Sie standen bei Fragen immer hilfreich zur Seite.
2.2 Dokumentenstruktur
Im Abschnitt 3 wird die Ausgangslage und die Aufgabenstellung beschrieben. Die Implementierung
einer ZigBee-Verbindung wird im Abschnitt 4 erläutert. Die Erweiterung der USB-Kommunikation ist
im Abschnitt 5 beschrieben. Im Abschnitt 6 ist dokumentiert wie die PC-Applikation entwickelt
wurde. Abschnitt 7 behandelt die Entwicklung der PHP-Skripte für die Webanwendung. Ein
Funktionstest des Gesamtsystems ist im Abschnitt 8 dokumentiert. Eine Bedienungsanleitung für die
Komponenten ist im Abschnitt 9 beschrieben. Die Planung der Bachelorarbeit ist im Abschnitt 10
dokumentiert. Ein Gesamtfazit ist im Abschnitt 11 festgehalten.
7
3 Ausgangslage und Aufgabenstellung
In der Projektarbeit „Implementierung einer drahtlosen ZigBee-basierten Datenübertragung für eine
ARM-basierte Microkontroller-Applikation“ 14 habe ich mich mit dem Thema ZigBee und der Cortex
M3 Programmierung beschäftigt. Dieses Projekt war ein Teilprojekt eines größeren Gesamtsystems.
Zu dem Gesamtsystem gehören zwei weitere Bachelorarbeiten („Entwurf und Implementierung eines
ARM-basierten Systems (HW/SW) zur Verarbeitung und Übertragung von RFID-Tag-Daten“ [2] und
„Weiterentwicklung eines kontroller-basierten System zur Datenerfassung per RFID“ [3]). Diese
Systeme bilden zusammen ein Zeitmesssystem für Freiwasser-Schwimmwettbewerbe. Abbildung 1
zeigt die einzelnen Komponenten. Die dargestellte Funkverbindung wurde von mir in der
Projektarbeit [1] entworfen, jedoch noch nicht in dieses System integriert. Ein Test aller
Komponenten und deren Zusammenspiel konnte daher noch nicht durchgeführt werden. In der
Projektarbeit „Windows basierte RFID-Tag Erfassung mit C#“ [4] wurde eine Software geschrieben,
mit der eine Teilnehmerliste um die RFID-Tags erweitert wird.
Abbildung 1: Übersicht der Systemkomponenten [2]1
1 S. 8
8
3.1 Ausgangslage
Die Bachelorarbeit baut auf mehrere Komponenten auf, diese werden in diesem Abschnitt in
Kurzform erläutert.
3.1.1 RFID-Tag-Lesegerät
Das RFID-Tag-Lesegerät besteht aus drei Komponenten:
einer Antenne (Abbildung 2), an der die Schwimmer mit
dem RFID-Tag (Abbildung 3) anschlagen und
dem eigentlichen Zeitmesssystem (Abbildung 4).
Abbildung 2: RFID-Antenne (Anschlag auf anderer Seite)
9
Abbildung 3: RFID-Tag
Abbildung 4: Zeitmesssystem
Abbildung 4 zeigt das Zeitmesssystem, an dem ein RFID-Sensor angeschlossen ist. Die Spannung wird
von einer externen Spannungsquelle bezogen (12 V=), ein Betrieb über Akku ist möglich. Über eine
weitere Leitung ist die Verbindung zum Master (siehe Abbildung 1) hergestellt.
Die erfassten Zeitmessungen werden über den UART2-Standard an den Master übertragen. Dabei
wird bei jeder Übertragung ein einzelner Datensatz verschickt. Dieser besteht aus einem RFID-Tag
oder einem „Nachstart3“ und dem dazugehörigen Zeitstempel. Für die Übertragung wird zwischen
2 Universal Asynchronous Receiver Transmitter
3 Start der Zeitmessung
10
dem RFID-Tag und dem Zeitstempel ein Delimiter4 gesetzt. Das Ende einer Übertragung wird durch
das Zeichen „#“ signalisiert. Tabelle 1 zeigt den Aufbau eines UART-Datensatzes.
Information: RFID-Tag/Start Delimiter Zeit Ende des Datensatzes
Inhalt: Tag-Nummer/Start ; Zeitstempel # Tabelle 1: Aufbau der UART-Datensätze
4 Trennzeichen
11
3.1.2 Datensender (Master)
Der Master nimmt die Daten vom RFID-Tag-Lesegerät auf und speichert diese ab. Über eine USB-
Schnittstelle ist ein Anschluss an die Applikation „Data-Receiver“ möglich. Mit dieser können die
Daten ausgelesen werden. Die wichtigste Funktion, das Versenden der Datensätze über ZigBee, ist
noch nicht implementiert. Die ZigBee-Software ist wie bereits erwähnt programmiert, jedoch noch
nicht eingebunden. Abbildung 5 zeigt den Master, die Betriebsspannung und die Datensätze bezieht
der Master über eine einzige Verbindung zum RFID-Tag-Lesegerät.
Abbildung 5: Datensender (Master)
3.1.3 Datenempfänger (Slave)
Der Slave soll in der späteren Anwendung an einem PC angeschlossen werden. Auf diesem ist über
die Applikation „Data-Receiver“ das Auslesen der Wettkampfergebnisse möglich. Die Datensätze
werden über ZigBee vom Master empfangen, somit ist auch ein Auslesen der Daten aus einer
größeren Entfernung vom eigentlichen Messsystem möglich. Abbildung 6 zeigt den Slave, die
Kommunikation und die Betriebsspannung wird über eine USB-Verbindung ermöglicht.
12
Abbildung 6: Datenempfänger (Slave)
3.1.4 Applikation (Data-Receiver)
Die Applikation „Data-Receiver“ ist für die Installation auf einem handelsüblichen PC mit Windows-
Betriebssystem vorgesehen. Über USB kann eine Verbindung zum Master oder zum Slave hergestellt
werden. Die Software bietet Steuerungsfunktionen für diese Komponenten und das Auslesen der
Wettkampfergebnisse. Die Ergebnisse werden in einer vorher festgelegten CSV-Datei gespeichert.
Abbildung 7 zeigt das Startbild dieser Anwendung. Die Software ist in C#5 mit „Windows Forms“6
programmiert.
5 C# ist eine objektorientierte Programmiersprache
6 Programmierschnittstelle für Benutzeroberflächen unter C#
13
Abbildung 7: Data-Receiver
3.1.5 Applikation Teilnehmerliste
Die Applikation ermöglicht es, jeder teilnehmenden Person einen eindeutigen RFID-Tag zuzuweisen.
Dies ist vor dem Wettkampf durchzuführen und ermöglicht später ein explizites Zuweisen vom RFID-
Tag zum Namen. Mit dieser Software ist das Erstellen einer Teilnehmerliste möglich.
3.1.6 ZigBee
Die Übertragung der Daten vom Master zum Slave soll über den ZigBee-Standard realisiert werden.
Eine entsprechende Software ist entworfen und funktionstüchtig. Diese muss noch in die
Komponenten Master und Slave integriert werden.
14
3.2 Aufgabenstellung
Die Aufgabe gliedert sich in drei Teilbereiche:
1. Integration der ZigBee-Kommunikation.
2. Daten „live“ an den PC übertragen.
3. Ergebnisse auf einem Webserver bereitstellen.
Zu 1.) Die ZigBee-Kommunikation muss in den Master und den Slave integriert werden. Dafür ist
eine Einarbeitung in die bestehende Software nötig. Da die ZigBee-Kommunikation von mir
selber entwickelt wurde, entfällt eine Einarbeitung in die ZigBee-Thematik. Die Software ist
in „C“ geschrieben und läuft auf ARM Cortex M3 Prozessoren. Nach Integration der
Kommunikationsverbindung ist die Kommunikation zwischen Master und Slave entsprechend
den Anforderungen zu testen. Ist die Funktionsweise gegeben, kann mit dem zweiten Teil der
Aufgabe begonnen werden.
Zu 2.) Über die Software „Data-Receiver“ ist das Auslesen der Ergebnisse im Ready-Modus des
Slaves und Masters möglich. Dieses erlaubt es nach einem Wettkampf das Gesamtergebnis
auszulesen. In der bestehenden Software ist es jedoch nicht möglich, die Ergebnisse „Live“
auszulesen. Für die „live-Ergebnisse“ müssen Änderungen an der Slave- und Data-Receiver -
Software vorgenommen werden. Erhält der Slave über ZigBee einen neuen Datensatz, soll
dieser wie zuvor auf dem Flash gesichert werden, zudem muss dieser Datensatz nun über
USB an die PC-Software weitegeleitet werden.
Zu 3.) Es soll ermöglicht werden, von der PC-Software aus eine Verbindung zu einem Webserver
herzustellen. Auf diesem Webserver sollen die Ergebnisse gesichert und per Webbrowser
abrufbar sein. Zur Speicherung der Daten bietet sich ein Datenbanksystem an. Für die
Umsetzung sind grundlegende Änderungen oder eine Neuentwicklung der PC-Software
nötig. Für die Entwicklung der Webseite muss ein Webserver eingerichtet werden oder die
Dienste eines kostenlosen Webspace-Anbieters verwendet werden. Die Daten von der PC-
Software müssen zu dem Webserver geschickt werden und dort in die Datenbank eingepflegt
werden.
15
4 Implementierung der ZigBee-Kommunikation
In der von mir angefertigten Projektarbeit [1] habe ich eine Kommunikation für den Datenaustausch
zwischen Master und Slave entwickelt. Die Entwicklung wurde auf einem eigenständigen System
durchgeführt und bedarf noch kleinerer Anpassungen. Anschließend ist die Kommunikation in dem
System aus der Bachelorarbeit [2] zu integrieren. Im Abschnitt 4.1 wird kurz die
Entwicklungsumgebung vorgestellt. Die vorgenommenen Anpassungen für den Master werden im
Abschnitt 4.2 erläutern, für den Slave sind die Anpassungen im Abschnitt 4.3 dokumentiert.
4.1 Arbeitsumgebung
Für die Softwareentwicklung wurde auf die aus dem Projekt [1] bekannte Entwicklungsumgebung
„mikroC Pro for Arm Version 3.00“ zurückgegriffen. Als Programmiergerät kam der „mikroProg for
STM32“ von „mikroElektrinika“ zum Einsatz. Die Software aus der Bachelorarbeit [2] wurde
übernommen und muss mit der ZigBee-Kommunikation erweitert werden. Gearbeitet wurde auf der
aus der Bachelorarbeit [2] stammenden Hardware (siehe Abschnitt 3.1.2 und Abschnitt 3.1.3).
4.2 Master
Der Master muss die vom RFID-Tag-Lesegerät erhaltenen Datensätze (siehe 3.1.1) via ZigBee an den
Slave versenden. Dafür muss die ZigBee-Software für den Master aus dem Projekt [1] eingebunden
werden.
4.2.1 Anpassungen der ZigBee-Software
Die ZigBee-Kommunikation wurde auf einer eigenen Entwicklungsumgebung entwickelt. Für die
Entwicklung auf einem eigenständigen System wurden Funktionen geschaffen, die mit der
Integration in das Gesamtsystem überflüssig geworden sind. Nachfolgend werden die Bearbeitungen
aufgezeigt:
1. Entfernung der Funktion „void init()“:
In dieser Funktion wurde die MCU eingerichtet, dieses wird bereits in der Master-Software
erledigt und ist daher in der Endanwendung nicht mehr in der ZigBee-Software nötig.
16
2. Änderung der „void Main()“-Funktion:
Zum Testen der ZigBee-Kommunikation wurden in der Main-Funktion Testdatensätze
erzeugt. Die Testdaten wurden zunächst in eine Queue7 geschrieben, aus der die Daten dann
über ZigBee verschickt wurden. Die Testdaten werden im späteren Betrieb nicht mehr
benötigt und können entfernt werden. Abbildung 8 zeigt den Code-Ausschnitt, in dem die
Testdaten erzeugt werden. Dies wird nicht mehr benötigt und konnte deshalb entfernt
werden. Das Füllen der Queue mit Daten (Abbildung 9) wird in der späteren Anwendung vom
Master durchgeführt. Ein Füllen der Queue in der ZigBee-Software ist daher nicht mehr nötig
und wurde deshalb entfernt. In der Software des Masters existiert bereits eine Main-
Funktion, daher musste die Main-Funktion in der ZigBee-Software umbenannt werden. Der
neue Name ist „void zigbee()“.
3. Entfernung der Pins für die LEDs
Zur Optischen Wiedergabe kam bei der Entwicklung der ZigBee-Kommunikation eine
zusätzliche LED-Platine zum Einsatz. Diese findet im Endsystem keine Anwendung mehr.
Daher müssen die festgelegten Pins für die LEDs entfernt werden. Abbildung 10 zeigt den
entfernten Code.
Abbildung 8: Erzeugung der Testdaten
7 Warteschlange, wird mit Daten gefüllt die dann per ZigBee versendet werden
17
Abbildung 9: Füllen der Queue mit Testdaten
Abbildung 10: Pins der LED-Platine
Der Dateiname „master“ ist zudem in „zigbee“ geändert worden. So soll später schnell erkennbar
sein, welche Funktion diese Komponente umfasst.
4.2.2 Integration ZigBee in die Master-Software
Nach Durchführung der im Abschnitt 4.2.1 beschriebenen Änderungen war die ZigBee-Software
bereit für die Integration in die Master-Software. Die Integration wird in den folgenden 4 Abschnitten
beschrieben. Der erste Abschnitt (4.2.2.1) behandelt das Hinzufügen der ZigBee-Dateien in das
bestehende Master-Projekt. Unter Abschnitt 4.2.2.2 wird erläutert, wie die MCU konfiguriert werden
muss. Im Abschnitt 4.2.2.3 wird erklärt, welche Funktionen der ZigBee-Software aufgerufen werden
müssen. Abschließend wird im Abschnitt 4.2.2.4 die Anpassung der LED-Ausgabe des Masters
beschrieben.
18
4.2.2.1 Einbinden der ZigBee-Dateien
Zuerst müssen die Quelldateien der ZigBee-Kommunikation dem Projekt8 hinzugefügt werden, dies
ist einfach durch Rechtsklick auf Sources möglich. Abbildung 11 zeigt das sich öffnende Kontextmenü,
indem über „Add File To Project…“ die „zigbee.c“-Datei dem Projekt hinzugefügt werden kann. Mit
den Header-Files ist die Vorgehensweise identisch, nur das diese unter „Header Files“ hinzugefügt
werden.
Abbildung 11: Quelldatei dem Projekt hinzufügen
Folgende Dateien müssen hinzugefügt werden:
1. zigbee.c
2. WriteReadBoth.c
3. WriteReadBoth.h
4. zigbee.h
4.2.2.2 Konfiguration der MCU
In der Master-Software ist die MCU bereits grundlegend konfiguriert, um das ZigBee-Modul
ansprechen zu können, müssen jedoch einige Ergänzungen vorgenommen werden.
Für den Datenaustausch zwischen MCU und ZigBee-Modul wird der bereits konfigurierte SPI9-Bus
genutzt. Abbildung 12 zeigt den Programmausschnitt aus der Funktion „init_MCU()“, in dem der SPI-
Bus eingerichtet wird.
8 Software-Projekt in der Entwicklungsumgebung, in dem die Master-Software bearbeitet wird
9 Serial Peripheral Interface
19
Abbildung 12: SPI-Bus Initialisierung
Für den Datenaustausch zwischen MCU und dem ZigBee-Modul über den SPI-Bus ist ein Signal „Chip-
Select“ zu implementieren. Liegt am „Chip-Select“ des ZigBee-Moduls eine „0“ an, ist dies aktiv. Der
GPIO10-Pin der MCU (Pin PA4), der zu dem „Chip-Select“ des ZigBee-Moduls führt, ist als Ausgang zu
konfigurieren.
Hat das ZigBee-Modul eine neue Nachricht empfangen, wird ein Interrupt ausgelöst. Bei ausgelöstem
Interrupt liegt am Interrupt-Pin des ZigBee-Moduls eine „0“, ansonsten eine „1“. Dieser Wert wird
durch die MCU an dessen Pin PB9 ausgelesen. PB9 ist folglich als Eingang zu konfigurieren. Abbildung
13 zeigt den Code-Ausschnitt, in dem der Pin PB9 der MCU als Eingang konfiguriert wird.
Abbildung 13: GPIO-Pin als Eingang konfigurieren
Abbildung 14: MCU-Pins einen Namen zuweisen
In Abbildung 14 wird der Code-Abschnitt gezeigt, in dem durch „sbit“ den Pins der MCU einen Namen
zugewiesen wird.
4.2.2.3 Einbinden der ZigBee-Kommunikation
Zur Verwendung der ZigBee-Kommunikation reicht der Aufruf von drei Funktionen aus.
Bevor das ZigBee-Modul genutzt werden kann ist eine Initialisierung des Moduls notwendig. Die
Initialisierung findet in der Funktion „zigbee_init()“ der Datei zigbee.c statt. Diese Funktion muss zum
Programmstart einmalig aufgerufen werden. Abbildung 15 zeigt den Aufruf der Funktion, dieser wird
direkt nach der MCU Initialisierung in der main()-Funktion des Masters durchgeführt.
10
General-purpose input/output (Pins der MCU)
20
Abbildung 15: ZigBee Initialisierung
Die eigentliche Kommunikation über ZigBee wird durch den Aufruf der Funktion „zigbee()“ realisiert.
Diese ist in den Programmablauf so zu integrieren, dass sie fortlaufend aufgerufen wird. In der
Master-Software wird dies in der main()-Funktion ermöglicht. Abbildung 16 zeigt den Aufruf der
ZigBee-Kommunikation in der while(1)-Schleife der main()-Funktion.
Abbildung 16: Einbindung der ZigBee-Kommunikation
Die dritte Funktion puffert die Datensätze, die über ZigBee versendet werden sollen. Die ZigBee-
Software bietet dafür eine Queue an. In dieser werden die Datensätze gespeichert, beim nächsten
Aufruf von „zigbee()“ werden diese dann verschickt. Die Datensätze werden durch die Funktion
„FIFO_push()“ in die Queue aufgenommen. Abbildung 17 zeigt den Aufruf der Funktion FIFO_push(),
als Parameter wird die Adresse des zu übergebenden Datensatz angegeben. Aufgerufen wird die
Funktion, wenn ein Datensatz über UART vom RFID-Tag-Lesegerät eingegangen ist.
Abbildung 17: ZigBee-Queue füllen
4.2.2.4 Anpassung der LED-Ausgabe
Der Master bietet durch LEDs die Möglichkeit Informationen optisch darzustellen. Für die ZigBee-
Kommunikation ist die LED „LED_BEE_ACTIVITY“ vorgesehen. Wird ein Verbindungstest
durchgeführt, bei dem eine ZigBee-Verbindung aufgebaut werden kann, signalisiert die LED durch
Leuchten, dass eine Verbindung zum Slave hergestellt werden konnte. Abbildung 18 zeigt den Master
an dem die hier genutzten LEDs gekennzeichnet wurden.
21
Abbildung 18: Master mit gekennzeichneten LEDs
Befindet sich der Master im Operate-Modus, bedeutet ein aufleuchten der LED die Versendung eines
Datensatzes
Zudem wirkt sich die ZigBee-Kommunikation auf die Error-LEDs des Masters aus. Die Error-LEDs
geben durch verschieden schnelles Blinken unterschiedliche Stufen von Fehlern an. Konnte keine
ZigBee-Verbindung aufgebaut werden, erhöht sich der Error-Fehler und dadurch die
Blinkgeschwindigkeit. Abbildung 19 zeigt einen Code-Ausschnitt, in diesem wird die Variable
„con_error“ erhöht sofern keine ZigBee-Verbindung aufgebaut werden konnte. Die Auswertung wird
durch die bestehende Software vom Master vorgenommen.
Abbildung 19: Error zuweisen
4.3 Slave
Der Slave empfängt die vom Master verschickten Datensätze über ZigBee. Dafür sind Anpassungen
der ZigBee-Software und eine anschließende Einbindung der ZigBee-Software in die Slave-Software
nötig. Eingebunden werden muss die aus der Projektarbeit [1] stammende ZigBee-Software für den
Slave.
22
4.3.1 Anpassungen der ZigBee-Software
Wie auch beim Master (siehe Abschnitt 4.2.1) müssen einige Änderungen in der ZigBee-Software
vorgenommen werden. Nachfolgend werden die durchgeführten Änderungen aufgeführt:
1. Funktion „void init()“ entfernt
Die Initialisierung der MCU wird von der Slave-Software übernommen und muss deshalb
nicht mehr in der ZigBee-Software durchgeführt werden.
2. Funktion „mode_Pay()“ bearbeitet
In dem Projekte [1] wurde mit Testdaten gearbeitet, diese wurden in der Funktion
„mode_Pay()“ ausgewertet. In der Endanwendung werden keine Testdaten mehr verschickt,
somit ist eine Überprüfung der eingegangen Datensätze nicht mehr nötig. Der Code wurde
einfach auskommentiert und kann bei Bedarf wieder genutzt werden. Durch eine neu
eingefügte Variable wird der Slave-Software signalisiert, dass ein neuer Datensatz über
ZigBee eingegangen ist. Bei einem eingegangen Datensatz wird nun der Variablen
„new_Data_From_ZigBee“ eine „1“ zugewiesen (siehe Abbildung 20).
Abbildung 20: Variable neuer Datensatz ist eingegangen
Wie beim Master wurde die Quelldatei von „slave.c“ zu „zigbee.c“ umbenannt.
4.3.2 Anpassung der Slave-Software
Nachdem die ZigBee-Software im Abschnitt 4.3.1 angepasst wurde, ist die Einbindung der ZigBee-
Kommunikation in die bestehende Slave-Software möglich. Die zu tätigen Schritte hierfür werden in
den folgenden 4 Abschnitten erläutert.
4.3.2.1 Einbindung der ZigBee-Dateien
Die Einbindung der Daten erfolgt nach dem gleichen Schema wie bei dem Master. Die
Vorgehensweise ist dem Abschnitt 4.2.2.1 zu entnehmen. Für den Slave müssen die vorbereiteten
ZigBee-Dateien eingebunden werden. In diesem Falle sind das folgende vier Dateien:
1. zigbee.c
2. WriteReadBoth.c
3. zigbee.h
4. WriteReadBoth.h
4.3.2.2 Konfiguration der MCU
Die Änderungen, die bei der Konfiguration der MCU im Slave vorgenommen werden müssen, sind
identisch zu den Änderungen beim Master. Nachzulesen sind diese Änderungen im Abschnitt 4.2.2.2.
23
4.3.2.3 Einbindung der ZigBee-Kommunikation
Um die ZigBee-Kommunikation im Slave nutzen zu können, müssen lediglich zwei Funktionen
aufgerufen werden. Zum einen „zigbee_init()“ und zum anderen „zigbee()“, die Einbindung ist
identisch zu der beim Master. Aus dem Abschnitt 4.2.2.3 können weitere Informationen entnommen
werden.
Speziell beim Slave muss zudem noch die Abspeicherung der eingegangenen Datensätze
vorgenommen werden. Dafür wird in der Funktion Action() des Slaves abgefragt, ob ein neuer
Datensatz eingegangen ist. Abbildung 21 zeigt den Quellcode, in dem der eingegangene Datensatz
vom ZigBee-Modul der Variablen „Received_Data[]“ zugewiesen wird. Anschließend wird der
Datensatz in den Flash-Speicher der MCU geschrieben. Nachdem der neue Datensatz verarbeitet
wurde, wird die Variable „new_Data_From_Zigbee“ auf „0“ gesetzt.
Abbildung 21: Eingehende Datensätze speichern
4.3.2.4 Anpassung der LED-Ausgabe
Die ZigBee-Kommunikation wirkt sich direkt auf die LED „LED_BEE_ACTIVITY“ aus. Dabei
unterscheidet sich die Funktion der Lampe je nachdem, in welchem Modus sich der Slave befindet.
Im Modus „Ready“ zeigt ein Leuchten der LED eine aufgebaute ZigBee-Verbindung an. Befindet sich
der Slave im Operate-Modus, leuchtet die LED kurz auf sobald ein neuer Datensatz empfangen
wurde. Wie beim Master gibt es auch beim Slave eine Error-Ausgabe. Der Error-Grad wird durch
verschieden schnelles Blinken der Error-LED dargestellt. Abbildung 22 zeigt einen Ausschnitt aus dem
Quellcode, in welchem der Error-Wert hochgezählt wird sofern keine ZigBee-Verbindung besteht. Die
bereits in der Slave-Software implementierte Auswerte-Logik bestimmt, welche LEDs angesprochen
werden. In Abbildung 23 ist der Slave mit gekennzeichneten LEDs zu sehen.
24
Abbildung 22: Error-Auswertung
Abbildung 23: Slave mit gekennzeichneten LEDs
4.4 Inbetriebnahme des Gesamtsystems
Nachdem die ZigBee-Kommunikation Implementiert wurde, konnte das Gesamtsystem in Betrieb
genommen werden. Dabei kamen alle Komponenten aus den Bachelorarbeiten [2] und [3] zum
Einsatz sowie die ZigBee-Kommunikation aus dem Projekt [1]. Das System lief grundsätzlich, im Laufe
des Betriebs konnten jedoch noch einige Fehler entdeckt werden. Auf die Fehleruntersuchung und
-behebung wird im Abschnitt 8.1 eingegangen.
25
5 Erweiterung der USB-Kommunikation
In der Ausgangskonfiguration bietet das System das Auslesen der Wettkampfergebnisse nur im
Ready-Modus des Slaves und Masters an. Somit ist eine Auswertung der Wettkampfergebnisse erst
nach Beendigung des Rennens möglich. In dieser Bachelorarbeit soll das System erweitert werden.
Ermöglicht werden soll eine „Live“-Übertragung der Datensätze an die PC-Applikation. Dabei müssen
Änderungen an der C-Software vom Slave sowie an der C#-Applikation für den PC vorgenommen
werden. Da der Master im späteren Betrieb nicht für die Live-Übertragung vorgesehen ist, wird
dessen Funktionsumfang beibehalten. Dieser Abschnitt befasst sich mit den Änderungen an der
Slave-Software. Die Änderungen der PC-Software werden im Abschnitt 6.4 erläutert.
5.1 Aufbau der USB-Kommunikation
In der Bachelorarbeit [2]11 wurde die USB-Kommunikation zwischen den Komponenten Master/Slave
und der PC-Applikation definiert. Eine Übertragung über USB ist dabei standardmäßig 64 Byte groß.
Tabelle 2 zeigt den Aufbau eines USB-Datensatzes. Entscheidend für die Erweiterung der
Kommunikation ist der „OP-Code“-Bereich. In diesem wird definiert, wie der Empfänger mit dem
empfangenen Datensatz umzugehen zu hat.
Byte Beschreibung
0-2 OP-Code 3 Status 4-7 Versorgungspannung 8-11 Anzahl der Datensätze 12-63 Datensatz (RFID-Tag u. Zeitstempel)
Tabelle 2: Aufbau eines USB-Datensatzes [2] 12
In der Bachelorarbeit [2] wurden bereits mehrere Befehle festgelegt, diese werden in der Tabelle 3
kurz aufgeführt. Dabei handelt es sich um Befehle, die von der PC-Applikation zum Slave/Master
geschickt werden können. Nicht aufgeführt sind Befehle, die vom Slave/Master zum PC gesendet
werden. Diese sind in der Tabelle 4 aufgeführt. Für die Realisierung der „Live“-Ergebnisse wird ein
zusätzlicher Befehl benötigt, der vom Slave zum PC gesendet wird. Festgelegt wurde dieser mit „RTD“
(Real-Time-Data), siehe Tabelle 5. Anhand des OP-Codes kann die PC-Applikation den empfangenen
Datensatz als Live-Ergebnis erkennen und entsprechend verarbeiten.
11
Seite 50 12
Seite 53
26
Kurzbeschreibung Befehl Beschreibung
Reset RES Wenn sich das Gerät im Fehlerzustand MODUS_FATAL_ERROR befindet, kann das Gerät über die Applikation neu gestartet werden. Dafür wird der der Befehl RES an das jeweilige Gerät gesendet.
Speicher löschen DEL Durch die Übertragung des Kürzels DEL wird das Löschen des Speichers verursacht.
Flashinhalt übertragen TRA Durch die Übermittlung des Befehls TRA startet das angeschlossene Gerät den Transfer des Flash-Speicher-Inhalts an die Applikation
Datenübertragung starten SRT Durch diesen Befehl wird das System gestartet
Datenübertragung stoppen STO Durch diesen Befehl kann die Systemausführung wieder gestoppt werden
Tabelle 3: Bisherige Befehle aus der Bachelorarbeit [2]13
Kurzbeschreibung Befehl Beschreibung
Datenübertragung fertig DOK Gibt an, dass das Auslesen des Flash-Speichers beendet wurde.
Handshake CO Wird zur PC-Applikation gesendet, um einen Handshake durchzuführen.
Tabelle 4: Befehle die von der PC-Applikation ausgewertet werden
Kurzbeschreibung Befehl Beschreibung
Live-Datensatz RTD Gibt an, dass es sich um einen Live-Datensatz handelt.
Tabelle 5: Befehl "RTD"
5.2 Slave-Software
In der momentanen Konfiguration erhält der Slave einen Datensatz über die ZigBee-Kommunikation
und speichert diesen auf den internen Flash-Speicher ab. Mit dem im Abschnitt 5.1 definierten Befehl
„RTD“ sind die Grundlagen für eine Implementierung der Live-Übertragung gelegt. Festgelegt werden
muss noch der optimale Zeitpunkt für die Übertragung der Datensätze. Es bietet sich an, die
13
Seite 41
27
Datensätze direkt nach dem Empfang über ZigBee an die Applikation zu übertragen. Das hat den
Vorteil, dass sich der Datensatz noch im Arbeitsspeicher der MCU befindet und nicht extra wieder
aus dem Flash ausgelesen werden muss. Abbildung 24 zeigt den Quellcode, in dem die Übertragung
der Live-Ergebnisse durchgeführt wird. Der obere Teilbereich ist schon aus dem Abschnitt 4.3.2.3
bekannt, hier wird ein einkommender Datensatz vom ZigBee-Modul auf dem Flashspeicher der MCU
gesichert. Hinzugefügt wurde der Code in dem umrahmten Bereich, hier findet die USB-Übertragung
statt.
Abbildung 24: Implementierung der USB-Live-Übertragung
Die Variable „writebuff[]“ wird entsprechend der Definition aus dem Abschnitt 5.1 gefüllt und durch
den Aufruf der Funktion „HID_Write(&writebuff, USB_Buffer);“ über USB an die PC-Applikation
übertragen.
28
6 Entwicklung der PC-Applikation
Im Abschnitt 3.1.4 wurde bereits kurz die bestehende PC-Applikation vorgestellt. Diese wurde zu
Beginn der Arbeit mit der Funktion „Live-Ergebnisse“ erweitert. Im Laufe der Entwicklungszeit musste
jedoch festgestellt werden, dass die bestehende Software eher suboptimal programmiert wurde. Die
Vorzüge einer objektorientierten Programmiersprache wurden nicht umgesetzt. Das gravierende
Problem war jedoch die starre Fenstergröße. Dies stellt vor allem beim Einlesen von größeren
Teilnehmerlisten, die eine höhere Anzahl von Spalten besitzen, ein Problem dar. Es was zu
entscheiden, entweder die Software den neuen Gegebenheiten anzupassen oder eine neue Software
zu entwickeln.
Nach einem Entscheidungsprozess haben die Vorteile für eine Neuentwicklung der Software
überwogen. Die entscheidenden Punkte waren:
1. Umstellung von der veralteten WinForms-API14 auf die modernere WPF15-API.
2. Die grafische Umsetzung gestaltet sich mit der WPF-API einfacher.
3. Vorhandene Code-Abschnitte können zum Teil in die neue Software übernommen werden,
womit sich der Arbeitsaufwand in Grenzen hält.
Die Dokumentation beschränkt sich auf die WPF-Version des Programmes. Alle Funktionen die in der
ersten Version eingebaut wurden, sind auch in der WPF-Anwendung enthalten. Im späteren Verlauf
wird des Öfteren der Begriff „Systemkomponente“ genutzt, damit sind der Master und der Slave aus
der Bachelorarbeit [2] gemeint.
6.1 Die Entwicklungsumgebung
Als Entwicklungsumgebung kam von Microsoft das Produkt Visual Studio 2012 Ultimate [5] zum
Einsatz. Durch die Teilnahme der Hochschule Emden-Leer an dem MSDNAA16-Programm konnte die
Software kostenlos genutzt werden. In der Bachelorarbeit [2] wurde die Software ebenfalls genutzt
und dort als gute Entwicklungsumgebung beurteilt. Aufgrund der eigenen Erfahrung im Umgang mit
der Entwicklungsumgebung kam ich ebenfalls zu einem positiven Gesamteindruck. Microsoft bietet
online unter den Namen „msdn“ [6] eine sehr gute Dokumentation zu C# an. Als besonders positiv
bewerte ich die komfortable Design-Oberfläche und die hervorragende Möglichkeit zum Debuggen.
14
Application programming interface oder in Deutsch: Programmierschnittstelle 15
Windows Presentation Foundation 16
http://www.hs-emden-leer.de/fachbereiche/technik/unix-system/msdnaa.html
29
6.2 Einführung in die WPF-Programmierung
In diesem Abschnitt werden grundlegende Funktionen, die für die WPF-Programmierung genutzt
wurden, erklärt. Der Abschnitt 6.2.1 erklärt XAML und C#. Im Abschnitt 6.2.2 werden Data-Bindings
erläutert. Wie verschiedene Seiten ausgegeben werden ist im Abschnitt 6.2.3 erklärt.
6.2.1 Trennung der Benutzeroberfläche vom Hintergrundcode
Die Windows Presentation Foundation Programmierung ist eine moderne Variante für die
Programmierung von Benutzeroberflächen unter C#. Die wichtigste Neuerung in Vergleich zu den
WinForm-Anwendungen ist die Trennung von Design und Quellcode. Die Benutzeroberfläche wird in
XAML17, eine Unterart der XML-Sprache, erstellt. Die eigentliche Programmierung findet weiterhin in
C# statt. Unter XAML können deutlich mehr grafische Funktionen genutzt werden, als es bei
WinForm-Anwendungen möglich war. In Abbildung 25 ist ein XAML-Code aus der PC-Software zu
sehen. Abbildung 26 zeigt das aus dem XAML-Code generierte Design in der Vorschau von Visual
Studio. Der Hintergrundcode zu diesem XAML-Code wird in Abbildung 27 gezeigt. Wird auf dem
Button „Annehmen“ aus der Abbildung 26 gedrückt, wird die Zeile „private void
Annehmen_Click(object sender, RoutedEventArgs e)“ aus der Abbildung 27 ausgeführt. Durch die
eindeutige Trennung lässt sich die Arbeit gut auf einen Designer und Programmierer aufteilen.
Abbildung 25: XAML-Code
17
eXtensible Application Markup Language
30
Abbildung 26: WPF Designer-Ansicht
Abbildung 27: C#-Code
6.2.2 Data-Bindings
Ein wichtiger Aspekt in der WPF-Programmierung ist der Datenbindung zwischen dem Design-Bereich
und dem Hintergrundcode. In dieser Arbeit wurde speziell die Funktion „Binding18“ genutzt.
Anregung für die Datenbindung wurden sich aus dem Buch Visual C# 2010 von Galileo [7] geholt.
Gebraucht wird die Datenbindung z.B. wenn sich der Wert einer Variable im Hintergrundcode ändert
und sich diese Änderung auch auf die Benutzeroberfläche auswirken soll. In diesem Projekt geschieht
dies unter anderem bei der USB-Kommunikation zwischen Slave und PC-Applikation. Sendet der
Slave eine neue Anzahl von „Ergebnissen im Flash“, soll der neue Wert auf der Benutzeroberfläche
der PC-Applikation sichtbar sein. Abbildung 28 zeigt die Klasse, in denen die Variablen liegen, die mit
Datenbindungen an die Benutzeroberfläche bzw. mit dem XAML-Code verbunden sind. Durch die
Schnittstelle „INotifyPropertyChanged“ wird der Hintergrundcode mit dem XAML-Code verbunden.
Wird der Wert einer Variablen geändert, wird dies durch den Aufruf von „PropertyChanged(this, e);“
18
http://msdn.microsoft.com/de-de/library/system.windows.forms.control.databindings.aspx
31
der Benutzeroberfläche mitgeteilt. Die geänderten Werte werden dann an die verbundenen
Komponenten im XAML-Code weitergegeben.
Abbildung 28: Klasse für die Datenbindung [7]19
Abbildung 29 zeigt die Methode, in der die Werte für die Anzahl der Ergebnisse im Flash gespeichert
und abgerufen werden können. Der in Abbildung 30 dargestellte XAML-Code ist mit der Methode aus
Abbildung 29 „verbunden“ und bezieht aus dieser die Werte, die auf der Benutzeroberfläche
angezeigt werden.
Abbildung 29: Speicherung der Werte für "Ergebnisse im Flash"
Abbildung 30: XAML-Code zu "Ergebnisse im Flash"
6.2.3 Frame und Pages
In der vorgestellten PC-Applikation im Abschnitt 3.1.4 werden verschiedene Panel sichtbar und
unsichtbar geschaltet. Durch den Umstieg in das WPF-Format können nun eigene „Pages“ oder
Seiten angezeigt werden. Eine Page entspricht dabei einem Objekt, das immer nur dann erzeugt
wird, wenn es benötigt wird. Die einzelnen Pages werden dabei in einem vorher festgelegten Frame
angezeigt. Abbildung 31 zeigt den Quellcode des MainWindows, in dem ein Frame erzeugt wird. Der
Frame ist in diesem Fall in einem „ScrollViewer“ eingebettet, dieser erzeugt einen horizontalen und
vertikalen Scrollbalken.
19
http://openbook.galileocomputing.de/visual_csharp_2010/visual_csharp_2010_21_002.htm
32
Abbildung 31: Erzeugung eines Frames in XAML
In Abbildung 32 wird dem Frame „Frame1“ eine neue Seite zugewiesen. In diesem Fall wird von der
Page „Connect“ ein neues Objekt namens „Home“ erstellt. Die Page „Home“ wird nun in dem Frame
angezeigt, dabei handelt es sich im die Startseite.
Abbildung 32: Frame eine Page anzeigen lassen
6.3 Funktionen des Data-Receivers
Bestehende Funktionen des Data-Receivers (siehe Bachelorarbeit [2]20) sind zu übernehmen. Zudem
müssen einige neue Funktionen hinzugefügt werden. In Tabelle 6 sind die neuen Funktionen
aufgelistet.
Kurzbeschreibung Abschnitt Beschreibung
USB-Kommunikation anpassen
Live-Session (Abschnitt 6.6)
Die im Abschnitt 5.1 definierte Erweiterung der USB-Kommunikation für die „Live-Übertragung“ ist in die PC-Applikation zu integrieren.
Ausgabe der Ergebnisse automatisch aktualisieren
Live-Session (Abschnitt 6.6)
In der bisherigen Software muss für eine Aktualisierung der Ergebnisse ein Button betätigt werden. Bei Live-Session soll die Aktualisierung der Ausgabe automatisch geschehen.
Einlesen der Teilnehmerliste
Import (Abschnitt 6.7)
Momentan werden in der Software die Ergebnisse mit RFID-Tag und Zeitstempel ausgegeben. Durch das Einlesen der Teilnehmerliste können die RFID-Tags den Schwimmernamen zugewiesen werden.
RFID-Tag einen Namen zuweisen
Ausgabe (Abschnitt 6.8)
Die importierte Teilnehmerliste wird nach einem RFID-Tag durchsucht. Daraus ergibt sich die Möglichkeit den Namen eines Schwimmers anstelle des RFID-Tags auszugeben.
Verbindung zu einem Webserver
Web-Verbindung (Abschnitt 6.9)
Die Ergebnisse sollen auf einen Webserver bereitgestellt werden. Dadurch ergibt sich die Möglichkeit, dass die Zuschauer die Ergebnisse direkt einsehen können.
Tabelle 6: Neue Funktionen der PC-Software
20
Seite 46
33
6.4 Aufbau der Applikation
Durch die Umstellung zu einer WPF-Anwendung musste die Benutzeroberfläche neu erstellt werden.
Das Design ist an die Version der Bachelorarbeit [2] angelehnt. Die Fenstergröße ist nicht mehr starr
und kann vom Anwender geändert werden. Abbildung 33 zeigt die neue Oberfläche der PC-
Applikation beim Programmstart. Die Oberfläche ist in mehrere Bereiche, in der Abbildung durch
Zahlen markiert, aufgeteilt. Im Bereich 1 befindet sich der „Home“-Button, mit diesem gelangt man
sofort zur Startseite. „Webverbindung“ und „Daten Importiert“ sind Statusanzeigen, die durch Data-
Bindings (siehe Abschnitt 6.2) realisiert wurden. Der 2. Bereich ermöglicht eine Vor- und Zurück-
navigation, wie es z.B. in der Verzeichnis-Anzeige von Windows möglich ist. Im 3. Bereich werden
Statusinformationen, die durch die USB-Kommunikation vom Slave oder Master eingehen, angezeigt.
Der 4. Bereich ist ein „Frame“ (siehe Abschnitt 6.2.3), in diesem werden die entsprechenden Pages
angezeigt.
Abbildung 33: Data-Receiver
Abbildung 34 zeigt ein Klassendiagramm der PC-Applikation. In der Dokumentation werden nicht alle
einzelnen Pages genau erläutert, der Grundaufbau einer Page ist jedoch im Abschnitt 6.2
beschrieben.
34
Abbildung 34: Klassendiagramm
6.5 Anpassungen der Funktionen des Data-Receivers 1.0
Die Version 1.0 des Data-Receivers bietet bereits einige Funktionen, die übernommen werden
können. In Tabelle 7 werden die Funktionen kurz aufgelistet.
Kurzbeschreibung Beschreibung
USB-Verbindung Der Datenaustausch zwischen Master/Slave und PC-Applikation findet über USB statt. Für die USB-Kommunikation wurde eine fertige Bibliothek übernommen.
Einlesen der Ergebnisse über USB
Die im Flash-Speicher der MCU gespeicherten Ergebnisse können über USB auf die PC-Applikation übertragen werden
Speicherung der Ergebnisse
Die eingelesenen Ergebnisse werden in einer vorher bestimmten CSV-Datei gesichert.
Kommunikation mit Systemkomponenten
Den Systemkomponenten können über die USB-Verbindung Kommandos geschickt werden.
Tabelle 7: Grundfunktionen der PC-Applikation
Die Funktionen werden in der Bachelorarbeit [2] im Abschnitt „6.2 Windows-Applikation“ beginnend
auf der Seite 46 erläutert. Die meisten Funktionen konnte in den Hintergrundcode der WPF-
Anwendung übernommen werden, sodass die Funktionsweise identisch geblieben ist. Teilweise
mussten beim Programmcode kleine Umstrukturierungen vorgenommen werden, die in diesem
Abschnitt noch erläutert werden.
35
6.5.1 Auslagerung der USB-Kommunikation
Die USB-Verbindung wurde in eine eigene Klasse mit dem Namen „ClassConnectUSB“ ausgelagert.
Diese bietet z.B. mit der Methode „sendData“ die Möglichkeit, den Komponenten einen Befehl zu
senden. In Abbildung 35 wird von dem Objekt „usb“ (ist ein Objekt der Klasse ClassConnectUsb) die
Methode sendData() mit dem Parameter „DEL“ aufgerufen. Abbildung 36 zeigt den Quellcode der
Methode, die aufgerufen wird. Der Parameter wird für die Übertragung in ein „Byte“-Format
gewandelt und anschließend durch „usb.Connection.write()“ über USB an die Komponente
versendet. Zudem wurde die Methode „myEventCacher“ in der WPF-Anwendung in
„USBEventCacher“ umbenannt.
Abbildung 35: Flash löschen
Abbildung 36: USB Daten senden
6.5.2 Modifikation der Ausgabe
Die Ergebnisse werden wie in der Bachelorarbeit [2] über ein Datagrid ausgegeben. In der neuen
Software gibt es zwei Pages für die Ausgabe über ein Datagrid. Eine Seite wird für die Ausgabe der
importierten Teilnehmerliste genutzt (DataGrid). Die zweite wird beim Auslesen des Flash-Speichers
und in einer Live-Session genutzt (DataGridOutput). In der neuen Software kann die Anzahl der
Spalten und deren Inhalt variieren. Dafür bedarf es mehrere Anpassungen. Die nun aufgezeigten
Änderungen betreffen beide Pages. In der alten Version des Data-Receivers wurden die Zeilen einzeln
aus der Datei gelesen und dann in eine Tabelle gespeichert. In der neuen Version wird die Datei
komplett ausgelesen und in ein verzweigtes Array [7]21 gespeichert. Abbildung 37 zeigt die Methode
„splitData()“, die die Datei in ein verzweigtes Array speichert.
21
http://openbook.galileocomputing.de/visual_csharp_2010/visual_csharp_2010_02_005.htm Kapitel 2.5.8
36
Abbildung 37: Methode SplitData
Durch die Speicherung in ein verzweigtes Array ist eine Verarbeitung der Daten leicht möglich.
Abbildung 38 zeigt die Methode testInt(), diese durchläuft alle Zeilen einer Spalte (die im Array
gespeichert sind) und überprüft, ob der Inhalt einen Integer22-Wert entspricht. Sind in einer Spalte
nur Integer-Werte, wird diese als Integer-Spalte angelegt. In allen anderen Fällen sind die Spalten mit
String-Werten gefüllt.
22
Datentyp der ganzzahlige Werte speichert
37
Abbildung 38: Zellen auf Inhalt überprüfen
Die Speicherung der Tabelle in ein Array ermöglicht es, mit relativ geringem Aufwand eine Suche zu
implementieren. Die Methode „compareData(string)“ vereint zwei Funktionen. Zum einen wird durch
einen Algorithmus in dem verzweigten Array nach dem String, der als Parameter übergeben wurde,
gesucht und zum anderen dient die Methode dazu, die Ausgabe zu aktualisieren. Die Ausgabe wird
aktualisiert, sofern ein leerer String als Paramater übergeben wurde. Abbildung 39 zeigt den
Algorithmus, der die Tabelle durchsucht. In der Variablen „takeNameCell[]“ werden die
Zeilennummern gesichert, die als Suchergebnisse ausgegeben werden müssen. Die Ausgabe über das
Datagrid wird durch eine Daten-Tabelle realisiert. In jedem Objekt gibt es zwei Tabellen, eine für die
Ausgabe der Gesamtergebnisse und eine weitere für die Suchergebnisse. Sollte eine Suche
durchgeführt worden sein, wird die Such-Tabelle angezeigt, andernfalls die Standard-Tabelle.
38
Abbildung 39: Tabelle durchsuchen
6.6 Live-Session
Im Abschnitt 5 wurden bereits alle Vorkehrungen bzgl. des Slaves für die Live-Session vorgenommen.
Als OP-Code für die USB-Kommunikation wurde „RTD“ definiert. Empfängt die PC-Applikation einen
USB-Datensatz mit dem OP-Code „RTD“, müssen die Datensätze in eine CSV-Datei gespeichert und
die Ausgabe der Ergebnisse in der PC-Applikation aktualisiert werden.
Nachdem eine USB-Verbindung zu einer Komponente hergestellt wurde, kann eine Live-Session
gestartet werden. Abbildung 40 zeigt einen Ausschnitt der Benutzeroberfläche, nachdem eine USB-
Verbindung hergestellt wurde. Wird eine Live-Session gestartet, wird dies in einer Variablen
gesichert.
39
Abbildung 40: Live-Session starten
In Abbildung 41 ist ein Ausschnitt des Quellcodes der Klasse „ClassConnectUSB.cs“ in der Methode
„public void USBEventCacher()“ zu sehen. In dem String „strCheckSum“ befindet sich der Inhalt der
USB-Übertragung. In der IF-Abfrage wird überprüft, ob der OP-Code „RTD“ entspricht. Sollte dies der
Fall sein, wird der Datensatz in dem String „strData“ gesichert. Durch einen regulären Ausdruck
werden alle Zeichen gelöscht, die in einem RFID-Tag nicht vorkommen. Die Methode compareData()
speichert die Daten in eine CSV-Datei, der genaue Ablauf wird im Abschnitt 6.8 erläutert.
Abbildung 41: Eingang von Echtzeitdatensätze überprüfen
Befindet sich die Applikation ein einer Live-Session, muss die Ausgabe der Ergebnisse automatisch
aktualisiert werden. Die Ergebnisse werden wie in der Bachelorarbeit [2] über ein Datagrid
ausgegeben. Abbildung 42 zeigt aus der Methode „compareData()“ eine IF-Abfrage, die die Ausgabe
aktualisiert, sofern es sich um einen Live-Datensatz handelt.
Abbildung 42: Aktualisiere die Ausgabe
40
6.7 Teilnehmerliste importieren
Die Resultate des Wettkampfs sollen online für die Öffentlichkeit bereitgestellt werden. In der
momentanen Konfiguration ist nur die Ausgabe des RFID-Tags und der erreichten Zeit vorgesehen.
Eine Ausgabe in dieser Form ist jedoch für das Publikum ungeeignet. In der Projektarbeit „Windows
basierte RFID-Tag Erfassung mit C#“ [4] wurde eine Software erstellt, die den Namen eines
Schwimmers einem RFID-Tag zuweist. Diese Teilnehmerliste wird in einer CSV-Datei gespeichert und
ermöglicht so die Weiternutzung.
Die ausgewählte Datei wird in der Klasse „DataGrid()“ in der Methode „split()“ in ein verzweigtes
Array gesichert. Das Array wird zudem in der Klasse „ClassGlobalPath“ in dem Array „allData“
gespeichert. Durch die Speicherung des Arrays in die statische Klasse kann jedes Objekt auf diesen
Datensatz zugreifen. Das Array wird in eine Data-Tabelle geschrieben und anschließend über ein
DataGrid ausgegeben. Bei der Ausgabe der importierten Teilnehmerliste wird noch eine weitere Zeile
hinzugefügt. Abbildung 43 zeigt die PC-Applikation mit importierter Teilnehmerliste. Die schwarz
umrandete Zeile ist die zusätzlich hinzugefügte Nummerierung der Spalten.
Abbildung 43: Importierte Datei mit Spaltennummern
Abbildung 44 zeigt ein weiteres Fenster, das sich öffnet, sobald eine Datei importiert wird. Unter 1.
wird bestimmt, in welchen Spalten der Tabelle sich der Vorname, Nachname, RFID-Tag und die Zeit
befindet. Im 2. Bereich wird festgelegt, welche Spalten die PC-Applikation bei der Erzeugung einer
CSV-Datei anlegt.
41
Abbildung 44: Auswahl der Spalten
Bevor die Spalten im 2. Bereich in einer statischen Variablen gespeichert werden, wird der Inhalt
überprüft. Zum einen wird getestet, ob der angegebene Wert einem Integer-Wert entspricht und
zum anderen, ob die Spalte existiert. Die Überprüfung findet in der Methode „checkTake()“ statt. Es
können mehrere Spalten angegeben werden. Als Delimiter ist das normale Kommata („,“) definiert.
Zusätzlich kann mit dem Keywort „alle“ bestimmt werden, dass alle Spalten übernommen werden.
Bei einer Eingabe von z.B. „3-5“ werden die Spalten 3, 4 und 5 übernommen. Der Algorithmus, der
die Spalten auswählt, befindet sich ebenfalls in der Methode „checkTake()“. Abbildung 45 zeigt den
Algorithmus, der aus einem String mit dem Inhalt von z.B.: „1,4-6,8“ in 1,4,5,6,8 umformt. Die
Umformung von 4-6 wird durch ein Teilen des Strings durchgeführt. Als Delimiter dient der
Bindestrich, dadurch wird die 4 in das String-Array cmp2[0] und die 6 in das String-Array cmp2[1]
gespeichert, dies ist unter 1. In der Abbildung 45 zu sehen. Im 2. Bereich werden die Zahlen, in
diesem Fall mit der Zahl 5, vervollständigt. In einer Schleife wird eine Variable mit der Anfangszahl (4)
addiert und solange hochgezählt bis die Anfangszahl addiert mit der Zählvariablen die Endzahl (6)
erreicht hat.
42
Abbildung 45: Algorithmus der Spaltenübernahme
6.8 RFID-Tag einem Namen zuweisen
Durch das Importieren einer Teilnehmerliste können die vom RFID-Tag-Lesegerät erhaltenen RFID-
Tags einer entsprechenden Zeile der Teilnehmerliste zugeordnet werden. In einer Zeile können
weitere Informationen wie z.B. der Name des Schwimmers stehen. Im Abschnitt 6.7 wurde das
Importieren der Teilnehmerliste erläutert. Die Daten werden global gesichert und können von allen
Objekten der PC-Applikation genutzt werden.
Werden über die USB-Verbindung Datensätze eingelesen, muss zuvor eine Datei zum Speichern der
Ergebnisse festgelegt worden sein. Sollte dies nicht der Fall sein, werden die Datensätze nicht
abgespeichert. In dieser Datei werden nach der Verarbeitung, die im Folgenden beschrieben wird,
die Ergebnisse gespeichert.
Wird über die USB-Kommunikation ein neuer Datensatz übertragen, wird die Teilnehmerliste nach
dem einkommenden RFID-Tag durchsucht. Dabei werden nur die Spalten durchsucht, die der
Benutzer beim importieren der Teilnehmerliste als RFID-Tag-Spalten gekennzeichnet hat. In der
Methode „compareData(String str, bool rtd)“, die sich in der Klasse „ClassConnectUSB“ befindet, wird
das globale Array „allData“ (in dem die Teilnehmerliste gespeichert ist) nach dem einkommenden
RFID-Tag durchsucht. Konnte ein RFID-Tag einem Teilnehmer zugeordnet werden, wird anschließend
43
in der Methode „createString(string[] _build, string str, string[] cmp)“ ein String zusammengefügt.
Der erstellte String enthält alle Spalten, die vorher vom Benutzer festgelegt wurden und speichert
diese in die CSV-Datei. Abbildung 46 zeigt ein auf das wesentliche gekürzte Struktogramm der
Methode CompareData.
Abbildung 46: Struktogramm CompareData
Wurde keine Teilnehmerliste importiert, werden standardmäßig der RFID-Tag und der Zeitstempel in
die Datei geschrieben. Sofern keine Spalte für die Zeitmessung in der Teilnehmerliste vorgegeben
wurde, wird automatisch eine Spalte mit den Zeitmessungen hinzugefügt.
6.9 Daten zum Webserver senden
Dem Publikum soll ermöglicht werden, die Wettkampfergebnisse auf einem mit dem Internet
verbundenen Endgerät zu verfolgen. Für die Umsetzung muss eine Schnittstelle programmiert
werden, mit der die Daten auf einem Webserver hochgeladen werden können. Im Abschnitt 7 wird
auf die Implementierung des Webservers eingegangen. In diesem Abschnitt wird die Übertragung der
Daten von der PC-Applikation zum Webserver behandelt.
In der PC-Applikation sind für die Umsetzung ein neues Fenster, zwei Pages und zwei weitere Klassen
programmiert worden. Das neue Fenster hat den Namen „WindowAdminPW“ und öffnet sich nur,
wenn ein neuer User-Account erstellt werden soll. In Tabelle 8 werden kurz die Pages und in Tabelle
9 die Klassen vorgestellt.
Page Kurzbeschreibung
WebOption Ermöglicht das Einloggen in einem bestehenden Account. WebOptionCreate Legt einen neuen User-Account an. Desweiteren werden hier die LOG-
In-Daten für die MySQL-Datenbank eingetragen. Tabelle 8: Pages für die Web-Verbindung
44
Klasse Kurzbeschreibung
ClassConnectWeb Stellt einen Web-Request zur Verfügung. Mit diesem werden die Daten an den Webserver gesendet.
ClassStaticWebOptions In dieser Klasse werden die Daten gespeichert, die der Anwender über die Pages festgelegt hat.
Tabelle 9: Klassen für die Web-Verbindung
Für die Verbindung zum Internet sind vor allem die Page „WebOptionCreate“ und die Klasse
„ClassConnectWebOptions“ wichtig. Diese werden in Abschnitten 6.9.1 und 6.9.2 genauer erläutert.
6.9.1 Page WebOptionCreate
Bevor die PC-Software die Daten an den Webserver versenden kann, muss über die PC-Software der
Webserver eingerichtet werden. Abbildung 47 zeigt die PC-Software mit aufgerufener
WebOptionCreate-Page. Unter dem Punkt „Webseite“ wird die Adresse der Internetseite, auf dem
die Daten gespeichert werden sollen, angegeben. Im Zweig „Benutzer erzeugen“ wird ein neuer User-
Name sowie ein Passwort festgelegt. Mit diesem ist ein späteres einloggen unter der Page
„ClassConnectWeb“ möglich. Im Bereich „Neue Datenbank einrichten“ werden die Informationen,
die für das Einloggen in die Datenbank benötigt werden, eingetragen. Alle Daten werden in der
Klasse ClassStaticWebOptions gespeichert und können so von anderen Objekten genutzt werden.
Abbildung 47: Webserver einrichten
Das Passwort eines Benutzers wird, bevor es gespeichert wird, durch einen MD523-Hashwert ersetzt.
C# bietet dafür bereits eine Funktion an, die unter MSDN [6]24 dokumentiert ist. Mit diesem
23
Message-Digest Algorithm, erstellt einen 128-Bit-Hashwert 24
http://msdn.microsoft.com/de-de/library/system.security.cryptography.md5.aspx
45
Hashwert wird in der Software weiter gearbeitet. Das Passwort im Klartext wird somit nicht mehr
benötigt. In der Abbildung 48 ist die Methode zu sehen, die aus einem String einen MD5-Hashtag-
Wert generiert, dieser wird anschließend als String zurückgegeben. Wurde eine Teilnehmerliste
importiert, von denen Spalten zur Übernahme ausgewählt wurden (siehe Abschnitt 6.7), werden
diese Spalten auch in der MySQL-Datenbank angelegt.
Abbildung 48: Erzeugung eines MD5-Hashtags
Die angegebenen Daten werden anschließend über ein Web-Request an den Webserver gesendet. Im
nachfolgenden Abschnitt (6.9.2) wird die Übertragung per Web-Request erläutert.
6.9.2 Übertragung der Daten zum Webserver
In der Klasse „ClassConnectWeb“ werden die Daten über ein Web-Request an den Webserver
gesendet. Unter MSDN [6]25 ist die WebRequest-Klasse dokumentiert, zudem wird hier ein Beispiel
für die Einbindung gegeben. Die Klasse „ClassConnectWeb“ besitzt drei Methoden, diese werden in
der Tabelle 10 aufgezeigt.
Methode Kurzbeschreibung
sendLoginData An diese Methode werden die Daten übergeben, die an den Webserver gesendet werden sollen.
sendDatabase Versendet über einen Web-Request die Ergebnisse des Wettkampfes. sendLogin Versendet über einen Web-Request die Daten, die auf der Page
ClassStaticWebOptions definiert wurden. Tabelle 10: Methoden der Klasse ClassConnectWeb
Den Vorgang eines Web-Requests der Methode sendLogin wird in dem Abschnitt 6.9.2.1 genauer
erläutert.
25
http://msdn.microsoft.com/de-de/library/system.net.webrequest.aspx
46
6.9.2.1 Implementierung eines Web-Request
Bei der Implementierung wurde sich an dem Beispiel von MSDN gehalten, dieses wurde den
entsprechenden Anforderungen angepasst. Abbildung 49 zeigt einen Ausschnitt aus dem
Programmcode der Methode sendLogin. Dabei handelt es sich, wie unter 1. zu sehen, um einen Web-
Request. Übergeben wird die Webseiten-Adresse, die mit „/konfiguration.php“ erweitert wird. Dies
ist eine PHP-Seite, die in dieser Bachelorarbeit geschrieben wurde, eine Erläuterung hierzu folgt im
Abschnitt 7.4.1. Unter 2. wird die Art der Übertragung gewählt, in diesem Fall handelt es sich um
einen „POST26“-Request. Im 3. Bereich wird ein String erzeugt, der anschließend über ein „POST“-
Request übertragen wird. Nach erfolgter Übertragung wird die Antwort des PHP-Skriptes in die
Variable „responseFromServer“ gespeichert, dies ist im 4. Bereich zu sehen.
Abbildung 49: Programmcode Web-Request
Die Antwort des Servers wird als String gespeichert und kann anschließend ausgewertet werden.
Abbildung 50 zeigt eine Abfrage der Variable, dabei wird überprüft ob das Einloggen oder das
Erstellen eines neuen Benutzer-Accounts erfolgreich war.
26
http://php.net/manual/de/reserved.variables.post.php, wird im HTTP-Header übertragen
47
Abbildung 50: Auswertung der Antwort vom Server
6.9.2.2 Datensätze im eigenen Thread27 versenden
Das Versenden der Datensätze geschieht in der Klasse „ClassConnectWeb“, deren Funktion im
vorherigen Abschnitt (6.9.2.1) erläutert wurde. Dieser Abschnitt behandelt den Aufruf dieser Klasse.
Zum Versenden der Daten wird für jeden Datensatz ein neues Objekt der Klasse „ClassConnectWeb“
erzeugt. Die Datensätze werden, nachdem sie in eine CSV-Datei geschrieben wurden, durch die
Methode „sendDatabase“ der Klasse „ClassConnectWeb“ versendet. Der Aufruf geschieht in der
Methode „compareData“ der Klasse „ClassConnectUSB“, die bereits im Abschnitt 6.8 beschrieben
wurde. Für die Web-Übertragung wurde die Methode „compareData“ um eine IF-Abfrage erweitert.
Abbildung 51 zeigt die erweiterte Methode „compareData“ in Form eines Struktogramms.
Abbildung 51: Struktogramm von CompareData mit Web-Übertragung
Während der Entwicklungszeit zeigte sich, dass das Warten auf eine Antwort vom Webserver die PC-
Applikation „einfrieren“ lassen kann. Der Web-Request wurde zu Beginn der Entwicklung im Haupt-
Thread durchgeführt, in diesem wurde dann auf die Antwort des Webservers gewartet. Während des
Wartens wurde das Programm blockiert und es waren keine weiteren Aktionen mehr möglich. Um
dieses Problem zu umgehen, wird nun für jeden Datensatz, der verschickt wird, ein neuer Thread
27
In einem Thread wird der Programmcode abgearbeitet
48
erstellt. Abbildung 52 zeigt den Programmcode, in dem ein neuer Thread erstellt wird. Im
umrahmten Bereich wird aus dem Objekt „Web[webThreadNumber].sendDatabase“ ein Thread
erstellt und anschließend gestartet. Der Thread startet dabei in der Methode „sendDatabase“ des
Objekts. Bei der Erstellung eines Threads können dem Objekt keine Parameter übergeben werden.
Um dem Objekt die Daten übergeben zu können, werden diese, bevor der Thread erstellt wird, über
die Methode „sendLoginData“ in dem Objekt gespeichert. Anschließend wird der Thread gestartet,
dieser kann nun auf die in dem Objekt gespeicherten Daten zugreifen. Der Thread arbeitet im
Hintergrund den Web-Request ab und blockiert somit den Haupt-Thread nicht mehr.
Abbildung 52: Erstellung der Threads
49
7 Software auf dem Webserver
Die Daten, die von der PC-Software zum Webserver versendet werden, müssen in eine Datenbank
eingepflegt werden. Über eine Webseite sollen die Daten für das Publikum abrufbar sein.
7.1 Arbeitsumgebung
Als Entwicklungsumgebung wurde Aptana Studio 3 [8] genutzt. Die Entwicklungsumgebung ist für die
Programmierung von Web-Anwendungen optimiert. Als besonders vorteilhaft und komfortabel
zeigte sich das Einbinden des genutzten Webservers, dadurch konnte die entwickelte Software direkt
aus der Entwicklungsumgebung mit dem Webserver synchronisiert werden. Als Webserver wurde für
die Entwicklung mein persönlicher Home-Server genutzt. Dieser war durch die Nutzung eines
DynDNS28-Anbieters aus dem Internet zu erreichen. Als Webserver kam Apache2 [9] mit PHP5 zum
Einsatz, zudem lief MySQL [10] und PHPMyAdmin [11] auf dem Server.
7.2 Einführung in PHP und MySQL
PHP [12] steht für „Hypertext Preprocessor“ und ist eine weitverbreitete Skriptsprache in der
Webprogrammierung. Im Internet ist ein PHP-Handbuch [12] in diversen Sprachen kostenlos
zugängig. Als Datenbank wurde MySQL genutzt, dabei dient PHP als Schnittstelle. In diesem Abschnitt
werden grundlegende Funktionen, die in dieser Bachelorarbeit angewendet wurden, erläutert.
7.2.1 Variablen und Strings in PHP
In PHP werden Variablen durch ein Dollar-Zeichen gekennzeichnet. Anders als in anderen
Programmiersprachen werden die Variablen in PHP nicht deklariert. Strings werden in PHP durch
Punkte verbunden. Ist z.B. der String: „'CREATE DATABASE IF NOT EXISTS '.$datenbank.';'“ gegeben,
wird der Inhalt aus der Variablen $datenbank mit dem restlichen String verbunden. Hat die Variable
den Inhalt „Test“, ergibt das einen Gesamstring von: „'CREATE DATABASE IF NOT EXISTS Test;'“. Mit
„define“ werden in PHP Konstanten definiert, die Erzeugung einer Konstanten geschieht durch
„define ('PathLogInData', 'logindata.php');“. Wird im PHP-Code die Konstante „PathLoginData“
aufgerufen, enthält diese den String „logindata.php“.
28
Dynamic Domain Name System
50
7.2.2 Empfangen von Daten
In der PC-Applikation werden die Daten über einen Web-Request mittels „POST“29 an dem
Webserver geschickt. Auf dem Webserver liegt ein PHP-Skript, das nun aufgerufen wird und die
Daten verarbeitet. In der Abbildung 53 ist ein Teil vom Programmcode der Datei „konfiguration.php“
zu sehen. In diesem wird überprüft, ob „$_POST['data']“ den String „LogIn“ enthält. „$_POST ['data']“
wird von der PC-Applikation über den http-Header an das PHP-Skript übergeben. Dabei steht
„$_POST“ für den Typ der Variablen und 'data' ist der spezifische Name, der einen Wert enthält.
Abbildung 53: PHP $_POST
7.2.3 Daten in die Datenbank schreiben
Die Anbindung an die MySQL-Datenbank wird durch PHP-Skripte realisiert. Für den Zugriff auf die
MySQL-Datenbank wird unter PHP auf MySQLi [12]30 zurückgegriffen. In Abbildung 54 ist zusehen,
wie im 1. Bereich über MySQLi eine Verbindung zur Datenbank aufgebaut wird. Anschließend wird im
2. Bereich ein SQL-Befehl: „CREATE DATABASE IF NOT EXISTS '.$datenbank.';'“ in die Variable $sql
gespeichert. Mit diesem Befehl wird eine neue Datenbank, sofern diese noch nicht existiert,
angelegt. Ausgeführt wird der Befehl jedoch erst in der nächsten Zeile durch den Aufruf von
„mysqli_query($db_link, $sql)“.
Abbildung 54: MySQLi Beispiel
7.3 Aufbau des Websystems
Damit nicht jeder beliebige Internetnutzer auf die Datenbank zugreifen kann, ist der Zugriff auf die
PHP-Skripte durch ein Passwort geschützt. Dabei wurde ein System mit zwei verschiedenen
Zugriffsarten entwickelt. Zum einen besteht die Möglichkeit, mit einem Admin-Passwort einen User-
Account zu erstellen, zum anderen ist das Einloggen mit einem bestehenden User-Account möglich.
Bei der Erstellung eines User-Accounts werden gleichzeitig die Daten für den Zugriff auf die
29
http://php.net/manual/de/reserved.variables.post.php 30
http://www.php.net/manual/de/intro.mysqli.php
51
Datenbank und die Eigenschaften der Wettkampf-Tabelle festgelegt. Mit einem User-Account
können lediglich neue Datensätze in eine bestehende Datenbank eingetragen werden.
7.4 PHP-Skripte
Um die geforderte Aufgabe zu erfüllen, kommen mehrere PHP-Skripte zum Einsatz. Die entwickelten
PHP-Skripte werden in der Tabelle 11 vorgestellt. Die Skripte konfiguration.php, rest.php, output.php
und refresh.php werden in diesem Abschnitt genauer erläutert. Die restlichen Skripte werden nur zur
Speicherung genutzt und besitzen keine über die in der Tabelle 11 beschriebenen hinausgehenden
Funktionen.
Skript Kurzbeschreibung
konfiguration Dieses PHP-Skript wird aufgerufen, wenn in der PC-Applikation ein neuer Account erstellt wird oder sich in einen bestehenden Account eingeloggt wird.
rest Werden von der PC-Applikation neue Datensätze verschickt, werden diese in Rest.php verarbeitet und in die MySQL-Datenbank geschrieben.
output und refresh Dient zur Ausgabe der Ergebnisse auf eine Webseite, die in einem Browser aufgerufen werden kann.
pathlink In dieser Datei wird angegeben, unter welchen Pfaden sich die Dateien AdminPW, logindata und mysqlconfig befinden.
AdminPW Hier wird ein Passwort bestimmt, nur mit diesem Passwort ist es später möglich, über die PC-Software einen neuen Account zu erstellen.
logindata Dient zur Speicherung des angelegten User-Accounts, in diesem Account kann sich dann immer wieder eingeloggt werden.
mysqlconfig In mysqlconfig werden die Log-In-Daten für die Datenbank hinterlegt. Tabelle 11: PHP-Skripte
7.4.1 konfiguration.php
Wird in der PC-Applikation eine Verbindung zum Webserver hergestellt, ruft diese über einen Web-
Request das Skript konfiguration (siehe Abschnitt 6.9.2.1) auf. Durch die „POST“-Variablen können
die Daten, die von der PC-Applikation verschickt wurden, in dem PHP-Skript verarbeitet werden. Das
Konfiguration-Skript ermöglicht das Einloggen in einen bestehenden User-Account oder das Erzeugen
eines neuen User-Accounts. Abbildung 55 zeigt den Teil des Skripts, in dem ein Log-In in einen
bestehenden User-Account durchgeführt wird. Mit „require_once()“ werden die PHP-Skripte, in
denen die Log-In-Daten gespeichert sind, in das Konfigurations-Skript eingebunden. In dem Skript
wird überprüft, ob Log-In-Daten korrekt sind, je nach Auswertung wird über „echo“ ein String
ausgegeben. In der PC-Applikation wird dieser String anschließend ausgegeben und ausgewertet.
52
Abbildung 55: Log-In in einen bestehenden Account
Die Erzeugung eines neuen User-Accounts ist nur mit dem Admin-Passwort möglich. Bei der
Erstellung eines neuen User-Accounts werden die Skripte mysqlconfig.php und logindata.php erstellt.
In Tabelle 12 wird gezeigt, welche Informationen in den Skripten gespeichert werden.
Skript Kurzbeschreibung
mysqlconfig Für die MySQL-Datenbank werden die Log-In-Daten, die Adresse der Datenbank, der Datenbankname, der Tabellenname und die Namen der einzelnen Spalten in das Skript „mysqlconfig“ als Konstante geschrieben.
logindata In logindata wird der User-Account, bestehend aus einem Benutzername und einem Passwort, gespeichert.
Tabelle 12: Erzeugen eines neuen User-Accounts
Um die Daten zu speichern, wird eine neue PHP-Datei erstellt oder eine bestehende PHP-Datei
genutzt. In diese Datei werden die Daten, die von der PC-Software übertragen wurden, in Konstanten
gespeichert. Diese Dateien können durch die „require_once()“-Funktionen in andere PHP-Skripte
eingebunden werden, somit ist eine Nutzung der gespeicherten Konstanten in einem anderen Skript
möglich. Abbildung 56 zeigt, wie ein String erzeugt wird und anschließend in eine Datei geschrieben
wird. Bei diesem String werden die Daten für die MySQL-Datenbank gespeichert. Durch
„fopen(PathMySQLConfig,“w+“);“ wird eine Datei geöffnet, in der anschließend durch
„fwrite()$datei, $svelogin);“ der String geschrieben wird. Dabei wird der alte Inhalt der Datei
überschrieben. War die Erstellung eines neues User-Accounts erfolgreich, werden die angelegten
Spalten und der String: „Account erstellt und eingeloggt“ ausgegeben.
53
Abbildung 56: String in eine Datei speichern
7.4.2 rest.php
Die Datensätze mit den Resultaten des Wettkampfes werden durch das Skript rest.php in die
Datenbank eingepflegt. Die PC-Applikation schickt bei einer Übertragung einen Datensatz und die
User-Account-Daten. Ist der User-Account inkorrekt, werden die Datensätze nicht angenommen. Die
Log-In-Daten für die MySQL-Datenbank werden aus der Datei „mysqlconfig.php“ entnommen.
Zur Abspeicherung der Datensätze in die Datenbank wird ein MySQLi-Befehl genutzt. Die Datensätze
und die Tabellen liegen in Form eines Strings vor und müssen, bevor sie abgespeichert werden,
getrennt werden. Die Strings werden durch den Aufruf von „explode“ getrennt. In der Abbildung 57
ist unter 1. zu sehen, wie die einzelnen Spalten und Datensätze in String-Arrays gespeichert werden.
Mit den Arrays werden im 2. Bereich Strings zusammenbaut, die für den MySQL-Befehl benötigt
werden. Im 3. Bereich wird der MySQL-Befehl erstellt und anschließend ausgeführt. Durch den Befehl
wird in einer Tabelle eine neue Zeile angelegt. Die Spalten „$addtoCoulumns“ erhalten dabei die
entsprechenden Werte von „$addData“.
54
Abbildung 57: Hinzufügen neuer Datensätze
7.4.3 output.php und refresh.php
Die Skripte output.php und refresh.php werden nicht von der PC-Software aufgerufen, sondern
dienen zur Ausgabe der Wettkampfergebnisse in einem Webbrowser. In der Abbildung 58 ist
exemplarisch eine Ausgabe über den Webbrowser zu sehen.
55
Abbildung 58: Ausgabe im Webbrowser
Im Webbrowser wird die Ausgabe durch den Aufruf von output.php realisiert, folgende Adresse wäre
z.B. möglich: „http://Webseite.de/output.php“. In output.php wird durch ein JavaScript der Inhalt
des Skriptes refresh.php alle fünf Sekunden neu aufgerufen und angezeigt.
Für JavaScript wurde jquerry [13] als libary31 genutzt. Die libary wurde nicht auf dem Server
gespeichert, sondern wurde lediglich von einem Google-Server eingebunden. Die Funktionsweise
wurde aus einem Tutorial von tfonfara.de [14] übernommen. In Abbildung 59 ist die Einbindung von
dem JavaScript zu sehen.
Abbildung 59: Einbindung von JavaScript
Zudem verfügt die output.php noch über eine Suchfunktion, der Suchbegriff wird durch einen
„POST“-Request an den Webserver gesendet. Die Abarbeitung der Suche geschieht auf dem Skript
refresh.php. Die Daten aus der MySQL-Datenbank werden in einer html-Tabelle ausgegeben. In der
Abbildung 60 ist der Quellcode zu sehen, der die Tabelle erzeugt. Zuerst werden die Spalten erzeugt,
anschließend werden die Spalten mit den Werten aus der MySQL-Datenbank gefüllt.
31
Bibliothek
56
Abbildung 60: Erzeugung der Ausgabe für den Browser
Soll eine Suche durchgeführt werden, wird die MySQL-Datenbank mit dem Befehl: "SELECT * FROM
".MYSQL_TABELLE." WHERE ".$columns.";" durchsucht. Wird der Suchbegriff in einer Spalte
gefunden, wird die zugehörige Zeile im Browser ausgegeben.
57
8 Fehlersuche, Tests und Verbesserungsmöglichkeiten
Die Fehlersuche teilt sich in zwei Abschnitten auf. Im Abschnitt 8.1 sind Fehler dokumentiert, die
durch die Inbetriebnahme der übernommenen System-Komponenten gefunden wurden. Die
Fehlersuche in der in dieser Bachelorarbeit entwickelten Software ist im Abschnitt 8.2 dokumentiert.
8.1 Fehlersuche im übernommenen System
In den verschiedenen Komponenten des Systems konnten mehrere Fehler entdeckt und teilweise
behoben werden, diese werden in der Tabelle 13 kurz aufgezeigt.
Komponente Kurzbeschreibung Fehler
RFID-Tag-Zeitmesssystem
Fehler bei der UART-Übertragung
Bei der UART-Übertragung wurde beim Start ein Zeichen zu viel übertragen, Fehler konnte behoben werden (siehe Abschnitt 8.1.1).
RFID-Tag-Zeitmesssystem
Wackelkontakt Ein Wackelkontakt führt zum Ausfall von der UART-Übertragung von der Antenne zum Zeitmesssystem. Zudem entstehen durch diesen Wackelkontakt die „Phantommessungen“, die in der Bachelorarbeit [3] dokumentiert sind. Fehler konnte nicht behoben werden.
Slave Fehlerhafter Handshake
Der Handschake zwischen PC und Slave war nicht funktionstüchtig. Fehler konnte behoben werden (siehe Abschnitt 8.1.2).
Master Fehlerhafter Handshake
Der Handshake zwischen Master und dem Zeitmesssystem war im Master nicht implementiert. Fehler konnte behoben werden (siehe Abschnitt 8.1.3).
Tabelle 13: Fehler in den übernommenen Komponenten
8.1.1 Fehler bei der UART-Übertragung
In der Testphase wurde beim Auslesen der Daten über den Slave ein Fehler entdeckt. Nach dem
Starten einer Zeitmessung (Nachstart) hat der darauffolgende Messwert nur noch einen sechs-
stelligen Zeitwert, anstelle von sieben Stellen. Um den Fehler einzugrenzen, wurden einige Tests
durchgeführt. Begonnen wurde mit dem Auslesen der Daten vom Master, hier kam es zu den
gleichen Fehlern, womit ein Fehler bei der ZigBee-Übertragung und dem Slave ausgeschlossen
werden konnte. Der Fehlerbereich konnte somit auf den Master, das RFID-Tag-Lesegerät und die PC-
Software eingegrenzt werden. Um den Fehler zu bestimmen, wurde eine Testreihe durchgeführt.
58
Die Tests zeigten auf, dass nach jedem Nachstart der Zeitwert um eine Stelle zu kurz war. Somit
konnte ausgeschlossen werden, dass es sich um zufällige Fehler handelt. Als nächsten Schritt wurde
überprüft, welche Datensätze das RFID-Tag-Lesegerät via UART überträgt. Dafür wurde der Ausgang
des RFID-Tag-Lesegeräts an einem PC mit einer RS232 Schnittstelle angeschlossen. Am PC konnten
die Übertragungen Datensätze betrachtet werden. Dabei kam zum Vorschein, dass nach jedem
„Nachstart“ eine „new Line“ übertragen wurde. Dadurch konnte als Fehlerquelle das RFID-Tag-
Lesegerät ausgemacht werden. Um die Fehlerursache identifizieren zu können, wurde die Software
des RFID-Tag-Lesegeräts näher untersucht. Diese ist in C++ geschrieben und läuft auf einem Arduino-
Board .
Der gefundene Fehler, war sehr simpel, hatte jedoch große Auswirkungen. Bei einem Nachstart
wurden die Daten mit: „altSerial.println((char*)) fertig_daten;“ über UART übertragen. Dies hat zur
Folge, dass zusätzlich noch einen Zeilenumbruch über UART übertragen wurde. Dadurch war die
Übertragung 1 Byte länger als es die Verarbeitung in der Master-Software vorgesehen hat. Der Fehler
konnte einfach durch die Verwendung von „altSerial.print((char*)) fertig_daten;“ gelöst werden.
8.1.2 Fehlerhafter Handshake beim Slave
Der Slave führt über die USB-Verbindung mit der PC-Applikation einen Handshake durch. Bei der
Entwicklung der neuen Software ist bemerkt worden, dass der Handshake nicht ausgeführt wird. In
der vorherigen Implementierung sendet der Slave einmalig ein „CO“ zur PC-Applikation, diese soll
anschließen mit „OK“ antworten. Die Funktion war jedoch nicht gegeben, da der Slave nicht auf die
Antwort von der PC-Applikation gewartet hat.
In der neuen Konfiguration sendet die PC-Applikation bei einem Verbindungsaufbau zum Slave den
String „OKK“, dieser Antwortet anschließend mit „CCO“ und bestätigt somit den Handshake.
8.1.3 Fehlerhafter Handshake beim Master
Der Handshake zwischen Master und dem RFID-Tag-Lesegerät war im Master nicht implementiert.
Der im RFID-Tag-Lesegerät festgelegte Handshake wurde im Master entsprechend implementiert.
Abbildung 61 zeigt die Funktion, die für den Handshake programmiert wurde. Wird die Funktion
aufgerufen, sendet der Master zum RFID-Tag-Lesegerät über UART ein „T“. Der Master erwartet vom
RFID-Tag-Lesegerät als Antwort ein „K“. Wurde der Handshake korrekt durchgeführt wird dies in
einer Variablen gespeichert.
59
Abbildung 61: Master Handshake
8.2 Tests der PC-Applikation und der Webanwendung
Die Funktionen der PC-Applikation und der Webanwendung wurden gemeinsam getestet.
Nachfolgend sind die verschiedenen Tests aufgeführt:
Bei allen Tests ist der Master mit dem RFID-Tag-Lesegerät über UART und mit dem Slave über ZigBee
verbunden. Dabei befindet sich der Master im Operate-Modus.
Test 1:
Ausgangssituation: Die PC-Software ist über USB mit dem Slave verbunden. Es wird eine Live-Session
gestartet, bei der eine neue Datei erzeugt wird. Es werden Nachstarts und Zeitmessungen
durchgeführt.
Resultat: Der Slave wird in den Operate-Modus gewechselt. In der Datei wurden die Spalten
„Platzierung“, „RFIDTag“ und „Timestamp“ erzeugt. Bei der Ausgabe der Zeit fehlt die Einteilung in
Stunden, Minuten usw.
Test 2:
Ausgangssituation: Die PC-Software ist noch aus dem ersten Test im Betrieb, die USB-Verbindung
wurde kurzzeitig getrennt und dann wieder aufgebaut. Es wird eine Live-Session gestartet, bei der die
Datei aus dem Test 1 übernommen wird. Es werden Nachstarts und Zeitmessungen durchgeführt.
Resultat: Der Slave wechselt wieder automatisch in den Operate-Modus. Die Ergebnisse werden an
die Datei angehängt, die Platzierungen werden weitergezählt und sind korrekt.
60
Test 3:
Ausgangssituation: Die PC-Software ist noch aus den vorherigen Tests im Betrieb. Es wird eine Read-
Session gestartet, bei der eine neue Datei angelegt wird. Im Flash-Speicher des Slaves befinden sich
noch die Datensätze aus dem ersten und zweiten Test. Es werden Nachstarts und Zeitmessungen
durchgeführt.
Resultat: Der Slave wechselt in den Operate-Modus. In der Datei wurden die Spalten „Platzierung“
„RFIDTag“ und „Timestamp“ erzeugt. Alle Datensätze wurden korrekt ausgelesen. Bei der Ausgabe
der Zeit fehlt die Einteilung in Stunden, Minuten usw.
Test 4:
Ausgangssituation: Die PC-Software ist noch aus den vorherigen Tests im Betrieb. Es wird eine
Teilnehmerliste importiert, die Spalte, in denen sich die RFID-Tags befinden, wird angegeben. In die
Datei sollen keine Spalten übernommen werden. Anschließend wird eine Live-Session gestartet. Es
werden Nachstarts und Zeitmessungen durchgeführt.
Resultat: Der Slave wechselt in den Operate-Modus. In der Datei wurden die Spalten „Platzierung“
„RFIDTag“ und „Timestamp“ erzeugt. Die Ausgabe ist somit korrekt.
Test 5:
Ausgangssituation: Die PC-Software ist noch aus den vorherigen Tests im Betrieb. Es wird eine
Teilnehmerliste importiert, die Spalte, in denen sich die RFID-Tags befinden, wird angegeben. Es
sollen mehrere Spalten übernommen werden. Die im Test 4 erzeugte Datei wird wieder genutzt,
diese hat weniger Spalten. Es werden Nachstarts und Zeitmessungen durchgeführt.
Resultat: Fehler! In der Software werden bei den neuen Resultaten nur leere Zeilen angezeigt. Die
Daten wurden aber dennoch abgespeichert und befinden sich in der Datei.
Bewertung: In diesem Szenario ist lediglich die Anzeige in der PC-Software inkorrekt. Der Fehler tritt
durch einen Bedienungsfehler auf.
Lösungsvorschlag: Die einfachste Möglichkeit den Fehler auszuschließen ist, zunächst eine
Teilnehmerliste zu importieren und anschließend eine neue Datei zu erzeugen. Der Fehler kann mit
entsprechenden Modifikationen von der Software abgefangen werden, in diesem Fall müsste die
bestehende Datei ausgelesen werden. Sollte in dieser eine andere Anzahl von Spalten existieren,
kann z.B. automatisch eine neue Datei mit den entsprechenden Spalten erzeugt werden.
Test 6:
Ausgangssituation: Die PC-Software wird neu gestartet. Es wird ein Web-Account eingerichtet mit
drei Spalten. In einer Live-Session werden einige Messungen durchgeführt. Anschließend wird eine
Teilnehmerliste importiert, von dieser werden fünf Spalten übernommen. Die Web-Verbindung
bleibt weiterhin zum vorher erstellten Web-Account bestehen. Es werden weitere Messungen
durchgeführt.
61
Resultat: Fehler! Die Daten werden in der MySQL-Datenbank nicht gespeichert. In Abbildung 62 ist
der Inhalt der MySQL-Datenbank zu sehen. Die ersten drei Ergebnisse stammen aus der Phase, bevor
eine Teilnehmerliste importiert wurde. Die folgenden Datensätze mit fünf Spalten sind inkorrekt oder
gar nicht abgespeichert worden.
Bewertung: Die Daten werden nicht in der Datenbank gespeichert und gehen verloren. Wird die
korrekte Reihenfolge eingehalten (zunächst die Teilnehmerliste importieren und anschließend einen
User-Account erzeugen), tritt dieser Fehler nicht auf.
Lösungsvorschlag: Die leichteste Möglichkeit den Fehler auszuschließen ist, erst nach dem
Importieren einer Teilnehmerliste einen User-Account zu erstellen. Der Fehler kann mit
entsprechenden Modifikationen von der Software abgefangen werden, in diesem Fall müsste der
Webserver, mit einem entsprechenden Fehler-Code, antworten oder automatisch neue Spalten
hinzufügen damit die Datensätze gespeichert werden können.
Abbildung 62: Daten in der Datenbank
8.3 Verbesserungsmöglichkeiten
Die im Abschnitt 8.2 aufgeführten Fehler sollten von einer bereits bestehenden Nachfolgergruppe,
die an diesem Projekt arbeiten wird, behoben werden. Für die Ausgabe über die Webseite sollte es
möglich sein, einzelne Spalten zu sperren. Dafür würde sich ein Web-Interface anbieten. Momentan
wird die Tabelle der Webseite alle fünf Sekunden neu geladen. Besser wäre es, wenn die Tabelle nur
neugeladen wird, sofern neue Ergebnisse vorliegen.
62
9 Bedienungsanleitung
Die Bedienungsanleitung teilt sich in zwei Abschnitte auf. Zuerst wird erläutert, wie die PC-Software
installiert und der Webserver eingerichtet wird. Anschließend wird das Gesamtsystem in Betrieb
genommen, dabei werden die einzelnen Funktionen der PC-Software aufgezeigt.
9.1 Installation und Konfiguration der PC- und Web-Software
Die Inbetriebnahme der PC-Software gestaltet sich äußerst einfach. Die vorliegende EXE-Datei muss
lediglich gestartet werden, damit öffnet sich die Anwendung und ist einsatzbereit. Die Einrichtung
des Webserver gestaltet sich etwas aufwendiger. Grundlegend müssen die PHP-Skripte auf einem
Webserver hochgeladen werden. Die meisten Webspace-Anbieter bieten hierfür eigene Tools an,
diese ermöglichen z.B. auch das Hochladen der Dateien von einem Webbrowser aus. Wie die Dateien
hochgeladen werden, ist prinzipiell egal. Es sollte jedoch darauf geachtet werden, dass der Ordner
„SaveData“, möglichst nicht im Web-Bereich des Servers gespeichert werden. Dies dient der
Sicherheit, ansonsten liegen die Dateien in denen sich die Passwörter befinden im Web-Bereich und
könnten theoretisch über einen Webbrowser aufgerufen werden. Zum Testen wurde die
Webanwendung bei dem kostenlosen Webspace-Anbieter funpic.de [16] hochgeladen. Dabei zeigte
sich das Problem auf, dass keine Möglichkeit besteht, die Daten außerhalb des Webbereichs zu
speichern. Nachdem die Dateien auf einem Webserver hochgeladen wurden, sind einige
Konfigurationen vorzunehmen. Im Ordner „Online“ befindet sich die Datei „pathlink.php“ , in dieser
wird festgelegt, in welchem Verzeichnis sich die Dateien aus dem Ordner „SaveData“ befinden. In der
Abbildung 63 ist der Inhalt der Datei „pathlink.php“ zu sehen. In dem umrahmten Bereich müssen
jeweils die Pfade zu den Dateien angegeben werden. Im Beispiel sind die Pfade außerhalb des
Webbereichs.
Abbildung 63: Pathlink.php
Anschließend wird empfohlen, in dem Ordner „SaveData“ das Passwort in der Datei „AdminPW“ zu
ändern. Im umrahmten Bereich der Abbildung 64 wird das Passwort eingetragen, dieses muss später
in der PC-Software bei der Erstellung eines neuen User-Accounts angegeben werden. Das System ist
nun vollständig konfiguriert und kann genutzt werden.
Abbildung 64: AdminPW
63
9.2 Inbetriebnahme des Gesamtsystems
Für die Komponenten aus den bestehenden Bachelorarbeiten gibt es bereits Bedienungsanleitungen.
Das RFID-Tag-Lesegerät ist in der Bachelorarbeit [3]32 beschrieben. Die Bedienungsanleitung für die
Komponenten Master und Slave befindet sich in der Bachelorarbeit [2]33.
Als erstes wird das RFID-Tag-Lesegerät mit dem Master verbunden und anschließend in Betrieb
genommen. Der Master wird durch das Drücken des grünen Tasters (siehe Abbildung 65) in den
Operate-Modus versetzt. Die beiden Komponenten sind nun einsatzbereit.
Abbildung 65: Bedienfeld des Masters
Anschließend wird der Slave über USB mit einem PC verbunden. Die ZigBee-Verbindung baut sich nun
automatisch auf, bei erfolgreichem Aufbau der Verbindung wird dies durch das Leuchten der ZigBee-
LED signalisiert. Der Slave befindet sich somit im Ready-Modus. Am PC kann nun die PC-Software
gestartet werden. In Abbildung 66 ist die PC-Applikation nach dem Start zu sehen. Im 1. Bereich
befindet sich ein „Home“-Button, mit diesem gelangt man immer wieder zur Startseite. Desweiteren
werden hier noch Status-Informationen zu einer Webverbindung und einer importierten
Teilnehmerliste angezeigt. Die im 2. Bereich gekennzeichneten Pfeiltasten erlauben das Vor- und
Zurücknavigieren in der PC-Applikation. Informationen bezüglich der USB-Verbindung werden im 3.
Bereich ausgegeben. Der 4. Bereich ist der Arbeitsbereich, hier werden die möglichen Aktionen
angezeigt. In den folgenden Abschnitten wird die Bedienung der Software erklärt.
32
Abschnitt 9, ab Seite: 59 33
Abschnitt 8, ab Seite: 60
64
Abbildung 66: PC-Applikation Startzustand
9.2.1 Teilnehmerliste importieren
Das Importieren einer Teilnehmerliste ist nicht zwingend notwendig, ermöglicht aber das Zuweisen
vom RFID-Tag zum Namen des Schwimmers. Eine Teilnehmerliste sollte immer vor der Erstellung
eines Web-Accounts importiert werden. In der Projektarbeit von Herrn Borsych [4] wurde eine
Software entwickelt, mit der eine Teilnehmerliste hergestellt werden kann. Eine dieser
Teilnehmerlisten wird in dieser Bedienungsanleitung importiert. Nach Drücken des Buttons
„Teilnehmerliste“ gelangt man auf die nächste Seite. Auf dieser Seite muss der Pfad zu der Datei
angegeben werden, über den Button „Einlesen“ wird die Teilnehmerliste importiert. Nach dem die
Teilnehmerliste importiert wurde, wird diese angezeigt (siehe Abbildung 67). Im umrahmten Bereich
der Abbildung wird eine Spaltennummer angegeben. Diese wird für das Fenster „Spalten
bestimmen“, das sich automatisch mit öffnet, benötigt. Soll in der Ausgabe der Name des
Schwimmers angezeigt werden, muss die Spaltennummer, in denen sich RFID-Tags befinden,
angegeben werden. Sollen Spalten aus dieser Teilnehmerliste in der späteren Ausgabe angezeigt
werden, müssen diese Spalten übernommen werden (siehe Abbildung 68). Dabei werden die Spalten
durch ein Komma getrennt (z.B. 4,5,6). Ist die Übernahme aller Spalten gewünscht, kann dies durch
das Eintragen von „alle“ geschehen. Eine weitere Möglichkeit besteht darin, mehrere Zeilen durch
einen Bindestrich zu übernehmen (z.B. 4-8). Mithilfe der Checkbox „Alle Spalten in Datei
übernehmen“ werden die vorher bestimmten Spalten, auch für die Ausgabe übernommen. Die
Spalten werden in der PC-Applikation und auf der Webseite übernommen.
65
Abbildung 67: Importierte Teilnehmerliste
Abbildung 68: Spalten bestimmen
9.2.2 Verbindung zum Webserver herstellen
Eine Verbindung zum Webserver wird nur benötigt, sofern die Ergebnisse online abrufbar sein sollen.
Über den Button einrichten gelangt man auf eine neue Seite, auf dieser kann man sich mit einem
bestehen User-Account einloggen. Zu empfehlen ist jedoch bei jedem Wettkampf einen neuen
Account zu erstellen. Der Button „Weiter“ führt zu der Seite, auf der man einen neuen Account
erstellen kann. Als erstes sollte hier das Admin-Passwort angegeben werden, ohne diesen kann kein
neuer User-Account erstellt werden. In der Abbildung 69 ist die Seite für das Erstellen eines User-
Accounts bereits ausgefüllt zu sehen. Nach dem Drücken des Buttons „Erzeugen“ werden die Daten
zum Webserver geschickt. Der Webserver antwortet, ob die Erzeugung des Accounts erfolgreich war,
die Antwort wird von der PC-Applikation in einem extra Fenster ausgegeben (siehe Abbildung 70).
Die Verbindung zum Webserver ist nun hergestellt, die Ergebnisse werden automatisch hochgeladen.
66
Abbildung 69: Erzeugung eines User-Accounts
Abbildung 70: Antwort des Webservers
9.2.3 Verbindung zu einer Komponente über USB herstellen
Über USB kann sich mit den Komponenten Master und Slave verbunden werden. Nachdem eine
Verbindung zu einer der Komponenten hergestellt wurde, erschein ein neuer Bereich auf der
Startseite. In diesem Bereich können verschiedene Aktionen zwischen der PC-Applikation und der
angeschlossenen Komponente gestartet werden. Die neuen Funktionen werden in der Abbildung 71
gezeigt. Mit den unteren drei Buttons können der Komponente Befehle geschickt werden. Mit dem
Button „Löschen“ wird der Flash-Speicher der Komponente gelöscht. Wird der Button „Start“
67
gedrückt, wechselt die Komponente in den Operate-Modus, der „Stop“-Button setzt die Komponente
in den Ready-Modus. Über den Button „Live“ gelangt man in den Live-Modus, in diesem werden die
Ergebnisse sofort während des Wettkampfes angezeigt. Soll nach einem Wettkampf der Flash-
Speicher ausgelesen werden, geschieht dies über den Button „Auslesen“. Bei beiden Verfahren muss
eine Datei erstellt oder angegeben werden, in dieser werden die Tabellen erzeugt und die
einkommenden Ergebnisse gespeichert.
Abbildung 71: Funktionen der Komponente
In der Abbildung 72 ist die PC-Applikation in einer Live-Session zu sehen. Es wurden in der
Teilnehmerliste nicht alle RFID-Tags eingetragen, deshalb sind einige Einträge nur mit dem RFID-Tag
und der Zeit versehen. Die Ergebnisse werden gleichzeitig auf dem Webserver hochgeladen, die
Ausgabe der Tabelle ist identisch mit der in der PC-Applikation.
Abbildung 72: PC-Applikation in einer Live-Session
68
10 Projektmanagement
Zu Beginn der Bachelorarbeit wurde für das Projektmanagement eine Projektplanung durchgeführt.
In dieser wurden mehrere Meilensteine definiert, diese teilen die Aufgabenstellung in kleineren
Zeiträumen auf. Für die Aufgabenstellung ist insgesamt ein Zeitraum von 14 Wochen vorgesehen.
Dem Erstprüfer wurde jede Woche ein Bericht, mit dem erreichten Fortschritt und den Zielen für
darauffolgende Woche, abgegeben.
10.1 Meilensteinplanung
In der Planung wurden sieben Meilensteine definiert. In Abbildung 73 ist die Meilensteintrendanalyse
zu sehen. Bei dieser ist es bereits möglich, die Anfangszeitpunkt der einzelnen Meilensteine
abzulesen. In der Tabelle 14 werden die definierten Meilensteine erläutert.
Abbildung 73: Meilensteintrendanalyse
12.07.2013
19.07.2013
26.07.2013
02.08.2013
09.08.2013
16.08.2013
23.08.2013
30.08.2013
06.09.2013
13.09.2013
20.09.2013
27.09.2013
04.10.2013
11.10.2013
18.10.2013
25.10.2013
01.11.2013
08.11.2013
12/7 19/7 26/7 2/8 9/8 16/8 23/8 30/8 6/9 13/9 20/9 27/9 4/10 11/10 18/10 25/10 1/11 8/11
Me
ilen
ste
inp
rog
no
sen
Berichtszeitpunkte
Meilensteintrendanalyse
Ziellinie
Zusammenführung ZigBee und BA Webserver einrichten
PC-Software PC-MCU
PC-Software PC-WWW
Webseite
Testphase und Modifikationen
Ausarbeitung
69
Meilensteine Kurzbeschreibung Endzeitpunkt
Zusammenführung ZigBee und BA
Implementierung der ZigBee-Kommunikation in die Komponenten Slave und Master.
25.07.2013
Webserver einrichten Als Arbeitsumgebung für die Web-Entwicklung wurde ein Webserver genutzt, dieser musste den Anforderungen entsprechend eingerichtet werden.
30.07.2013
PC-Software PC-MCU Entwicklung der Live-Ergebnisse, dafür wurden die Slave-Software und die PC-Software bearbeitet.
09.08.2013
PC-Software PC-WWW
Die PC-Software erweitern, so dass die Daten ins Internet gestellt werden können.
23.08.2013
Webseite Die Daten von der PC-Software aufnehmen und im Browser ausgeben.
04.09.2013
Testphase und Modifikationen
Testen der Funktionen, sollte weitere Zeit zur Verfügung stehen werden erweiternde Funktionen entwickeln.
18.09.2013
Ausarbeitung Erstellen einer Dokumentation über die Funktionen und der Arbeitsweise dieser Bachelorarbeit.
16.10.2013
Tabelle 14: Meilensteine
10.3 Arbeitszeitplanung
Die Projektplanung sieht für jede Woche einen Bericht vor. Die Arbeitszeitplanung richtet sich nach
diesem Berichtzeitraum, somit wird für jede Woche eine Arbeitszeit bestimmt. Die
Wochenarbeitszeit in dieser Bachelorarbeit beträgt 35 Stunden. Dadurch ergibt sich eine
Gesamtarbeitszeit von 450 Stunden (siehe Tabelle 15). Die Werte in den Spalten „Arbeit Soll“ und
„Fortschritt Soll“ sind in der Projektplanung definiert worden. In den Spalten „Arbeit ist“ und
„Fortschritt Ist“ werden die Daten jeweils in den Wochenberichten eingetragen.
Arbeit in Stunden pro Berichtsintervall! Fortschritt (in%) Arbeit
Soll Arbeit Soll
kum. Arbeit Soll
% Arbeit
Ist Arbeit Ist
kum. Arbeit Ist % Soll Ist
14,00 0,00 0,0% 0,00 2,0%
35,00 35,00 7,1% 0,00 0,0% 7,0%
35,00 70,00 14,3% 0,00 0,0% 14,0%
35,00 105,00 21,4% 0,00 0,0% 21,0%
35,00 140,00 28,6% 0,00 0,0% 33,0%
35,00 175,00 35,7% 0,00 0,0% 40,0%
35,00 210,00 42,9% 0,00 0,0% 55,0%
35,00 245,00 50,0% 0,00 0,0% 63,0%
35,00 280,00 57,1% 0,00 0,0% 68,0%
35,00 315,00 64,3% 0,00 0,0% 70,0%
35,00 350,00 71,4% 0,00 0,0% 80,0%
35,00 385,00 78,6% 0,00 0,0% 85,0%
35,00 420,00 85,7% 0,00 0,0% 90,0%
35,00 455,00 92,9% 0,00 0,0% 95,0%
35,00 490,00 100,0% 0,00 0,0% 100,0% Tabelle 15: Arbeitszeitplanung
70
10.4 Auswertung der Projektplanung
In diesem Abschnitt wird der Projektablauf dargestellt. Dabei werden einige Punkte aufgezeigt, bei
denen es zu leichten Abweichung, zu der eigentlichen Projektplanung kam.
10.4.1 Meilensteintrendanalyse
Bei der Abarbeitung der Meilensteine, kam es zu kleinen Abweichungen, im Vergleich zu der Planung.
Die Abbildung 74 zeigt die Meilensteintrendanalyse vom 04.10.2013, somit 12 Tage vor Abgabe der
Arbeit. Bei den Meilensteinen „PC-SoftwarePC-WWW“ und „Webseite“ kam es zu kleinen
Verschiebungen. Für die Bearbeitung des Meilensteins „PC-Software PC-WWW“ wurde mehr Zeit, als
geplant, benötigt. Die Auswirkung auf den Meilenstein „Webseite“ war jedoch gering, da die
Entwicklung der Webseite größtenteils parallel zu dem Meilenstein „PC-SoftwarePC-WWW“ verlief.
Abbildung 74: MTA Stand 05.10.2013
12.07.2013
19.07.2013
26.07.2013
02.08.2013
09.08.2013
16.08.2013
23.08.2013
30.08.2013
06.09.2013
13.09.2013
20.09.2013
27.09.2013
04.10.2013
11.10.2013
18.10.2013
25.10.2013
01.11.2013
08.11.2013
12/7 19/7 26/7 2/8 9/8 16/8 23/8 30/8 6/9 13/9 20/9 27/9 4/10 11/10 18/10 25/10 1/11 8/11
Me
ilen
ste
inp
rog
no
sen
Berichtszeitpunkte
Meilensteintrendanalyse
Ziellinie
Zusammenführung ZigBee und BA Webserver einrichten
PC-Software PC-MCU
PC-Software PC-WWW
Webseite
Testphase und Modifikationen
71
10.4.2 Arbeitszeit
Für die Bachelorarbeit wurde in der Planung mit einer Gesamtzeit von 450 Stunden gerechnet. In der
Tabelle 16 ist der Wöchentliche-Arbeitszeitaufwand bis einschließlich dem 04.10.2013 zu sehen.
Wöchentlich kam es zu kleineren Schwankungen, insgesamt wurden jedoch lediglich fünf Stunden
mehr Zeitaufwand, als geplant, benötigt.
Datum Berichtsintervall Arbeit in Stunden pro Berichtsintervall! Fortschritt (in%) Berichtszeitpunkte Woche Arbeit Soll Arbeit Soll kum. Arbeit Soll % Arbeit Ist Arbeit Ist kum. Arbeit Ist % Soll Ist
12.07.2013 1. Schätzung am 12.07.2013 14,00 0,00 0,0% 14,00 0,00 0,0% 2,0% 2,0% 19.07.2013 13.07.2013 19.07.2013 35,00 35,00 7,1% 34,50 34,50 7,0% 7,0% 7,0% 26.07.2013 20.07.2013 26.07.2013 35,00 70,00 14,3% 35,00 69,50 14,2% 14,0% 14,0% 02.08.2013 27.07.2013 02.08.2013 35,00 105,00 21,4% 35,00 104,50 21,3% 21,0% 21,0% 09.08.2013 03.08.2013 09.08.2013 35,00 140,00 28,6% 31,00 135,50 27,7% 33,0% 33,0% 16.08.2013 10.08.2013 16.08.2013 35,00 175,00 35,7% 25,00 160,50 32,8% 40,0% 38,0% 23.08.2013 17.08.2013 23.08.2013 35,00 210,00 42,9% 36,00 196,50 40,1% 55,0% 50,0% 30.08.2013 24.08.2013 30.08.2013 35,00 245,00 50,0% 31,00 227,50 46,4% 63,0% 57,0% 06.09.2013 31.08.2013 06.09.2013 35,00 280,00 57,1% 46,00 273,50 55,8% 68,0% 64,0% 13.09.2013 07.09.2013 13.09.2013 35,00 315,00 64,3% 42,00 315,50 64,4% 70,0% 67,0% 20.09.2013 14.09.2013 20.09.2013 35,00 350,00 71,4% 36,50 352,00 71,8% 80,0% 77,0% 27.09.2013 21.09.2013 27.09.2013 35,00 385,00 78,6% 34,50 386,50 78,9% 85,0% 83,0% 04.10.2013 28.09.2013 04.10.2013 35,00 420,00 85,7% 38,50 425,00 86,7% 90,0% 90,0% 11.10.2013 05.10.2013 11.10.2013 35,00 455,00 92,9% 425,00 0,0% 95,0% 18.10.2013 12.10.2013 18.10.2013 35,00 490,00 100,0% 425,00 0,0% 100,0% 25.10.2013 19.10.2013 25.10.2013 490,00 100,0% 425,00 0,0% 01.11.2013 26.10.2013 01.11.2013 490,00 100,0% 425,00 0,0% 08.11.2013 02.11.2013 08.11.2013 490,00 100,0% 425,00 0,0%
Tabelle 16: Arbeitszeitplanung 04.10.2013
In Abbildung 75 ist der Verlauf der Arbeitsstunden in einem Diagramm dargestellt. In diesem sind die
Schwankungen der Arbeitszeit deutlich zu erkennen.
Abbildung 75: Stunden-Verlauf
0,00
100,00
200,00
300,00
400,00
500,00
600,00
0,00
5,00
10,00
15,00
20,00
25,00
30,00
35,00
40,00
45,00
50,00
Arbeit Soll
Arbeit Ist
72
11 Fazit
Die Aufgabe war sehr facettenreich, es musste sich in bestehende Software eingearbeitet und neue
Software entwickelt werden. Dabei wurden für die Umsetzung mehrere Programmiersprachen
genutzt. Die Systeme, für die die Software entwickelt wurde, waren zudem sehr unterschiedlich. Die
Arbeit deckt somit verschiedene Bereiche der Informatik ab. Durch die vielen verschiedenen
Programmiersprachen musste ich mich jeweils immer eine gewisse Zeit auf die neuen
Arbeitsumgebungen einarbeiten. Hierbei kann man aber sagen, dass dies relativ gut umsetzbar ist.
Ein Einarbeiten in eine neue Programmiersprache, wie bei z.B. in C# und PHP, gestaltet sich deutlich
einfacher als das Programmieren an sich zu lernen.
Rückblickend bin ich mit dem Ergebnis sehr zufrieden, die Aufgabenstellung konnte umgesetzt
werden. Es bestehen zwar noch kleinere Optimierungs- und Verbesserungsmöglichkeiten, die jedoch
die Funktion nicht beeinträchtigen.
LXXIII
12 Abbildungsverzeichnis
Abbildung 1: Übersicht der Systemkomponenten [2] ............................................................................. 7
Abbildung 2: RFID-Sensor ........................................................................................................................ 8
Abbildung 3: RFID-Tag ............................................................................................................................. 9
Abbildung 4: Zeitmesssystem .................................................................................................................. 9
Abbildung 5: Datensender (Master) ...................................................................................................... 11
Abbildung 6: Datenempfänger (Slave) .................................................................................................. 12
Abbildung 7: Data-Receiver ................................................................................................................... 13
Abbildung 8: Erzeugung der Testdaten ................................................................................................. 16
Abbildung 9: Füllen der Queue mit Testdaten ...................................................................................... 17
Abbildung 10: Pins der LED-Platine ....................................................................................................... 17
Abbildung 11: Quelldatei dem Projekt hinzufügen ............................................................................... 18
Abbildung 12: SPI-Bus Initialisierung ..................................................................................................... 19
Abbildung 13: GPIO-Pin als Eingang konfigurieren ............................................................................... 19
Abbildung 14: MCU-Pins einen Namen zuweisen ................................................................................. 19
Abbildung 15: ZigBee Initialisierung ...................................................................................................... 20
Abbildung 16: Einbindung der ZigBee-Kommunikation ........................................................................ 20
Abbildung 17: ZigBee-Queue füllen....................................................................................................... 20
Abbildung 18: Master mit gekennzeichneten LEDs............................................................................... 21
Abbildung 19: Error zuweisen ............................................................................................................... 21
Abbildung 20: Variable neuer Datensatz ist eingegangen .................................................................... 22
Abbildung 21: Eingehende Datensätze speichern ................................................................................. 23
Abbildung 22: Error-Auswertung .......................................................................................................... 24
Abbildung 23: Slave mit gekennzeichneten LEDs .................................................................................. 24
Abbildung 24: Implementierung der USB-Live-Übertragung ................................................................ 27
Abbildung 25: XAML-Code .................................................................................................................... 29
Abbildung 26: WPF Designer-Ansicht .................................................................................................... 30
Abbildung 27: C#-Code .......................................................................................................................... 30
Abbildung 28: Klasse für die Datenbindung [7] ..................................................................................... 31
Abbildung 29: Speicherung der Werte für "Ergebnisse im Flash" ......................................................... 31
Abbildung 30: XAML-Code zu "Ergebnisse im Flash" ............................................................................ 31
Abbildung 31: Erzeugung eines Frames in XAML .................................................................................. 32
Abbildung 32: Frame eine Page anzeigen lassen .................................................................................. 32
Abbildung 33: Data-Receiver ................................................................................................................. 33
Abbildung 34: Klassendiagramm ........................................................................................................... 34
Abbildung 35: Flash löschen .................................................................................................................. 35
Abbildung 36: USB Daten senden.......................................................................................................... 35
Abbildung 37: Methode SplitData ......................................................................................................... 36
Abbildung 38: Zellen auf Inhalt überprüfen .......................................................................................... 37
Abbildung 39: Tabelle durchsuchen ...................................................................................................... 38
Abbildung 40: Live-Session starten ....................................................................................................... 39
Abbildung 41: Eingang von Echtzeitdatensätze überprüfen ................................................................. 39
LXXIV
Abbildung 42: Aktualisiere die Ausgabe ................................................................................................ 39
Abbildung 43: Importierte Datei mit Spaltennummern ........................................................................ 40
Abbildung 44: Auswahl der Spalten ...................................................................................................... 41
Abbildung 45: Algorithmus der Spaltenübernahme ............................................................................. 42
Abbildung 46: Struktogramm CompareData ......................................................................................... 43
Abbildung 47: Webserver einrichten .................................................................................................... 44
Abbildung 48: Erzeugung eines MD5-Hashtags .................................................................................... 45
Abbildung 49: Programmcode Web-Request ........................................................................................ 46
Abbildung 50: Auswertung der Antwort vom Server ............................................................................ 47
Abbildung 51: Struktogramm von CompareData mit Web-Übertragung ............................................. 47
Abbildung 52: Erstellung der Threads ................................................................................................... 48
Abbildung 53: PHP $_POST ................................................................................................................... 50
Abbildung 54: MySQLi Beispiel .............................................................................................................. 50
Abbildung 55: Log-In in einen bestehenden Account ........................................................................... 52
Abbildung 56: String in eine Datei speichern ........................................................................................ 53
Abbildung 57: Hinzufügen neuer Datensätze ........................................................................................ 54
Abbildung 58: Ausgabe im Webbrowser ............................................................................................... 55
Abbildung 59: Einbindung von JavaScript ............................................................................................. 55
Abbildung 60: Erzeugung der Ausgabe für den Browser ...................................................................... 56
Abbildung 61: Master Handshake ......................................................................................................... 59
Abbildung 62: Daten in der Datenbank ................................................................................................. 61
Abbildung 63: Pathlink.php ................................................................................................................... 62
Abbildung 64: AdminPW ....................................................................................................................... 62
Abbildung 65: Bedienfeld des Masters ................................................................................................. 63
Abbildung 66: PC-Applikation Startzustand .......................................................................................... 64
Abbildung 67: Importierte Teilnehmerliste ........................................................................................... 65
Abbildung 68: Spalten bestimmen ........................................................................................................ 65
Abbildung 69: Erzeugung eines User-Accounts ..................................................................................... 66
Abbildung 70: Antwort des Webservers ............................................................................................... 66
Abbildung 71: Funktionen der Komponente ......................................................................................... 67
Abbildung 72: PC-Applikation in einer Live-Session .............................................................................. 67
Abbildung 73: Meilensteintrendanalyse ............................................................................................... 68
Abbildung 74: MTA Stand 05.10.2013 ................................................................................................... 70
Abbildung 75: Stunden-Verlauf ............................................................................................................. 71
LXXV
13 Tabellenverzeichnis
Tabelle 1: Aufbau der UART-Datensätze ............................................................................................... 10
Tabelle 2: Aufbau eines USB-Datensatzes [2] ....................................................................................... 25
Tabelle 3: Bisherige Befehle aus der Bachelorarbeit [2] ....................................................................... 26
Tabelle 4: Befehle die von der PC-Applikation ausgewertet werden ................................................... 26
Tabelle 5: Befehl "RTD" ......................................................................................................................... 26
Tabelle 6: Neue Funktionen der PC-Software ....................................................................................... 32
Tabelle 7: Grundfunktionen der PC-Applikation ................................................................................... 34
Tabelle 8: Pages für die Web-Verbindung ............................................................................................. 43
Tabelle 9: Klassen für die Web-Verbindung .......................................................................................... 44
Tabelle 10: Methoden der Klasse ClassConnectWeb ............................................................................ 45
Tabelle 11: PHP-Skripte ......................................................................................................................... 51
Tabelle 12: Erzeugen eines neuen User-Accounts ................................................................................ 52
Tabelle 13: Fehler in den übernommenen Komponenten .................................................................... 57
Tabelle 14: Meilensteine ....................................................................................................................... 69
Tabelle 15: Arbeitszeitplanung .............................................................................................................. 69
Tabelle 16: Arbeitszeitplanung 04.10.2013 ........................................................................................... 71
LXXVI
14 Literaturverzeichnis
[1] Projektarbeit Hochschule Emden-Leer
Implementierung einer drahtlosen ZigBee-basierten Datenübertragung für eine
ARM-basierte Microkontroller-Applikation
Veröffentlichungszeitpunkt: 2013
Autor: Karsten Dürschinger
[2] Bachelorarbeit Hochschule Emden-Leer
Entwurf und Implementierung eines ARM-basierten Systems (HW/SW) zur
Verarbeitung und Übertragung von RFID-Tag-Daten
Veröffentlichungszeitpunkt: 2013
Autoren: Markus Kybart und Christian Seidel
[3] Bachelorarbeit Hochschule Emden-Leer
Weiterentwicklung eines kontroller-basierten System zur Datenerfassung per RFID
Veröffentlichungszeitpunkt: 2013
Autor: Matthias Boomgarten
[4] Projektarbeit Hochschule Emden-Leer
Windows basierte RFID-Tag Erfassung mit C#
Veröffentlichungszeitpunkt: 2013
Autor: Waldemar Borsych
[5] Visual Studio 2012
Entwicklungsumgebung für C#
http://www.microsoft.com/visualstudio/deu/products/visual-studio-ultimate-2012
Herausgeber: Microsoft
[6] MSDN
C#-Dokumentation von Microsoft
http://msdn.microsoft.com/de-de/library/vstudio/kx37x362.aspx
Zeitpunkt des Zugriffs: September 2013
[7] Galileo Computing Visual C# 2010
http://openbook.galileocomputing.de/visual_csharp_2010/
ISBN: 978-3-8362-1552-7
Autor: Andreas Kühnel
LXXVII
[8] Aptana Studio 3
Entwicklungsumgebung für PHP
http://www.aptana.com/products/studio3
Herausgeber: Aptana
[9] Apache2
Webserver basierend auf dem HTTP-Protokoll
http://httpd.apache.org/
[10] MySQL-Datenbank
Open-Source-Datenbank
http://www.mysql.de/
[11] phpMyAdmin
Administrationstool für MySQL-Datenbanken
http://www.phpmyadmin.net/home_page/index.php
[12] PHP-Handbuch
http://www.php.net/manual/de/index.php
[13] jQuerry
Libary für JavaScript
http://jquery.com/
[14] Tfonfara
Beispiel für das Aktualisieren mit jQuery
http://www.tfonfara.de/ajax-seiteninhalt-laufend-aktualisieren-jquery.xhtml
Autor: Tobias Fonfara
[15] Arduino-Board
http://www.arduino.cc/
[16] Funpic.de
Kostenloser Webspace-Anbieter
http://www.funpic.de/
LXXVIII
15 Glossar und Abkürzungsverzeichnis
Abkürzung Ausgeschrieben Erklärung
UART Universal Asynchronous Receiver Transmitter
Serielle Schnittstelle zur Übertragung von Daten.
Delimiter Trennzeichen WinForms Windows Forms Programmierschnittstelle für
Benutzeroberflächen unter C#. Queue Warteschlange zum zwischenspeichern
von Datensätzen. SPI Serial Peripheral Interface Bus-System für die Datenübertragung. GPIO General-purpose input/output Pins der genutzten MCU, die entweder aus
Ausgang oder Eingang konfiguriert werden können.
API Application programming interface Programmierschnittstelle WPF Windows Presentation Foundation Programmierschnittstelle für
Benutzeroberflächen unter C#. XAML eXtensible Application Markup
Language Eine Unterart der XML-Sprache.
MD5 Message-Digest Algorithm Erstellt einen 128-Bit-Hashwert von einem beliebigen String.
