Entwicklung und Umsetzung eines Datenbank-basierten Systems zur RFID-basierten Erfassung von sportlichen Wettkampfdaten auf einem PC und Raspberry-PI

Entwicklung und Umsetzung
eines Datenbank-basierten
Systems zur RFID-basierten
Erfassung von sportlichen
Wettkampfdaten auf einem
PC und Raspberry-PI
Katharina Rawers
Studiengang Elektrotechnik
Erstprüfer : Prof. Dr.-Ing. Dirk Rabe
Zweitprüfer : Frederik Gosewehr, M.Eng.

Katharina Rawers
13.01.2020 - 29.06.2020

ERKLÄRUNG

Soweit meine Rechte berührt sind, erkläre ich mich einverstanden, dass die vorliegende
Arbeit Angehörigen der Hochschule Emden/Leer für Studium / Lehre / Forschung
uneingeschränkt zugänglich gemacht werden kann.

EIDESSTATTLICHE VERSICHERUNG

Ich, die Unterzeichnende, erkläre hiermit an Eides statt, dass ich die vorliegende Arbeit
selbständig verfasst habe und keine anderen als die angegebenen Quellen und Hilfsmittel
benutzt habe. Alle Quellenangaben und Zitate sind richtig und vollständig wiedergegeben
und in den jeweiligen Kapiteln und im Literaturverzeichnis wiedergegeben. Die vorliegende
Arbeit wurde nicht in dieser oder einer ähnlichen Form ganz oder in Teilen zur Erlangung
eines akademischen Abschlussgrades oder einer anderen Prüfungsleistung eingereicht.

Mir ist bekannt, dass falsche Angaben im Zusammenhang mit dieser Erklärung strafrechtlich
verfolgt werden können.

 _____________________________

 Ort, Datum, Unterschrift

Inhaltsverzeichnis
1 Einleitung ......................................................................................................................................... 1
 1.1 Aufgabenstellung..................................................................................................................... 1
 1.2 Aufbau der Arbeit .................................................................................................................... 1
2 Systemaufbau .................................................................................................................................. 2
3 Antennen HF .................................................................................................................................... 4
 3.1 Konstruktion von zwei Testantennen...................................................................................... 4
 3.2 Abgleich der Testantennen ..................................................................................................... 7
 3.3 Testen von Antennen .............................................................................................................. 7
4 Aufbau des Laptops ....................................................................................................................... 11
5 SSH-Tunnel .................................................................................................................................... 12
 5.1 Allgemeine Informationen .................................................................................................... 12
 5.2 Installationen ......................................................................................................................... 14
 5.3 Public-Key-Authentication einrichten ................................................................................... 14
 5.4 RSync Test.............................................................................................................................. 15
 5.5 RSync automatisieren ............................................................................................................ 15
 5.6 Probleme ............................................................................................................................... 15
 5.6.1 Windows-Kontoname .................................................................................................... 15
 5.6.2 Dienst starten ................................................................................................................ 15
 5.6.3 Programmpfad bekannt machen .................................................................................. 17
 5.6.4 Berechtigungen .ssh-Ordner ......................................................................................... 18
 5.6.5 Alternative Übertragung des publickeys ....................................................................... 18
 5.6.6 WLAN des Raspberry Pis................................................................................................ 19
 5.6.7 SSH debuggen ................................................................................................................ 19
6 Datenbank ..................................................................................................................................... 21
 6.1 Grundlagen ............................................................................................................................ 21
 6.2 Installationen ......................................................................................................................... 22
 6.2.1 MySQL............................................................................................................................ 22
 6.2.2 Python ........................................................................................................................... 23
 6.3 Einrichtung ............................................................................................................................ 23
 6.4 Python-Code .......................................................................................................................... 25
 6.4.1 importer.py.................................................................................................................... 25
 6.4.2 tag-listener.py................................................................................................................ 27
 6.4.3 exporter.py .................................................................................................................... 30

6.5 Programme testen................................................................................................................. 32
 6.5.1 Importer Test ................................................................................................................. 32
 6.5.2 Tag-Listener Test ........................................................................................................... 34
 6.5.3 Exporter Test ................................................................................................................. 35
 6.6 Programm zum Aufruf der Python-Programme .................................................................... 35
 6.7 Anpassungen Schwimmwettkampf ....................................................................................... 36
 6.7.1 Anpassungen Importer .................................................................................................. 37
 6.7.2 Anpassungen Tag-Listener............................................................................................. 37
 6.7.3 Anpassungen Exporter .................................................................................................. 40
 6.7.4 Test ................................................................................................................................ 41
 6.8 Unittest .................................................................................................................................. 42
 6.9 Probleme ............................................................................................................................... 44
 6.9.1 MySQL Connector: Unknown database ........................................................................ 44
 6.9.2 MySQL Connector: Access denied ................................................................................. 44
 6.9.3 Python Bibliothek installieren (pyfilewatch) ................................................................. 45
 6.9.4 Bibliotheksversionen ..................................................................................................... 46
7 Systemtests ................................................................................................................................... 47
 7.1 Testablauf .............................................................................................................................. 47
 7.2 Test Laufveranstaltung .......................................................................................................... 47
 7.3 Test Schwimmwettkampf ...................................................................................................... 49
8 Projektverlauf ................................................................................................................................ 51
9 Fazit ............................................................................................................................................... 52
10 Ausblick...................................................................................................................................... 52
11 Literatur- und Quellenverzeichnis ............................................................................................. 53
12 Abbildungsverzeichnis ............................................................................................................... 55
13 Listingverzeichnis....................................................................................................................... 57
14 Tabellenverzeichnis ................................................................................................................... 58

1 Einleitung
Für die Zeiterfassung von Sportlern bei Wettkämpfen wird häufig die RFID-Technik eingesetzt. Jeder
Sportler trägt je nach Wettkampf-Typ einen (bei Laufwettkämpfen) oder zwei (bei Freiwasser-
Schwimmwettkämpfen) Transponder, sogenannte Tags. Wenn die Sportler mit den Tags im
Erfassungsbereich der Antennen sind, werden ihre Zeiten und die Tag-IDs vom System
aufgenommen. Über die Tag-ID kann auf den Sportler geschlossen werden.

Im Rahmen dieser Bachelorarbeit soll eine vorhandene Antennenlösung für die
Hochfrequenzzeitaufnahme für Schwimmwettkämpfe [4][5] und die Neuaufsetzung des Systems vom
Spendenlauf einer Projektgruppe aus dem Jahr 2019 [1]. Außerdem soll die Software für
Schwimmwettkämpfe erweitert werden.

1.1 Aufgabenstellung
Zuerst sollte überprüft werden, ob die Empfangs-Zuverlässigkeit der vorhandenen RFID-basierten
Transponder-Erkennung im HF-Bereich mit 2 sehr breiten Antennen durch kleinere Antennen (ca.
5m) erhöht werden kann. Dabei soll aufgrund der möglichen Erweiterung auf z.B. 4 Antennen das
Multiplexing der Antennen überprüft werden.

Die Ergebnisse, die in txt-Dateien auf den Raspberry Pi geschrieben werden, sollen mithilfe eines
SSH-Tunnels zum PC-Auswerter-Programm übertragen werden.

Dieser Laptop soll neu aufgesetzt werden und dafür alle notwendigen Programme installiert und
eingerichtet werden.

Außerdem soll eine Datenbank mit Sportlerdaten, Transponderzuordnung (auch mehr als 1
Transponder pro Sportler) und Abgangszeiten von Sportlern (Renneinteilung oder individuell) erstellt
werden. Diese soll auch eine Export-Funktionen (csv-Format) beinhalten.

Des Weiteren sollen Unit-Tests und System-Tests durchgeführt werden.

1.2 Aufbau der Arbeit
In Abschnitt 2 werden der Systemaufbau dargestellt und die einzelnen Komponenten kurz erläutert.
Danach wird im Abschnitt 3 die vorhandene Antennenlösung für die Zeitmessung für
Schwimmwettkämpfe durch Vergleichen mit neuen Antennen überprüft und der Aufbau des Laptops
in Abschnitt 4 erklärt. Dann wird in Abschnitt 5 der SSH-Tunnel und in Abschnitt 6 die Datenbank für
das System für den Spendenlauf und den Schwimmwettkampf erläutert. Danach sind in Abschnitt 7
kurze Systemtests für Laufwettkämpfe und Schwimmwettkämpfe zu finden. Den Abschluss bildet der
Projektverlauf, das Fazit sowie der Ausblick ab Abschnitt 8.

 1

2 Systemaufbau
Der grobe Aufbau des Systems wurde vom Vorgängerprojekt einer Projektgruppe [1] übernommen
und auf einem PC neu aufgebaut und erweitert. Das System beinhaltet mehrere Teilkomponenten
und wird in Abbildung 1 dargestellt. Der Aufbau ist für zwei Szenarien vorgesehen: eine Zeiterfassung
von Schwimmwettkämpfen mittels Hochfrequenz- und eine von Leichtathletik-Laufveranstaltungen
via Ultrahochfrequenz-RFID-Zeiterfassung. Aufgrund der verschiedenen Anforderungen an die
Zeitmessung der verschiedenen Wettkämpfe wurden verschiedene Frequenzen genutzt.

 (b)

 (c)
 (d)

 (a)

 Abbildung 1: Systemaufbau

 2

(a) Die Liste mit den inventarisierten Tags und die Anmeldedatei, die von einem
 Anmeldeprogramm [2] erstellt wird, werden an EasyWK übertragen und dann als Meldedatei
 exportiert. Diese Datei wird auf den Laptop übertragen und mit dem Importer-Programm in
 die Datenbank importiert.

 (b) Die Erfassung der RFID-Tags geschieht mittels spezieller Antennen und Software, welche in
 Vorgängerprojekten [1][4] entwickelt wurde. Die verwendete Hardwarebasis, die die
 Erfassung steuert, stellt dabei ein Raspberry Pi dar. Dadurch wird beim Wettkampf eine
 Textdatei mit den Tagnummern und den dazugehörigen Zeiten erstellt (tag.txt). Außerdem
 wird für das Drücken des Tasters bei Schwimmwettkämpfen eine Textdatei erstellt mit den
 jeweiligen Zeiten (time.txt). Diese Dateien werden mit Hilfe eines SSH-Tunnels1 und RSync2
 während des Rennens auf den Laptop übertragen, der vom Tag-Listener-Programm auf dem
 Laptop aufgerufen wird. Das Tag-Listener-Programm schreibt die Tagzeiten aus der tag.txt
 und beim Schwimmwettkampf die Tasterdrückzeiten aus der time.txt in die Datenbank.
 Dieses wurde teilweise schon in Vorgängerprojekten erarbeitet [1][5].

 (c) Während des Rennens greift das Moderator-Kit auf die Datenbank (Steuerungs-Laptop) zu,
 um aktuelle Informationen zur Veranstaltung darstellen zu können und diese zusätzlich an
 ein Großdisplay zu übertragen [1].

 (d) Damit die Sportlerdaten nach einem Rennen weiter verarbeitet werden können, wird die
 Datenbank mit dem Exporter-Programm in eine csv-Datei übertragen und kann dann wieder
 an das EasyWK-Programm übertragen werden.

1
 SSH (Secure Shell) – Tunnel: Programm zur sicheren und verschlüsselten Übertragung von Shell-Kommandos,
siehe Abschnitt 5 SSH-Tunnel
2
 RSync: Nutzt den SSH-Tunnel zum Datenaustausch, siehe Abschnitt 5 SSH-Tunnel
 3

3 Antennen HF
Im Rahmen dieser Arbeit soll überprüft werden, ob die Empfangs-Zuverlässigkeit der vorhandenen
RFID-basierten Transponder-Erkennung aus einem Vorgängerprojekt [4] im Hochfrequenz(HF)-
Bereich mit 2 sehr breiten Antennen durch kleinere Antennen erhöht werden kann. Diese sollen
genau wie die alten Antennen insgesamt eine Breite von 5m haben.

3.1 Konstruktion von zwei Testantennen
Auf den 5m Breite und 30cm Höhe sollen vier gleichgroße Antennen zu finden sein (Abbildung 2).

 Abbildung 2: Antennenaufbau

Somit sind, wie in der Abbildung 3 zu sehen, die Maße jeder Antenne 125 ⋅ 30 . Damit wurde
versucht die größtmögliche Anschlagsbreite von 5 m Breite mit vier Antennen komplett abzudecken.

 125cm

 30cm

 Abbildung 3: Antennenmaße

Um zu überprüfen, ob die Antenneneigenschaften kürzerer Antennen sich im Vergleich zu den
größeren Antennen verbessert haben, wurden zuerst zwei Antennen zum Testen aufgebaut.

Für jede Antenne werden ca. 280 cm Kupferrohr mit einem Durchmesser von 22 mm, 4 Eckstücke
und 1 Verbindungsstück benötigt. Bei den Maßen der Stücke müssen die jeweiligen versenkten Teile
im Eck- bzw. Verbindungsstück bedacht werden. Außerdem muss noch eine Lücke für den Anschluss
an die Abgleichplatine (Abstand Bohrungen Abgleichplatine - Sicherheitsabstand zu den Bohrungen)
eingeplant werden und 4 Schrauben zum Fixieren der Abgleichplatine an der Antenne.

Zuerst wurden die Rohrstücke mithilfe eines Rohrschneiders auf Maß gebracht und miteinander
verbunden, wie in Abbildung 4 dargestellt.

 4

125,00cm

 2,20cm

 30,00cm
 2,20cm

 4,00cm 6,00cm 4,00cm
 73,00cm 19,00cm 19,00cm

 4,00cm
 AP

 22,00cm
 AP = Abgleichplatine

 4,00cm
 4,00cm 117,00cm 4,00cm

 Abbildung 4: Abmessungen der Antennen

Die montierte Antenne ist in der Abbildung 5 abgebildet.

 Abbildung 5: Zusammengesteckte Antennen

Außerdem wurden die Enden zur Abgleichplatine, wie in der Abbildung 6 zu sehen, mithilfe eines
Schraubstocks zusammengepresst.

 5

Abbildung 6: Zusammengesteckte Antenne mit zusammengepressten Enden

Im nächsten Arbeitsschritt wurden die einzelnen Rohrstücke miteinander durch Verlöten fest
verbunden. (Abbildung 7).

 Abbildung 7: Verlötete Antenne

Im Anschluss wurden noch die Enden zur Abgleichplatine durchbohrt und verzinnt. Des Weiteren
wurden die überstehenden Stücke soweit gekürzt, dass diese deren Enden exakt auf der dafür
vorgesehenen Fläche auf der Platine aufliegen. In Abbildung 8 ist die fertige Antenne mit und ohne
Abgleichplatine zu sehen.

 Abbildung 8: Fertige Antennen oben ohne und unten mit Abgleichpatine

 6

3.2 Abgleich der Testantennen
Damit die Antennen am System bestmöglich funktionieren, müssen diese zuerst auf einen reellen
Wellenwiderstand von 50 Ω bei der RFID-HF-Übertragungsfrequenz abgeglichen werden. Dies wurde
hier mithilfe der Abgleichplatine ID ISC.MAT.S der Firma Feig [6] und dem Netzwerkanalysator von
Rohde & Schwarz erledigt. Die Jumper der Abgleichplatine werden dafür so auf der Abgleichplatine
versetzt, dass der Marker mit der RFID-HF-Frequenz (13,56 MHz) auf dem Netzwerkanalysator so nah
wie möglich bei 1 landet. Dies stellt den angestrebten Wellenwiderstand von 50 Ω dar. Dann ist die
Antenne bestmöglich abgeglichen. In der Abbildung 10 ist das Bild des Netzwerkanalysators der
abgeglichenen Antennen von 13 bis 14 MHz zu erkennen. Dies wurde bei diesen Antennen, wie in
Abbildung 9 zu erkennen, mit den Kapazitäten C1/1(J1) und C1/2(J2) von 16,9 pF und C2(J3) von 60
pF erreicht.

 Abbildung 9: Abgleichplatine C1/1=J1=C1/2=J2=16,9pF; C2=J3=60pF

 Abbildung 10: Netzwerkanalysatorbild der abgeglichenen Antennen

Es gilt zu beachten: die Antenne ist nach der Messung nur für den Ort der Messung abgeglichen. Bei
Bewegung bzw. Umlegen der Antenne muss dieser Vorgang erneut durchgeführt werden, z.B. beim
Aufbau an einem Veranstaltungsort.

3.3 Testen von Antennen
Es wurden mehrere Antennen zusammen getestet, um diese vergleichen zu können. Um die
Antennen testen zu können, wurden diese an das vorhandene HF-System angeschlossen. Das
Antennenkabel kann am Reader durch Öffnen der Abdeckplatte an der dafür vorgesehenen
Verschraubung angeschlossen werden. Bei den Tests wurden zwei verschiedene Transponder, wie
bei einem Schwimmwettkampf auch zu erwarten ist, flach zu der Antenne gehalten. Auch diese
Transponder haben einen großen Einfluss auf die Empfangseigenschaften der Antennen. Um gleiche
Bedingungen für alle Antennen zu schaffen, wurden diese liegend auf dem Stuhl getestet. Ab welcher
 7

Entfernung die RFID-Tags von der Antenne erkannt werden, ist in der Tabelle 1 zu finden. Für einen
Schwimmwettkampf sind die Entfernungen nach vorne, ab denen die Tags von der Antenne erkannt
wurden, die wichtigsten.

 Antenne 1 2 3 4
 ungefähre Größe in cm 68*30 68*30, 150*30 125*30
 doppelt gelegt
 Durchmesser mm 22 12 18 22
Transponder nach vorne in cm 35 30 22 15
blau/rot
 zur Seite in cm 10 12 10 5
Transponder nach vorne in cm 45 50 50 45
schwarz
 zur Seite in cm 25 27 25 20
 Tabelle 1: Antennentests HF

Bei der Erfassung von schnell bewegten Transpondern gab es zwischen den Antennen keinen
erkennbaren Unterschied.

 Abbildung 11: Antenne 1

Die Antenne 1 (Abbildung 11) ist ungefähr die in dem Abschnitt 3.1 erstellte Antenne in der Länge
halbiert. Die Empfangseigenschaften haben sich dadurch etwas verbessert.

 8

Abbildung 12: Antenne 2

Die Antenne 2 (Abbildung 12) hat die gleiche Größe wie die Antenne 1, wurde aber doppelt gelegt
und hat einen kleineren Rohrdurchmesser. Dadurch haben sich die Empfangseigenschaften bei den
schwarzen Transpondern geringfügig verbessert und die der blau/roten Transponder blieben
ungefähr gleich.

 Abbildung 13: Antenne 3

Die Antenne 3 (Abbildung 13) ist deutlich länger als die vorherigen beiden Antennen. Dadurch haben
sich die Empfangseigenschaften verschlechtert.

 Abbildung 14: Antenne 4
 9

Die Antenne 4 (Abbildung 14) ist die Antenne, die in Abschnitt 3.1 konstruiert und in Abschnitt 3.2
abgeglichen wurde. Diese Antenne hat im Vergleich mit den anderen Antennen am schlechtesten
abgeschnitten.

Zusammenfassend kann nach Beobachtung festgestellt werden, dass eine Verkleinerung der
Antennen und auch mehr Windungen die Empfangseigenschaften der HF-Antennen verbessern.
Außerdem kann festgestellt werden, dass unterschiedliche Transponder einen deutlichen Einfluss auf
die Empfangseigenschaften der Antennen haben.

Für einen Schwimmwettkampf müssen die neu gebauten Antennen die Transponder schnell und bei
einem Mindestabstand von 30 cm nach vorne erfassen. Jedoch ist es nach den selbst durchgeführten
Tests fraglich, ob die neu konstruierten Antennen eine wesentliche Verbesserung für das System
darstellen würden. Da diese kleiner sind müssen mehr Antennen auf der gleichen Fläche verbaut
werden, damit diese komplett für die Aufnahme von Transpondern genutzt werden können. Aber da
nur eine Antenne an den HF-Reader angeschlossen werden kann, müssen bei mehr als einer Antenne
Powersplitter oder ähnliches dazwischen verbaut werden. Dadurch ist aber eine Verschlechterung
der Empfangseigenschaften der Antennen zu erwarten.

 10

4 Aufbau des Laptops
Auf dem Desktop des eingerichteten Laptops sind alle notwendigen Ordner und Programme für die
Sportveranstaltungen zu finden. In der Abbildung 15 wird dieser dargestellt.

 Software
 Moderatorenkit

 Lauf- Schwimm-

 veranstaltung veranstaltung

 Abbildung 15: Laptopdesktop

Für den SSH-Tunnel müssen die Programme Open-SSH, cygwin und Deltacopy installiert werden. Dies
wird in Abschnitt 5.2 erklärt.

Die Datenbank benötigt die Programme MySQL, Python und Notepad++ (oder PyCharm) aus
Abschnitt 6.2.

Außerdem muss auch noch Software für das Moderatoren-Kit installiert werden. Diese wird in einem
Vorgängerprojekt einer Projektgruppe [1] weiter erläutert.

ISOStart ist die Feig Reader Software, die zur Kommunikation des Laptops mit den Readern der Firma
Feig dient. Dieses Programm kann von dem Downloadbereich der Website der Firma [7]
heruntergeladen werden und kann unter anderem dafür genutzt werden, verschiedene Parameter
der Reader der Firma Feig einzustellen oder Tags einzeln einzulesen.

 11

5 SSH-Tunnel
Damit der Laptop mit dem Raspberry Pi kommunizieren kann und die benötigte tag.txt (time.txt)-
Datei übertragen werden kann, wird ein SSH-Tunnel mit RSync benötigt. Dieser ist somit, wie in der
Abbildung 16 zu sehen, das Verbindungsstück zwischen dem Laptop und dem Raspberry Pi.
Aufbauend auf den Arbeiten von Herrn Troff [5] und der Projektgruppe [1] wurde der SSH-Tunnel
und RSync eingerichtet.

 Abbildung 16: Systemaufbau SSH-Tunnel

5.1 Allgemeine Informationen
Mithilfe eines SSH-Tunnels können sicher (verschlüsselte) Shell-Kommandos übertragen werden.
Diesen Tunnel verwendet RSync zum Datenaustausch. Dabei ist der Raspberry Pi der Server und der
Laptop der Client, der Dateien vom Server kopiert. Diese Verbindung ist in der Abbildung 17 zu
sehen.

 Raspberry Pi Laptop
 - OpenSSH Server WLAN - OpenSSH Client
 - zu kopierende Dateien - RSync

 Abbildung 17: Verbindungsstruktur

Damit eine SSH-Verbindung aufgebaut werden kann, muss sich der Client beim Server
authentifizieren. Hierfür kann das Benutzerpasswort des Servers genutzt werden. Dies ist aber für
eine Verbindung, die öfter nacheinander wieder aufgebaut wird, nicht sinnvoll. Deswegen wird hier
die Public-Key-Authentication genutzt, die ein Schlüsselpaar zur Authentifizierung nutzt. Dieses
Schlüsselpaar wird vom Client erstellt und enthält einen öffentlichen und einen privaten Schlüssel.
Der öffentliche Schlüssel dient der Erkennung einer geplanten Verbindung und wird dafür auf den
Server übertragen. Dieses ist auch in Abbildung 18 zu erkennen.

 12

Abbildung 18: Schlüssel erstellen und übertragen

Der vereinfachte SSH-Verbindungsaufbau mit der Public-Key-Authentication ist Schritt für Schritt in
der Abbildung 19 zu finden. Hier wird zu Beginn ein Handshake durchgeführt. Daraufhin wird der
Server beim Client authentifiziert und zum Schluss wird der Client beim Server authentifiziert.
Danach startet die Hauptverbindung zwischen Client und Server. [8]

 Abbildung 19: vereinfachte Funktionsweise SSH [9]
 13

5.2 Installationen
Für die Kommunikation des Laptops mit dem Raspberry Pi müssen die Programme Open-SSH, cygwin
und Deltacopy installiert werden.

Zuerst muss auf dem Laptop das OpenSSH-Paket für Windows als ZIP-Archiv heruntergeladen und
dieses dann im Verzeichnis C:/Program files entpackt werden. Dann wird in einer Powershell mit
Administratorrechten das OpenSSH-Verzeichnis geöffnet und danach das Installationsskript
ausgeführt, welches die SSH-Dienste sshd und ssh-agent einrichtet.

Da SSH eigentlich für UNIX-Systeme entwickelt wurde, muss danach noch cygwin installiert werden.
Dafür wird die Setup-Datei heruntergeladen und danach ausgeführt.

Weiterhin wird noch Deltacopy benötigt. Dafür wird das ZIP-Verzeichnis heruntergeladen und dieses
unter C: entpackt. In diesem Verzeichnis befinden sich RSync und cygwin-DLLs. Diese müssen dann
noch, wie im Abschnitt 5.6.3 zu finden, als Programm dem PC bekannt machen [5].

5.3 Public-Key-Authentication einrichten
Zuerst müssen die SSH-Konfiguratonsdateien („sshd_config“) der beiden Geräte angepasst werden,
indem folgende Zeilen einkommentiert werden und wie folgt angepasst werden:

 - PublicKeyAuthentication yes
 - PasswordAuthentication no

Um den öffentlichen und privaten Schlüssel zu erzeugen, wird das Programm ssh-keygen ausgeführt.
Dabei müssen alle Fragen mit einem Enter bestätigt werden. Das Programm erstellt dann den Ordner
.ssh im Benutzerverzeichnis, das die beiden Schlüssel enthält. Die beiden Schlüssel (id_rsa,
id_rsa.pub) müssen auf den Raspberry Pi (Server) übertragen werden und der publicKey muss in der
Datei authorized_keys im .ssh-Ordner abgespeichert werden. Dafür sollten folgende Befehle in das
Terminal des Raspberry Pis eingegeben werden.

$ cd /home/pi/.ssh
$ touch authorized_keys
$ cat id_rsa.pub >> authorized_keys

Mit Hilfe des ersten Befehls wird in den Ordner .ssh gewechselt, in dem die Keys vom PC übertragen
wurden. Danach wird mit dem zweiten Befehl die Datei authorized_keys erstellt und dann wird der
publicKey mit dem letzten Befehl in die Datei authorized_keys übertragen.

Außerdem müssen die SSH-Dienste mit Net start sshd und Net start ssh-agent gestartet werden.
[1][8][10]

PS C:\WINDOWS\system32> Net start sshd
OpenSSH SSH Server wird gestartet.
OpenSSH SSH Server wurde erfolgreich gestartet.
PS C:\WINDOWS\system32> Net start ssh-agent
OpenSSH Authentication Agent wird gestartet.
OpenSSH Authentication Agent wurde erfolgreich gestartet.

 14

5.4 RSync Test
Um die Verbindung testen zu können oder um manuell eine Datei oder einen Ordner übertragen zu
können, kann der folgende Befehl in die PowerShell im Ordner C:/Deltacopy (cd C:/Deltacopy)
eingegeben werden. Diese Oberfläche zur Eingabe von Windows-Steuerungs-Befehlen lässt sich
durch Rechtsklick auf das Windows-Symbol öffnen.

PS C:\DeltaCopy> rsync -vrb -e "ssh -i C:\Users\RFID\.ssh\id_rsa -o PasswordAuthentication=no"
pi@192.168.1.1:/media ./

Dies ist ein Befehl zum RSync-Aufruf, was an dem Wort am Anfang zu erkennen ist. Danach sind die
Optionen des Befehls zu finden (v-ausführliche Ausgabe, r-Unterverzeichnisse mit synchronisieren, b-
Backup). Dann wird der Ort des Keys angegeben und die Authentifizierung per Passwort
ausgeschaltet für die SSH-Verbindung. Am Ende werden der Benutzer, die IP-Adresse des Raspberry
und der Pfad des zu synchronisierenden Verzeichnisses angegeben. [8]

5.5 RSync automatisieren
Um mit RSync nahezu dauerhaft die notwendige Datei vom Raspberry Pi auf den Laptop zu kopieren,
wurde eine Batch-Datei erstellt:

 Listing 1: Sync.bat

In dieser Datei sind genau die Befehle zu finden, die einzeln vorher in die PowerShell eingegeben
werden mussten (vgl. Abschnitt 5.4). Zuerst wird in den DeltaCopy Ordner gewechselt und dort wird
dann der RSync-Befehl ausgeführt. Damit werden alle Dateien und Ordner aus dem media Ordner
und den Unterordnern des Raspberry Pi in den Deltacopy Ordner kopiert. Diese Batch-Datei wird
immer wieder vom Python-Programm tag-listener.py aufgerufen, wie in Abschnitt 6.4.2 zu erkennen
ist. [1]

5.6 Probleme
Bei dem Einrichten des SSH-Tunnels und RSync sind verschiedene Probleme aufgetreten. Diese sind
mit Lösungsvorschlägen im Folgenden zu finden.

5.6.1 Windows-Kontoname
Wenn ein PC mit einem SSH-Tunnel mit einem Anderen verbunden werden soll, dann sollte der
Windows-Kontoname keine Leerzeichen beinhalten. Außerdem sollte auch auf jegliche
Sonderzeichen und Ähnliches verzichtet werden. Wenn dies nicht beachtet wird, gibt es Probleme
mit den Befehlen. Deswegen wurde ein neuer Benutzer ohne Leerzeichen angelegt.

5.6.2 Dienst starten
Wenn sich ein Dienst nicht mit der Powershell und dem Befehl Net start … starten lässt, dann kann
dieser manuell gestartet werden. Dafür wird in der Computerverwaltung den Reiter Dienste und
Anwendungen ausgewählt. Dort werden die Dienste, wie in der Abbildung 20 zu erkennen, geöffnet
und dort kann dann der jeweilige Dienst mithilfe eines Doppelklicks ausgewählt werden.

 15

Abbildung 20: Dienste

Dann kann, wie in der Abbildung 21 zu sehen, der Dienst konfiguriert und der Dienst automatisch
gestartet, manuell gestartet oder deaktiviert werden. Außerdem kann der Dienst mit Hilfe der
Schaltflächen manuell gestartet, beendet, angehalten oder fortgesetzt werden.

 Abbildung 21: Konfiguration Dienst ssh-agent

 16

Der Dienstname kann von dem Anzeigename des Dienstes in der Liste der Dienste abweichen, wie
zum Beispiel auch bei dem Dienst ssh-agent.

5.6.3 Programmpfad bekannt machen
Es sollte dem PC bekannt gemacht werden, wo er neu installierte Programme, wie zum Beispiel
RSync, finden kann. Sonst muss der Pfad beim Befehlsaufruf mit angegeben werden, was zu
Problemen führen kann. Deswegen ist es besser die Umgebungsvariable PATH dafür zu nutzen. Dort
sind die Verzeichnisse gespeichert, in denen nach Befehlen gesucht werden soll. Um ein neues
Verzeichnis darin abzuspeichern, muss in der Systemsteuerung auf den Reiter System ausgewählt
werden. Danach sind die Umgebungsvariablen unter den Tabreiter Erweitert (Erweiterte
Systemeinstellungen) und dem Button Umgebungsvariablen zu finden, die in der Abbildung 22 zu
sehen sind.

 Abbildung 22: Erweiterte Systemeinstellungen

Dort sind die Umgebungsvariablen getrennt nach Benutzervariablen und Systemvariablen zu finden.
Unter Systemvariablen, die in der Abbildung 23 zu sehen sind, wird dann der Pfad zum RSync-
Programm hinzugefügt, indem der Reiter PATH markiert und Bearbeiten ausgewählt wird.

 17

Abbildung 23: Systemvariablen

Dann sollte das Programm RSync ohne Probleme auf dem PC gefunden werden. [11]

5.6.4 Berechtigungen .ssh-Ordner
Um die Berechtigungen eines Verzeichnisses/einer Verzeichnisstruktur auf dem Raspberry Pi
einzusehen, muss zuerst zum root user gewechselt werden. Der root user wird benötigt, damit der
Benutzer fast alle Rechte auf dem Raspberry Pi hat, da dies für den Standardnutzer pi nicht der Fall
ist. Dafür wird der Befehl sudo su in das Terminal eingegeben. Mit dem change owner Befehl (chown)
kann der Besitzer einer Datei oder einer Gruppe geändert werden. Hier wird mit dem Befehl chown
pi:pi .ssh/ -R der Besitzer und die Gruppe des .ssh-Ordners und seinen Unterordnern inklusive der
Dateien auf pi geändert. Das war notwendig, da sonst der Ordner nicht die nötigen Berechtigungen
hatte und ssh nicht funktioniert. Um die Verzeichnisstruktur und die Berechtigungen des .ssh-
Ordners anzeigen zu lassen, muss dann der Befehl ls -la .ssh/ in das Terminal eingegeben werden.
Dabei kann beispielsweise folgende Ausgabe ausgegeben werden:

drw------- 2 pi pi 4096 Jun 12 23:35 .
drwxr-xr-x 27 pi pi 4096 Jun 13 00:40 ..
-rw------- 1 pi pi 575 Jun 12 23:35 authorized_keys
-rw------- 1 pi pi 2610 Mr 3 2020 id_rsa
-rw------- 1 pi pi 575 Mr 3 2020 id_rsa.pub

Mit dem exit-Befehl kann wieder zum normalen Nutzer gewechselt werden. [12]

5.6.5 Alternative Übertragung des publickeys
Der publicKey kann auch anders übertragen werden und zwar über die PowerShell. Dafür sollte
zuerst in die SSH-Konfigurationsdateien (sshd_config) der Punkt PasswordAuthentication auf yes
geändert werden. Dann wird das Schlüsselpaar erstellt mit dem ersten Befehl ssh-keygen.exe. Mit
dem Befehl danach wird eine SSH-Verbindung mit dem Raspberry Pi hergestellt. Dieser fragt dann
nach einem Passwort für den Raspberry Pi, welches dem allgemeinen Passwort für den Raspberry Pi
entspricht. Damit ist der Benutzer auf dem Raspberry Pi angemeldet und kann somit Befehle in die
PowerShell des Laptops eingeben und den Raspberry Pi damit steuern. Dann wurde der publicKey auf
den Raspberry Pi in die Datei authorized_keys im Ordner .ssh übertragen. Danach meldet sich der
Benutzer wieder mit exit oder der Tastenkombination Strg+D vom Raspberry Pi ab.

 18

PS C:\DeltaCopy> ssh-keygen.exe
PS C:\DeltaCopy> ssh -i 'C:\Users\RFID\.ssh\id_rsa' pi@192.168.0.1
pi@192.168.0.1's password:
pi@raspberrypi:~ $ nano id_rsa.pub
pi@raspberrypi:~ $ pi@raspberrypi:~ $ cat id_rsa.pub
ssh-rsa
…
pi@raspberrypi:~ $ cat id_rsa.pub > .ssh/authorized_keys
pi@raspberrypi:~ $ Abgemeldet
Connection to 192.168.0.1 closed.

5.6.6 WLAN des Raspberry Pis
Um die Konfiguration der verfügbaren WLANs einsehen zu können, muss ifconfig in das Raspberry Pi
Terminal eingegeben werden. Daraufhin werden die WLAN-Einstellungen mit Konfigurationen wie
zum Beispiel der IP-Adresse ausgegeben.

Wenn das Passwort vom integrierten WLAN des Raspberry Pis vergessen wurde oder jemand anderes
den Raspberry Pi eingerichtet hat, dann kann dieser in der Datei wpa_supplicant.conf im Ordner
/etc/wpa_supplicant gefunden werden. Diese Datei kann mithilfe des Befehls sudo nano
/etc/wpa_supplicant/wpa_supplicant.conf mit dem Terminal geöffnet werden. Dort kann dann das
Passwort eingesehen und verändert werden. [13]

5.6.7 SSH debuggen
Um Probleme bei der SSH-Verbindung zu finden und Fehlermeldungen dafür ausgegeben zu
bekommen, sollte die SSH-Verbindung gedebuggt werden. Dafür muss in den SSH-Befehl beim Client
ein –v für das erste Level des verbosity Modus, -vv für das zweite Level und –vvv für das dritte Level
angefügt werden. Desto höher das Level des verbosity Modus ist, desto mehr Ausgaben sind zu
erkennen. Um die SSH-Verbindung bei diesem System im ersten Level des verbosity Modus zu testen,
wurde folgender Befehl in die als Administrator ausgeführte PowerShell eingegeben [14]:

ssh -v pi@192.168.0.1

Im Folgenden ist ein Ausschnitt von der Ausgabe zu finden.

debug1: Authentications that can continue: publickey,password
debug1: Next authentication method: publickey
debug1: Offering public key: RSA SHA256:J9iRJYE6iiXl0HYMI0zTtozeAUJnwY1cZKw+50G0ArE
C:\\Users\\Digitaltechnik E14/.ssh/id_rsa
debug1: Authentications that can continue: publickey,password
debug1: Trying private key: C:\\Users\\Digitaltechnik E14/.ssh/id_dsa
debug1: Trying private key: C:\\Users\\Digitaltechnik E14/.ssh/id_ecdsa
debug1: Trying private key: C:\\Users\\Digitaltechnik E14/.ssh/id_ed25519
debug1: Trying private key: C:\\Users\\Digitaltechnik E14/.ssh/id_xmss
debug1: Next authentication method: password
debug1: read_passphrase: can't open /dev/tty: No such file or directory
pi@192.168.0.1's password:
debug1: Authentication succeeded (password).
Authenticated to 192.168.0.1 ([192.168.0.1]:22).
debug1: channel 0: new [client-session]
debug1: Requesting no-more-sessions@openssh.com
debug1: Entering interactive session.
 19

debug1: pledge: network
debug1: console supports the ansi parsing
debug1: client_input_global_request: rtype hostkeys-00@openssh.com want_reply 0

Hier kam es zu Problemen, da bei fehlender Pfadangabe zum publicKey, dieser im Default Verzeichnis
gesucht wird. Dieses stimmt aber nicht mit dem passenden Key überein, der auf den Raspberry Pi
übertragen wurde. Deswegen springt SSH in die Password Authentication. Mit dem Befehl exit wird
die SSH-Verbindung wieder getrennt.

Um den hier benutzten SSH-RSync-Befehl, der in Abschnitt 5.4 zu finden ist, im dritten Level des
verbosity Modus zu debuggen, muss folgender Befehl eingegeben werden:

rsync -vrb -e "ssh -vvv -i C:\Users\RFID\.ssh\id_rsa -o PasswordAuthentication=no"
pi@192.168.0.1:/media ./

Die Ausgaben der verschiedenen Level des verbosity Modus sind an den Anfängen der Zeilen (debug1
gehört zu Level 1, etc.) zu erkennen.

Da hier auch direkt der Pfad zu dem Key angegeben wurde, wird er hier auch gefunden. Dies ist an
dem Ausschnitt der Ausgabe zu erkennen:

debug1: Authentications that can continue: publickey,password
debug3: start over, passed a different list publickey,password
debug3: preferred publickey,keyboard-interactive
debug3: authmethod_lookup publickey
debug3: remaining preferred: keyboard-interactive
debug3: authmethod_is_enabled publickey
debug1: Next authentication method: publickey
debug1: Offering public key: C:\\Users\\RFID\\.ssh\\id_rsa
debug3: send_pubkey_test
debug2: we sent a publickey packet, wait for reply
debug1: Server accepts key: pkalg ssh-rsa blen 279
debug2: input_userauth_pk_ok: fp de:26:85:3b:45:22:9b:df:1c:ce:15:48:e6:9e:84:b0
debug3: sign_and_send_pubkey
debug1: read PEM private key done: type RSA
debug1: Authentication succeeded (publickey).

 20

6 Datenbank
Um die gesamten Sportlerdaten speichern zu können und auch die Transponderzeiten den jeweiligen
Sportlern zuordnen zu können, wird eine Datenbank benötigt. In dieser werden alle Daten mit dem
Programm MySQL verwaltet. Damit die Daten in die Datenbank geschrieben und gelesen werden
können, sind Python-Programme erstellt worden. Diese Programme und die Datenbank sind in der
Abbildung 24 zu finden. Die Datenbank wurde aufbauend auf ein Vorgängerprojekt [3] entwickelt.

 Abbildung 24: Systemaufbau Datenbank und Python-Code

6.1 Grundlagen
Ein Datenbanksystem besteht aus einem Datenbankmanagementsystem und Datenbanken.

Ein Datenbankmanagementsystem (DBMS) dient zur Erstellung, Verwaltung und den Zugriff auf
Datenbanken. Es gibt zwei Arten von Datenbankmanagementsystemen, das Fileserver-System und
das Client-Server-System. Bei dem Fileserver-System liegen die Datenbanken an zentraler Stelle und
das Datenbankmanagementsystem auf dem Client. Ein Nachteil von diesem System ist es, dass es bei
 21

Abfragen unter Umständen zu einer hohen Netzbelastung durch Übertragung einer großen Menge an
Daten zum Datenbankmanagementsystem kommen kann. Deshalb kommt dieses System nur bei
kleinen Anwendungen in Frage. Dahingegen ist das Client-Server-System so aufgebaut, dass sich die
Datenbanken und das Datenbankmanagementsystem, also das komplette Datenbanksystem, auf
einem Server befinden. Daher werden Abfragen von Nutzern an zentraler Stelle ausgewertet und nur
das Ergebnis wird durch das Netzwerk übertragen. Dies ist entwickelt worden für sehr große
Datenbanken mit hoher Benutzeranzahl. MySQL ist auch ein Client-Server-System.

Eine Datenbank ist eine strukturierte Sammlung von Daten, die in einem sachlogischen
Zusammenhang stehen. Für die Datenstrukturierung und –anordnung gibt es verschiedene
Möglichkeiten. Eine große Bedeutung dabei haben die relationalen Datenbanken, bei denen Tabellen
die Grundlage bilden. Ein Ausschnitt aus so einer Datenbank ist in Abbildung 25 zu sehen.

 Tabelle (Relation) Datenfeld Schlüssel

 Attribute

 Datensatz
 (Tupel)

 Abbildung 25: Ausschnitt Datenbanktabelle

Eine relationale Datenbank besteht aus mindestens einer, meistens mehreren Tabellen (Relationen).
Eine Zeile der Tabelle wird als Datensatz (Tupel) bezeichnet, der wiederum aus mehreren Datenfelder
besteht. Gleichartige Datenfelder sind spaltenweise angeordnet und werden Attribute genannt. Ein
wichtiger Bestandteil einer Datenbank ist mindestens ein Schlüssel, damit jeder Datensatz eindeutig
identifizierbar ist. Bei dieser Tabelle ist die TransponderID1 der Schlüssel, mit dessen Hilfe einzelne
Zeiten den Sportlern zugeordnet werden können. Außerdem können mit Schlüsseln Tabellen
verknüpft werden. [15]

6.2 Installationen
Im Folgenden sind die Anleitungen zur Installation der Programme MySQL und Python zu finden.

6.2.1 MySQL
Für die Installation von MySQL muss der MySQL Installer heruntergeladen werden und dann
gestartet werden. Dort muss dann, wie in der Abbildung 26 zu sehen, der Installationstyp Full
ausgewählt werden.

 22

Abbildung 26: Installationstyp Full

Außerdem müssen noch das Passwort angegeben und ein User erstellt werden. Diese Daten sollten
unbedingt notiert werden, da diese immer wieder benötigen werden.

6.2.2 Python
Zum Programmieren mit der Programmiersprache Python muss diese heruntergeladen werden. Bei
diesem Laptop haben wurde die Version 3.7 gewählt, da die neueste Version mit MySQL zum
Zeitpunkt der Installation noch nicht kompatibel war. Das ist an dem nicht vorhandenen Python
Connector für die Version 3.8 zu erkennen. Zum Programmieren bietet es sich an, eine Oberfläche
wie zum Beispiel PyCharm oder Notepad++ zu installieren.

6.3 Einrichtung
Für die Python-Programme werden verschiedene Bibliotheken benötigt. Diese können einfach in der
Powershell, die als Administrator ausgeführt werden sollte, mit dem Befehl pip install Bibliothek
heruntergeladen werden. Um alle Bibliotheken für die hier nötigen Programme zu installieren,
müssen folgende Befehle in die Powershell eingegeben werden:

pip install pandas==0.24.1
pip install sqlalchemy
pip install mysql-connector-python

Die oberste Bibliothek pandas dient zur Daten-Manipulation und –Analyse. In diesem Projekt dient
sie zum Umgang mit numerischen Tabellen. Die Erklärung, warum eine Bibliotheksversion angegeben
werden muss, ist in Abschnitt 6.9.4 zu finden. [16]
 23

Mit der Bibliothek sqlalchemy kann ein Python Programm mit einer SQL-Datenbanken verbunden
werden und mit diesen arbeiten. [17]

Damit MySQL und Python miteinander kommunizieren können, ist der sog. mysql-connector-python
Treiber notwendig. Dieser dient mit seiner API als Schnittstelle zwischen Python-Programmen und
der eigentlichen MySQL Datenbank.

Um MySQL einzurichten, sollte als erstes die MySQL Workbench gestartet werden. Dann ist auf dem
Bildschirm das Gleiche zu erkennen wie in Abbildung 27. Dort wird die MySQL Connection
ausgewählt, die für die Datenbank genutzt werden soll und dann wird das Passwort eingegeben.

 Abbildung 27: Verbindung herstellen

Danach muss der Reiter Schemas auf der linken Seite von Abbildung 28 ausgewählt werden. Dort
wird mit einem Rechtsklick und Create Schema das Schema spendenlauf erstellt.

 24

Abbildung 28: Schema

Damit sind alle Konfigurationen abgeschlossen.

6.4 Python-Code
Im Folgenden sind die nötigen Programme für die Kommunikation mit der Datenbank beschrieben.

Bei einer Laufveranstaltung gibt es mehrere einzelne Rennen. Alle Sportler eines Rennens sind zur
selben Zeit auf der Strecke.

6.4.1 importer.py
Mithilfe des Importers wird eine Meldedatei, die vom Programm EasyWK erstellt wird, in die
Datenbank importiert.

 Listing 2: Funktion main

 25

Beim Start des Programmes wird zuerst die main-Funktion aufgerufen, die im Listing 2 dargestellt ist.
Am Anfang dieser Funktion ist eine Ausgabe zu finden, die kurz erklärt, wie das Programm arbeitet.
Danach werden für die PowerShell nützliche Kommandozeilenparameter erstellt, die den Benutzer
unterstützen sollen. Zum Beispiel eine Hilfenachricht mit dem Befehl python importer.py –h
angezeigt werden:

Spendenlauf CSV to SQL Importer
usage: importer.py [-h] filename
Export input csv nef file to database
positional arguments:
 filename filename to csv data to import into database
optional arguments:
 -h, --help show this help message and exit

Dann wird die Funktion importerCSVFromFile aufgerufen mit dem übergebenen Dateinamen und der
Rückgabewert der Funktion wird danach an die Funktion exportToDB übergeben.

 Listing 3: Funktion importCSVFromFile

Die Funktion importCSVFromFile, die im Listing 3 zu sehen ist, bekommt von der main den Dateipfad
von der zu importierenden csv-Datei übergeben. Daraufhin gibt sie die csv-Datei als Dataframe, mit
dem das Programm weiter arbeiten kann, wieder zurück an die main.

 Listing 4: Funktion exportToDB Teil 1

Die Funktion exportToDB, die im Listing 4 zu sehen ist, bekommt das Dataframe der csv-Datei von der
main. Ein Dataframe ist vergleichbar mit einer Tabelle, die Zeilen und Spalten beinhaltet, ähnlich wie
Excel-Tabellen. Zuerst wird eine Verbindung zur Datenbank aufgebaut und danach die Nachricht
„VerbindungzurDatenbankerfolgt“ herausgegeben. Wenn die Datenbank noch nicht existiert, dann
wird diese erstellt und wenn die Tabelle daten der Datenbank vorhanden ist, wird sie gelöscht. Dann
wird das Dataframe in die Tabelle daten der Datenbank umgewandelt und noch der Datentyp
einzelner Zeilen angepasst, damit diese nachher richtig beschrieben werden können.

 26

Listing 5: Funktion exportToDB Teil 2

Als letztes werden noch die Views erstellt, die im Listing 5 gezeigt werden. Diese dienen
hauptsächlich der Weiterverarbeitung der Daten in dem Moderatoren-Kit beziehungsweise dem
Display, welches in der Projektarbeit der Projektgruppe [1] erläutert wird.

6.4.2 tag-listener.py
Dieses Programm dient zum Import von Zeiten von Sportlern bei einer Laufveranstaltung. Dabei
erkennt das Programm eine Erweiterung einer Datei mit Sportlerzeiten und fügt diese dann in die
Datenbank ein. Dieses Programm läuft dauerhaft bei der Veranstaltung und neue Zeiten werden bis
auf kleinere Verzögerungen durch Software, wie beispielsweise dem SSH-Tunnel, an das System
weitergegeben.

 Listing 6: Funktion main

Hier wird am Anfang die main-Funktion (Listing 6) aufgerufen. Zuerst wird die Variable rennen als
global gekennzeichnet. Danach wird auch hier kurz ausgegeben, was das Programm machen soll.
Hierbei werden für die PowerShell nützliche Kommandozeilenparameter erstellt, die den Benutzern
beim Benutzen des Programms helfen sollen. Dann wird die übergebene Rennenzahl in eine Variable

 27

geschrieben wenn diese vorhanden ist und sonst wird die Rennenzahl auf 1 gesetzt. Diese wird dann
ausgegeben und die Funktion tail, die im Listing 7 zu finden ist, mit dem Dateipfad zur Tag-Zeiten-
Datei aufgerufen.

 Listing 7: Funktion tail

Zuerst wird die batch-Datei sync.bat aufgerufen, die die RSync-Befehle ausführt. Diese ist im
Abschnitt 5.5 zu finden. Danach wird die Tag-Zeiten-Datei, wie zum Beispiel in der Abbildung 29 zu
sehen, mit Hilfe des übergebenen Dateipfades zum Lesen geöffnet.

 Abbildung 29: Tag-Zeiten-Datei

Danach wird der Cursor ans Ende der Datei positioniert. Dies verhindert ein Einlesen der
Überschriften der Datei und alter Zeilen. Als Nächstes wird die Cursorposition gespeichert und eine
Dauerschleife beginnt, in der zuerst die Zeile eingelesen wird. Wenn eine neue Zeile eingefügt wurde,
 28

wird die Cursorposition und die Zeile ausgegeben. Es wird die Zeile an den Semikolons zerteilt und
wenn die Zeile richtig erstellt wurde, wird die neue Cursorposition eingelesen und die Funktion
update_table aufgerufen. Danach wird wieder eine Zeile eingelesen. Wenn keine neue Zeile angefügt
wurde, wird die Datei geschlossen. Daraufhin wird RSync aufgerufen, die Datei wieder zum Lesen
geöffnet und der Cursor positioniert auf den Punkt einer möglichen neuen Zeile.

 Listing 8: Funktion update_table Teil 1

Am Anfang der Funktion aus Listing 8 wird eine Verbindung zur Datenbank hergestellt. Danach
werden die Zeiten der Datenbanktabelle herausgesucht, bei dem das richtige Rennen und die richtige
Tag-ID angegeben sind. Diese werden dann in ein Dataframe geschrieben und danach wird überprüft,
ob etwas in das Dataframe geschrieben wurde. Wenn dies nicht passiert ist, wird eine Warnung
herausgegeben. Danach werden nach und nach die Stellen des Dataframes darauf überprüft, ob
diese ohne Inhalt sind. Wenn ein leeres Feld gefunden wurde, dann wird dies ausgegeben. Dann wird
an diese Stelle in der Datenbanktabelle die Zeit geschrieben und ausgegeben, dass das Schreiben
erfolgreich war. Dieses ist für die weiteren Zeiten 1 bis 8 am Beispiel der ersten beiden Zeiten in den
Listing 9 und Listing 10 zu finden.

 29

Listing 9: Funktion update_table Teil 2

 Listing 10: Funktion update_table Teil 3

Wenn alle Zeiten beschrieben wurden, dann wird eine Warnung herausgegeben.

6.4.3 exporter.py
Nach den Wettkämpfen können mit Hilfe dieses Programmes alle Sportlerdaten in eine csv-Datei
exportiert werden, die dann von EasyWK weiter genutzt werden können.

 Listing 11: Funktion main

Bei diesem Programm wird auch am Anfang die main aufgerufen, die im Listing 11 zu erkennen ist.
Zuerst wird in dieser Funktion die Variable rennen als global gekennzeichnet, somit kann in der
Funktion auf die Variable zugegriffen werden. Danach wird kurz ausgegeben, was das Programm
machen soll. Hierbei werden auch für die PowerShell nützliche Kommandozeilenparameter erstellt,

 30

die die Benutzer beim Verwenden des Programms unterstützen sollen. Dann wird die übergebene
Rennenzahl übergeben, wenn sie vorhanden ist und sonst wird die Rennenzahl auf 1 gesetzt. Danach
wird die Zahl ausgegeben und die Funktion ExportDBTOCSVFile aufgerufen.

 Listing 12: Funktion ExportDBToCSVFile Teil 1

Bei dieser Funktion wird wieder als Erstes, wie im Listing 12 zu sehen, eine Verbindung zur
Datenbank hergestellt. Da die Spaltennamen der Datenbank und die Anzahl der Spalten nicht mit den
Benötigten für die csv-Datei übereinstimmen, müssen diese dann noch angepasst werden. Zum
Beispiel wird die Spalte Wk in Wettkampfnummer umbenannt und die Spalte ZE wird neu eingefügt.

 Listing 13: Funktion ExportDBToCSVFile Teil 2

 31

Wie im Listing 13 zu erkennen ist, werden danach die Daten aus SQL in ein Dataframe geschrieben.
Dort werden noch die Zeiten verarbeitet, damit diese am Ende richtig in die csv-Datei geschrieben
werden können. Vor der Konvertierung hat die Variable den Datentyp timedelta64[ns] und wird im
Format 0 days 00:00:00.000000000 ausgegeben. Für die Komptabilität mit EasyWK muss die Zeit
jedoch im Format 00:00:00,00 vorhanden sein, wofür die Konvertierung in einen anderen Datentyp,
hier datetime64[ns], notwendig ist.

Am Ende wird das veränderte Dataframe in eine csv-Datei übertragen.

6.5 Programme testen
Um ein Python Programm auszuführen, muss in die PowerShell ein Befehl eingegeben werden. Am
Anfang des Befehls ist das Stichwort python zu finden. Danach sind der jeweilige Programmname und
ggf. Optionen anzugeben.

Möglichkeiten, um die Funktionalität der einzelnen Python-Programme zu testen und zu überprüfen,
sind im Folgenden zu finden.

6.5.1 Importer Test
Um dieses Programm zu starten, muss zuerst die PowerShell als Administrator ausgeführt werden.
Danach wird mit dem Befehl cd C:\Users\RFID\Desktop\python in den Ordner gewechselt, wo die
Programme zu finden sind. Dann wird mit dem folgenden Befehl das Importer-Programm ausgeführt:

python importer.py C:\Users\RFID\Desktop\python\Meldeergebnis4SQL_Export.csv

Am Ende des Befehls ist der Pfad zur importierenden Meldedatei angegeben. Diese sieht zum
Beispiel wie folgt aus:

 Abbildung 30: Meldeergebnis4SQL_Export.csv

Hierbei gibt die Spalte K (Rennen) an, um welchen Lauf es sich handelt. Von diesem Programm
werden die Views und die Tabelle erstellt, die in der Abbildung 31 zu sehen sind.

 32

Abbildung 31: Tabelle und Views

Um zu überprüfen, ob die Tabelle richtig und vollständig angelegt wurde, sollte die in der Abbildung
32 markierten Schaltfläche ausgewählt werden.

 Abbildung 32: Aufruf der Tabelle

Danach erscheint in der Mitte auf dem Bildschirm die Tabelle, wie in der Abbildung 33 zu sehen ist.

 33

Abbildung 33: Tabellenansicht

Diese Tabelle sollte der importierten csv-Meldedatei entsprechen.

6.5.2 Tag-Listener Test
Zuerst sollte die PowerShell als Administrator ausgeführt werden, um das Tag-Listener Programm zu
testen. Danach wird mit dem Befehl cd C:\Users\RFID\Desktop\python in den Ordner mit dem
Programm gewechselt und einer der folgenden Befehle sollte eingegeben werden:

python tag-listener.py C:\DeltaCopy\media\tag.txt -rennen 1

python tag-listener.py C:\DeltaCopy\media\tag.txt -rennen 2

Der Pfad in den Befehlen ist der zur mit RSync kopierten Datei. Die Zahl nach –rennen ist die Auswahl
für den Lauf.

Ob ein Tag mit der dazugehörigen Zeit vom Raspberry Pi zur Datenbank auf dem Laptop übertragen
wurde, kann an den Meldungen auf der PowerShell erkannt werden.

An folgender Meldung ist zu erkennen, dass das Übertragen in die Datenbank funktioniert hat:

'E2004106160A0048200046DA;00:02:26,22;01:41:25,63\n'
['E2004106160A0048200046DA', '00:02:26,22', '01:41:25,63']
NOTE: Eintrag wird in: Startzeit geschrieben.
NOTE: Das Schreiben war erfolgreich.

Anhand folgender Meldung ist zu erkennen, dass die Zeit nicht in die Datenbank eingetragen werden
konnte:

'E2003412DC03011924165398;00:02:31,28;01:41:30,75\n'
['E2003412DC03011924165398', '00:02:31,28', '01:41:30,75']
WARNING: Dataframe was empty.
ID: E2003412DC03011924165398

 34