Sensoren und Aktoren über den Raspberry Pi mit Java erfassen und steuern

Inhaltsverzeichnis

Abkürzungsverzeichnis

Abbildungsverzeichnis

Quelltextverzeichnis

1 Die Einführung

2 Java auf Raspberry Pi. Addons und weitere Möglichkeiten
2.1 Das Pi4J Projekt
2.2 Direktzugriff über die Linux-Ebene mit Hilfe von sysfs

3 Die Sensoren
3.1 Temperatursensor und Drehpoti über AD-Wandler anschließen
3.2 Magnet und Taster

4 Die Aktoren
4.1 Die LED
4.2 Der Servomotor

5 Das Fazit

Literaturverzeichnis

A Anhang
A.1 Experimentierplatine
A.2 Schaltplan

B Anhang
B.1 Quelltext – Testprogramm „FileRW“
B.2 Quelltext – Treiberklasse „MCP3008“
B.3 Quelltext – Testprogramm „Poti“
B.4 Quelltext – Testprogramm „Temperatur“
B.5 Quelltext – Testprogramm „Taster“
B.6 Quelltext – Testprogramm „Magnetschalter“
B.7 Quelltext – Testprogramm „LED“
B.8 Quelltext – Testprogramm „pwm“ für Servomotor

Abkürzungsverzeichnis

Abbildung in dieser Leseprobe nicht enthalten

Abbildungsverzeichnis

Abbildung 2.1: Java Version

Abbildung 2.2: Die Ausgabe in der Konsole nach jedem Aufruf

Abbildung 3.1: command Bytes und das Ergebnis

Abbildung 3.2: Manipulation mit den Bytes in den Zeilen 44, 45 und 46

Abbildung 3.3: Konsolenausgabe des Programms „Poti“

Abbildung 3.4: Linearer Verlauf von drei Messpunkten

Abbildung 3.5: Temperaturmessergebnis

Abbildung 3.6: Hysterese des Hall-Sensors A1120

Abbildung 4.1: Der Drehwinkel in Abhängigkeit von der Pulsbreite

Abbildung 4.2: Die PWM Signale für drei Positionen des Servomotors

Abbildung A.1: Experimentierplatine mit Flachbandanschluss

Quelltextverzeichnis

Quelltext 3.1: Auszug aus dem Testprogramm „Temperatur“

Quelltext 3.2: Auszug aus dem Programm „Taster“

Quelltext 3.3: Auszug aus dem Programm „Magnetschalter“

1 Die Einführung

Die ersten Einplatinencomputer (SBC) sind in der Mitte der siebziger produziert worden (vgl. Ortmeyer 2014, S.2). Heute gibt es viele unterschiedliche Modifikationen von verschiedenen Herstellern. Die SBCs haben eine breite Palette an Einsatzmöglichkeiten, angefangen bei den einfachen Steuerungen bis hin zu voll automatisierten Regelsystemen, die in unterschiedlichen Bereichen des Lebens ihre Anwendung finden. Mit dem Einsatz von SBCs werden verschiedene Ziele verfolgt, die auf unterschiedlichen Wegen erreicht werden können. Die Projekte können mit bereits entwickelter Software erstellt oder es können eigene Programme geschrieben werden. Dafür gibt es viele Communitys, die diese Arbeit erleichtern.

Die vorliegende Ausarbeitung befasst sich mit dem Raspberry Pi (RPi). Dabei handelt es sich um einen SBC, der mit einem Betriebssystem aufgerüstet werden muss, damit jegliche Funktionalität vorhanden ist. Der RPi besitzt eine GPIO Schnittstelle, wo zusätzliche Hardwaremodule angeschlossen werden können. Die Module erweitern die Funktionen des RPi und geben ihm die Möglichkeit mit der Außenwelt mittels Sensoren und Aktoren zu interagieren. In erster Linie wurden diese Computer für Studenten, Schüler und Hobbybenutzer entwickelt, um ihnen das Erlernen der Programmiersprachen und der Hardwarearchitektur zu erleichtern (vgl. Ortmeyer 2014, S.2-4). Die meisten veröffentlichten Projekte kommen daher aus dem privaten Bereich. Es existiert aber auch eine Reihe von Entwicklungen, die einen großen Potenzial für den Einsatz in der Industrie haben, z. B. Miniserver, Router, Datenlogger, Messsysteme, Roboter usw.

Gegenüber den anderen SBCs hat der RPi einige grundlegende Vorteile. Er ist kostengünstig und erfüllt somit die Voraussetzung für Einsteiger. Wichtig für Anfänger ist ebenfalls das Vorhandensein vieler Open-Source-Projekte und großer Communitys, die den Einstieg in die Hardwareprogrammierung erleichtern. Der RPi ist mittlerweile mit Quadcore-Prozessor ausgestattet, was seine Leistungsfähigkeit verbessert hat. Ein weiterer Aspekt ist die sofortige Arbeitsbereitschaft nach der Betriebssysteminstallation, die nur wenige Minuten in Anspruch nimmt.

Um nun auf die GPIO Schnittstelle zugreifen zu können besteht eine Auswahl an mehreren Programmiersprachen. In dieser Ausarbeitung wurde die Auswahl auf Java begrenzt. Die Vorzüge von Java sind die große Bibliothek mit vielen Methoden, ihre Plattformunabhängigkeit sowie die gute Strukturierung der Sprache. Daher könnte Java, im Vergleich zu den anderen Programmiersprachen, einfacher in der Anwendung sein. Andererseits ist Java nicht für den unmittelbaren Zugriff auf die Hardwareebene geeignet, was die Programmierung erschweren kann. Ein geeignetes Verfahren zum Programmieren des RPi mit Java zu finden, stellt den Schwerpunkt dieser Arbeit dar.

2 Java auf Raspberry Pi. Addons und weitere Möglichkeiten

Für diese Ausarbeitung wurde ein RPi2 – Modell B verwendet, der auf einem System-on-Chip Broadcom BCM2836 basiert. Der Chip hat einen Prozessor mit vier Kernen je 900 MHz, einen Grafikprozessor mit VideoCore und dem OpenGL Treiber sowie eine FullHD Unterstützung mit 1080 Punkten. Des Weiteren ist auf der Platine ein SDRAM DDR2 Speicher mit 1024 MB angebracht. Der RPi verfügt über einen SD-Kartenslot, vier USB-Ports, einen HDMI-Ausgang, eine LAN-Fast-Ethernet-Buchse und eine Kombinationsbuchse für Audio und Composite Video Ausgänge. Die UART, SPI und I2C Schnittstellen sind ebenfalls vorhanden. Der RPi braucht eine Betriebsspannung von 5 Volt und mindestens 700 mA Strom, anderenfalls könnte das Gerät beim Betrieb mit einer aufwändigen Schaltung abstürzen.

Für die Installation wurde das 2 GB große Raspbian8-Betriebssystem (jessie) als eine Image-Datei von der Internetseite^[1] heruntergeladen und auf die SD-Karte mithilfe des Programms Win32 Disk Image^[2] kopiert. Danach wurde die SD-Karte in den Steckplatz des RPi eingeführt und das Gerät gestartet. (Vgl. Raspberry Pi Foundation: Raspbian und Setup o.J., o.S.) Bei dem ersten Start müssen Monitor, Tastatur und Maus an den RPi angeschlossen werden, um die grundlegenden Einstellungen durchzuführen. Ohne tief in die Konfigurierung einzusteigen wurden folgende Einstellungen vorgenommen:

- Dateisystem auf der SD-Karte erweitert, um wieder das volle Speichervolumen von 32 GB nutzen zu können
- SSH, SPI und I2C Schnittstellen frei geschaltet
- grafische Oberfläche dauerhaft eingeschaltet
- Grafikspeicher von 64 MB auf 128 MB geändert
- automatische Anmeldung deaktiviert, um root nutzen zu können
- root-Benutzer aktiviert
- Samba Server für filesharing installiert und eingerichtet
- VPN Server installiert, um den Fernzugriff zu ermöglichen

Wie der letzte Punkt bereits andeutet, kann der Zugriff auf RPi mittels eines VPN Programms über einen anderen Computer aufgebaut werden. Dies hat Vor- und Nachteile: ein Vorteil ist, dass kein Monitor, keine Tastatur und keine Maus angeschlossen werden müssen; ein Nachteil ist der durch die Netzwerkübertragung begrenzte Datentransfer, welcher die Bildqualität und die Reaktionszeit sehr einschränkt. Ein weiterer Nachteil ist die fehlende Möglichkeit die Symbole, wie geschweifte und eckige Klammer, zu übertragen, da die Alt Gr Taste für die Steuerung des VPN Programms reserviert ist. Für die Programmierung des RPi sind diese Begrenzungen nicht tolerierbar, daher wurde der direkte Anschluss gewählt.

Da der RPi für Python konzipiert wurde, ist mit dem Raspbian-Betriebssystem eine direkte Programmierung mit dieser Sprache möglich. Um den RPi aber mit Java programmieren zu können, müssen zusätzliche Softwaremodule installiert werden, zuerst das Java Development Kit (JDK). Das Paket beinhaltet neben der Virtuellen Maschine (VM), die notwendig ist, um Java-Programme betriebssystemunabhängig auszuführen, noch einen Debugger und einen Compiler. Die letzten zwei werden gebraucht, um auf dem RPi programmieren zu können. Es kann auch eine vereinfachte Java-Paket Version installiert werden – Java Runtime Environment, die nur die VM beinhaltet und somit nur die Ausführung der Java-Programme auf dem RPi ermöglicht. Es gibt zwei Wege das Java-Paket zu installieren, entweder automatisch per Konsolenbefehl apt-getinstall mit der Voraussetzung eines Internetzuganges oder manuell. Die erste Variante ist die einfachere Lösung. Zuerst wird eine Aktualisierung (update) durchgeführt, dann Java automatisch heruntergeladen und installiert:

sudoapt-get update &&sudoapt-getinstall oracle-java8-jdk

Bei der zweiten Variante muss zuerst das Paket von der Oracle Internetseite^[3] herunterladen und mit einem USB-Stick, FTP oder Netzwerk auf RPi übertragen werden.

Danach soll der Inhalt des Archivs ins opt Verzeichnis auf dem RPi entpackt werden. Das wird entweder über die Raspbian-Oberfläche mit Hilfe von Xarchiver gemacht oder mit dem folgenden Befehl:

sudo tar xvzf jdk-8u101-linux-arm32-vfp-hflt.tar.gz -C /opt

Jetzt kann die Installation durchgeführt werden. In der Konsole wird zum opt Verzeichnis gewechselt und folgende Befehle werden nacheinander ausgeführt:

sudo update-alternatives --install /usr/bin/javacjavac /opt/jdk1.8.0_101/bin/javac 1

sudo update-alternatives --install /usr/bin/javajava /opt/jdk1.8.0_101/bin/java 1

Nach der erfolgreichen Installation können die Quelldateien im opt Verzeichnis gelöscht werden. Mit folgenden Befehlen werden die Konfigurationen für die VM und den Compiler durchgeführt:

sudo update-alternatives –-configjavac

sudo update-alternatives --configjava

Nach der Befehlsausführung erscheinen in der Konsole nacheinander zwei Listen, wo zur Auswahl jeweils zwei Konfigurationsmöglichkeiten stehen. Für den automatischen Modus wird die erste ausgewählt, indem 0 eingegeben und mit Enter bestätigt wird. Wenn auf dem RPi eine vorherige Java Version installiert ist, muss manueller Modus mit der Java Version 8 ausgewählt werden. Für java und javac Konfigurationslisten wurde jeweils die Auswahlnummer 2 eingegeben. Nachdem die Laufzeitumgebung erfolgreich installiert wurde, können die Versionen von dem aktuell installierten Paket mit folgenden Befehlen angezeigt und überprüft werden:

java –version und javac –version

Abbildung in dieser Leseprobe nicht enthalten

Abbildung 2.1: Java Version

Für weitere Tests des Compilers sowie für die Ausführung von Programmen wird eine HalloWelt.java Datei mit dem Texteditor erstellt und gespeichert. Das kann entweder über die Oberfläche des Betriebssystems oder mit Nano-Texteditor erfolgen. Im letzten Fall wird in der Konsole folgender Befehl eingegeben:

Nano HelloWelt.java

Dadurch wird eine Datei in dem Verzeichnis abgelegt, aus dem der Befehl ausgeführt wurde.

In die Datei werden folgende Zeilen geschrieben, wobei der Klassenname dem Dateinamen entsprechen muss:

Class HalloWelt

{

Public static void main(String[] args)

{

System.out.println("Hallo Welt!");

}

}

Danach soll diese Eingabe gespeichert werden (im Nano-Texteditor mit der Tastenkombination Strg+O). Um die Datei zu kompilieren wird folgender Befehl verwendet:

javac HalloWelt.java

Wenn in der Konsole kein Fehler ausgegeben wird – wurde alles richtig gemacht und eine Datei mit dem gleichen Namen und der Endung class wird erzeugt: HalloWelt.class

Die erzeugte Datei ist gleichzeitig das Programm, welches per Befehl java HalloWelt gestartet werden kann. Nach der erfolgreichen Ausführung sollte in der Konsole Hallo Welt! erscheinen. In diesem Fall funktionieren die VM und der Compiler auf dem RPi einwandfrei.

Nachdem Java installiert ist, können Programme erstellt werden, die unter Raspbian-Betriebssystem mit Hilfe von VM ausgeführt werden können. Die Anforderung ist aber externe Hardware über die GPIO Schnittstelle ansprechen zu können. Da die Pins der GPIO Schnittstelle die direkten Abführungen vom ARM-Prozessor sind, müssen die Programme, die auf GPIO zugreifen, einen „nativen ARM-Code“ (Kleinert 2014, o.S.) erzeugen. Es sind mehrere Bibliotheken entwickelt worden, die den Zugriff auf Low-Level erleichtern. Die meisten sind in C oder C++ geschrieben, es existiert aber ein Projekt, das diesen Zugriff mit Java erlaubt: „Pi4J – Java I/O Library for the Raspberry Pi“^[4]. Das Projekt wurde von Robert Savage (im Folgenden Entwickler genannt) in Zusammenarbeit mit anderen Programmierern geschaffen, die die Wrappers komplett oder einige Teile des Quellcodes geschrieben haben. Die Bibliothek, bestehend aus mehreren Modulen, kann auf der o.g. Internetseite des Projektes als ein Archiv heruntergeladen und auf dem RPi installiert werden. (Vgl. Gludovatz o.J., o.S.) Neben der manuellen Installation kann die Bibliothek auch mit folgendem Konsolenbefehl auf dem RPi installiert werden, was auch von dem Entwickler empfohlen ist:

curl -s get.pi4j.com | sudobash

Mit diesem Befehl wird ein Bash-Skript heruntergeladen und ausgeführt. Das Skript führt mehrere Schritte durch – es lädt die Dateien herunter, installiert sie und fügt sie den lokalen Bibliotheken hinzu. Bei der manuellen Installation muss eine DEB-Datei^[5] mit Hilfe eines USB-Sticks bzw. eines Netzwerkes auf dem RPi gespeichert und über die Konsole mit folgendem Befehl ausgeführt werden:

Sudo dpkg -i pi4j-1.1.deb

(vgl. Savage: Pi4J Installation o.J., o.S.)

Um die Arbeitsweise der Bibliothek sowie alle anderen Funktionen testen zu können wurde eine einfache Schaltung auf der Europlatine aufgebaut. Alle GPIO Pins sind auf Streifenraster der Platine aufgeteilt und mit den jeweiligen Sensoren und Aktoren verbunden. Die Platine ist mit dem RPi durch ein 40-adriges Flachbandkabel verbunden. Die Abbildung der Experimentierplatine ist im Anhang A.1 zu finden und die Belegung der GPIO Schnittstelle mit Komponenten kann dem Schaltplan im Anhang A.2 entnommen werden. An dieser Stelle muss erwähnt werden, dass bei RPi verschiedene GPIO Bezeichnungen existieren, die sich abhängig von der Bibliothek unterscheiden. Für diesen und weitere Tests wird die Bezeichnung WiringPi verwendet.

In den installierten Bibliotheken sowie auf der Internetseite des Projektes gibt es eine Reihe von Beispielen (examples), die zum Testen verwenden werden können. Der Entwickler empfiehlt, für den Einblick bzw. die Einarbeitung in die Beispiele, sie mit folgendem Befehl zu kompilieren:

/opt/pi4j/examples/build

Nach der erfolgreichen Kompilierung können die einzelnen Programme aufgerufen und mittels angebundener Komponenten beobachtet oder auch gesteuert werden. Für den Test der Ein- und Ausgänge wird das Beispiel TriggerGpioExample verwendet. Zuerst wird in der Konsole zum Verzeichnis /opt/pi4j/examples gewechselt und mit folgendem Befehl das Programm ausgeführt:

sudo java -classpath .:classes:/opt/pi4j/lib/'*'TriggerGpioExample

Es erscheinen der Name des Programms und eine Textmeldung, dass für den Programmstart der Taster betätigt werden soll. Bei der Betätigung des Tasters wird jedes Mal eine Rückmeldung vom Programm ausgegeben:

- ->GPIO TRIGGER CALLBACK RECEIVED

Die LEDs reagieren auf den Taster wie folgt: die gelbe LED leuchtet, weil der Ausgang GPIO_04 auf High-Signal geschaltet wird, wenn beim Eingang ein High-Signal anliegt (beim Low-Signal ist das Verhalten umgekehrt). Die rote LED reagiert auf die Zustandsänderung beim Eingang, der Ausgang GPIO_05 wiederholt dabei den aktuellen Zustand (visuell gibt es keinen Unterschied zu der gelben LED). Die grüne LED blinkt in einem Sekundentakt, wenn der Eingang auf High-Signal geschaltet ist. Dies alles zeigt, dass die Bibliothek und die Beschaltung richtig funktionieren.

Jetzt können die Programme mit Java erzeugt und ausgeführt werden. Diese Aufgabe kann enorm erleichtert werden, wenn der Quellcode in einer Programmierumgebung erstellt wird. Es gibt eine große Auswahl an Programmierumgebungen, die Java unterstützen und auch für RPi geeignet sind. Angefangen bei den Texteditoren, die den Quelltext nur erkennen und hervorheben können, bis hin zu den komplexeren Programmen wie NetBeans oder Eclipse, die viele Funktionen beinhalten. Eclipse z. B. erleichtert nicht nur die Quellcodeerstellung, sondern auch die Einbindung der Bibliotheken und die Erstellung der grafischen Oberflächen. Besonders für einen Anfänger ist es vorteilhaft, wenn das Programm bei der Benutzung des Punktoperators einer Klasse die verfügbaren Methoden vorschlägt. Daher fiel die Wahl auf die Java-basierte Programmierumgebung Eclipse, die mit folgendem Konsolenbefehl installiert werden kann: sudoapt-getinstalleclipse

2.1 Das Pi4J Projekt

Das Pi4J Projekt stellt benutzerfreundliche, objektorientierte Programmierschnittstellen in einer Bibliothek bereit und ermöglicht so den Zugriff auf das GPIO Interface des RPi. Die Bibliothek distanziert den Benutzer von der Hardwareebene und macht es ihm möglich, sich auf die Programmierung der Anwendung zu konzentrieren. (Vgl. Savage: Index o.J., o.S.) Die Bibliothek funktioniert als ein Umsetzer zwischen dem Java-Programm und dem Low-Level des RPi. Auf der Basis der vorhandenen kurzen Programme, die für unterschiedliche Anwendungen geeignet sind, ist das Erstellen der Programme mühelos möglich. Der Quellcode dieser Bibliothek kann von der Internetsite github^[6] heruntergeladen werden.

Die Ordnerstruktur der Bibliothek ist in bestimmte Verzeichnisse unterteilt: core, device, distribution, example, gpio-extension und native. Dort befinden sich Dateien, die in ihrer Funktion der jeweiligen Verzeichnisbezeichnung entsprechen. Beispielsweise in dem Verzeichnis namens extension liegen die nach Herstellertyp sortierten Provider, die eine Verbindung mit bestimmten Erweiterungsgeräten ermöglichen. Zu solchen Erweiterungsgeräten zählen beispielsweise die Analog-Digital Wandler (AD-Wandler) MCP3002 von Microchip oder ADS1015 von Texas Instruments. Mithilfe einer Provider-Auswahlliste können die angeschlossenen Geräte in der eigenen Anwendung genutzt werden, ohne in die Low-Level Programmierung einsteigen zu müssen. Ein weiterer Ordner mit der Bezeichnung device hat in seinem Unterverzeichnis namens component eine Auswahl an fertigen Programmen für unterschiedliche Sensoren und Aktoren, z. B. für LCD-Display, Servomotor, LED, Relay, Temperatur u.a. Damit gibt der Entwickler dem Benutzer eine ganze Reihe an einfachen Programmen in die Hand, die sofort eingesetzt werden können. Selbst wenn eine Adaptierung an die eigene Schaltung notwendig ist, kann diese ohne großen Aufwand erfolgen. Der Entwickler konzentriert sich mit seinen Produkten vor allem auf die Anfänger und erleichtert ihnen damit den ersten Einstieg in die Hardwareprogrammierung.

Ein Bild^[7] auf der Internetseite des Entwicklers zeigt die Struktur der Bibliothek und die Aufteilung in zwei Plattformen. Innerhalb der nativen Plattform werden die Daten von dem Java- Programm verarbeitet und an die Bibliothek WiringPi weitergegeben. Diese Bibliothek ist ein Grundgerüst für das Pi4J Projekt und ermöglicht die Verbindung zum ARM-Code. Zu beachten ist, dass der Block libpi4j.so, der innerhalb der nativen Plattform zu sehen ist, nicht nur auf WiringPi Bibliothek zugreift, sondern auch auf Liniux sysfs. Die letzte Zugriffsoption wird im nächsten Kapitel genauer betrachtet.

2.2 Direktzugriff über die Linux-Ebene mit Hilfe von sysfs

Wie bereits erwähnt, gibt es neben der Zugriffsmöglichkeit auf die GPIO Schnittstelle mittels der Pi4J Bibliothek, noch eine weitere – über das virtuelle Dateisystem von Linux. Dieses ist ein Bestandteil des Linux-Kernels und dient der Systemverwaltung in Form von Dateien. Die Dateien haben unterschiedliche Bestimmungen und sind auf gewisse Art und Weise geordnet: reguläre Dateien, Verzeichnisse, Gerätedateien, Sockets usw.

In dem Verzeichnis /sys/class/gpio befinden sich zwei Dateien export und unexport, die die GPIO Schnittstelle darstellen. Der Zugriff auf diese Dateien kann nur mit root-Rechten erfolgen, entweder durch die Anmeldung als root-User oder durch die Ausführung des Befehls sudo (super user do). Das gilt für alle Systemfiles und dient der Sicherheit, um eine unabsichtliche Löschung der Dateien zu vermeiden. Um nun einen GPIO Pin ansteuern zu können wird in der Konsole folgender Befehl ausgeführt:

sudo echo 4 > /sys/class/gpio/export

Der Operator echo wird bei den Terminal-Befehlen benutzt und gibt die Zeichenketten in die Konsole oder in die Datei aus. In der oberen Befehlszeile wird die Ziffer 4 als ein Beispiel in die Datei export geschrieben. Nach der Ausführung erscheint im Verzeichnis /sys/class/gpio, zusätzlich zu den existierenden drei Dateien, noch eine weitere – gpio4. In dem Ordner gpio4 liegen mehrere Dateien: device, subsystem, active_low, direction, edge, uevent und value, wo die ersten zwei die virtuellen Systemdateien sind und die anderen für die Steuerung des GPIO Pins benutzt werden. Die Pin Nummerierung entspricht dabei der BCM Nummerierung. Als nächstes wird die Richtung festgelegt. In die Datei direction wird out für den Ausgang geschrieben:

sudo echo out > /sys/class/gpio/gpio4/direction

Für den Eingang wird in statt out geschrieben:

sudo echo in> /sys/class/gpio/gpio4/direction

Nachdem die Ausgangsrichtung festgelegt wurde, kann der Pegel des Pins definiert werden. Dafür wird in die Datei value eine 1 geschrieben:

sudo echo 1 > /sys/class/gpio/gpio4/value

Nur in dieser Reihenfolge wird der Pin mit der Spannung belegt. Würde zuerst value statt direction eingegeben, würde das Betriebssystem einen Fehler ausgeben, da die Richtung noch nicht bekannt ist. Der Inhalt aller Konfigurationsdateien kann mit einem Texteditor ausgelesen werden, z. B. mit dem Standardeditor Leafpad. Alternativ kann die Datei auch per Konsolenbefehl ausgelesen werden:

sudo cat /sys/class/gpio/gpio4/value

Der Inhalt sollte den geschriebenen Werten entsprechen, wobei in der direction Datei out und in der value Datei eine 1 stehen sollten. Dieselbe Methode wird verwendet, um auch den als Eingang programmierten Pin auszulesen. Wenn der Pin nicht mehr benutzt wird, muss er deaktiviert (unexport) werden:

sudo echo 4 > /sys/class/gpio/unexport

Wie es sich aus den anderen Dateinamen im Ordner gpio4 auslesen lässt, können noch die Flanke (edge), das Ereignis (uevent) und die Zustandsumkehrung (active_low) parametriert bzw. ausgelesen werden. Die Dateien werden nach dem o.g. Prinzip beschrieben oder gelesen. (Vgl. Hussam al-Hertani 2012, o.S.) Mit all diesen Befehlen wird ein einfaches Java-Programm erstellt, welches die GPIO Schnittstelle mit Hilfe von FileWriter und sysfs steuert. Für das Programm wurde GPIO_23 gewählt, da an der Testplatine an dem gleichen Pin eine LED angeschlossen ist.

Der Code des ganzen Beispielprogramms ist im Anhang B.1 zu finden. In den Zeilen 11 und 12 werden zuerst FileWriter und die File Instanzen angelegt. Die Klassen gehören zu java.io Bibliothek, die in der 1. Zeile bereits importiert wurde. In der 17. Zeile wird der Instanz verz der Pfad /sys/class/gpio/ übergeben und in der Zeile 19 dann der Inhalt in Form einer Liste gespeichert. In der Liste werden nur die Namen der sich dort befindenden Ordner und Dateien gespeichert. Die Länge des Arrays wird in der Zeile 22 bestimmt und in der if Anweisung zur Prüfung benutzt. Wenn die Anzahl der Dateien ungleich drei ist, wird die Zahl 23 in die Datei unexport geschrieben und GPIO_23 somit deaktiviert. Die Prüfung ist nur dann notwendig, wenn der Pin vorher vom anderen Programm aktiviert wurde. Da in die export Datei nicht nochmals die gleiche Zahl geschrieben werden darf, was zu einem Fehler führen würde, wird diese Handlung abgefangen.

In der Zeile 28 werden das Verzeichnis und der Dateiname export an die Instanz ausgabe der Klasse FileWriter übergeben. In der weiteren Zeile wird mit Hilfe der write Methode dieser Klasse die Zahl 23 in die Datei export geschrieben, um den Pin zu exportieren. Auch hier, wie bei der if Anweisung, wird der Schreibblock mit der Methode .close() geschlossen, damit die Zeichenkette in der Datei abgespeichert wird. Erst nach dem Speichern wird der neue Ordner mit dem Namen gpio23 im Verzeichnis /sys/class/gpio/ angelegt.

Weiter fängt der Schreibblock für die Datei namens direction an, wo die Richtung festgelegt wird. Hier wird ebenfalls mit der close Methode abgeschlossen. Ab der 35. Zeile fängt die while Schleife an, wo sie nur 10 Mal durchläuft. Innerhalb der Schleife befinden sich zwei Schreibblöcke, die in der Datei value eine 1 oder eine 0 abspeichern. Zwischen diesen Blöcken ist eine Pause mit Hilfe von der Thread.sleep Methode eingebaut, die die LED für eine halbe Sekunde aufleuchten bzw. erlöschen lässt. Somit wird die am GPIO Port 23 angeschlossene LED zehn Mal im 0,5 Sekundentakt aufleuchten. Anschließend wird der ausgelesene Verzeichnisinhalt, zur Prüfung, mit der for Schleife und der println Methode in der Konsole ausgegeben.

Abbildung in dieser Leseprobe nicht enthalten

Abbildung 2.2: Die Ausgabe in der Konsole nach jedem Aufruf

3 Die Sensoren

Die Sensoren sind Messaufnehmer, die die physikalischen Messgrößen in die elektrischen Signale umwandeln und einem Messsystem bereitstellen. Sie können nach ihrem Messverfahren (optisch, induktiv, mechanisch, fluidisch usw.), nach den jeweiligen Messgrößen (Temperatur, Druck, Lichtstärke, Schall, magnetischer Fluss, Gewicht, Drehzahl, Beschleunigung u. ä.) und auch nach dem Ausgangssignal (analog, digital und binär) unterschieden werden. Alternativ können die Sensoren auch in mechanische und nicht mechanische unterteilt werden. Die ersten messen folglich nur mechanische Messgrößen wie Gewicht, Druck, Position usw., die zweiten messen alle nicht mechanischen Größen wie Temperatur, Licht, elektromagnetische Effekte u.a. (Vgl. ITWissen.info: Sensor o.J., o.S.)

Die meisten Messaufnehmer, die heute eingesetzt werden, sind mit einer digitalen Schnittstelle ausgestattet, was ihre Benutzung enorm erleichtert. Bei der Aufnahme analoger Werte werden diese mittels Umsetzer (auch Umformer, Signalwandler, Messumformer, Signalumsetzer genannt) umgewandelt und an das Endgerät bzw. den Empfänger angepasst. Die Funktion des Umsetzers besteht darin das empfangene Signal zu verstärken und in ein Einheitssignal (z. B. 4-20 mA, 0-20 mA und 0-10 V) oder auf einen digitalen Ausgang (z. B. eine serielle Schnittstelle) umzusetzen. Oft bilden der Sensor und der Wandler eine Einheit. (Vgl. Karrasch 2007, S.5-12 und Trier 2011, S.2)

Die Sensoren werden für verschiedene Aufgaben in den unterschiedlichen Bereichen verwendet, z. B. in der Medizin, der Industrie und in nahezu allen elektronischen Geräten. Für diese Ausarbeitung werden sie an dem RPi gebraucht und dienen als „Sinnesorgane“ (Karrasch 2007, S.5) für die Steuerung. Benutzt werden Sensoren ohne Umformer, die durch Java-Programmierung ausgelesen werden sollen. Darauf wird in den nächsten zwei Kapiteln genauer eingegangen, wobei im Kapitel 3.1 analoge Sensoren betrachtet werden, die eine bestimmte Problematik darstellen, weil der RPi keine analoge Schnittstelle besitzt. Im Kapitel 3.2 werden dann die digitalen Sensoren aufgegriffen.

3.1 Temperatursensor und Drehpoti über AD-Wandler anschließen

Der RPi besitzt keinen AD-Wandler, was als ein Nachteil angesehen werden kann, da an der Stelle, wo analoge Sensoren angeschlossen werden sollen, unbedingt, ein AD-Wandler zum Einsatz kommen muss. Somit sind einige Erweiterungsplatinen entstanden, die einen oder mehrere AD-Konverter am Bord haben. Alternativ kann auch ein AD-Wandler Baustein benutzt werden. Verbreitet sind Bausteine von Microchip^[8] – MCP3002 2-Kanal oder 3008 8-Kanal, mit jeweils 10 Bit Auflösung.

Eine der wichtigen Spezifikationen des AD-Wandlers ist das Vorhandensein einer Kommunikationsschnittstelle, die zur Übertragung von Daten benutzt wird. Für die Art Aufgaben, die auch in dieser Ausarbeitung gestellt sind, werden des Öfteren die Schnittstellen I2C und SPI verwendet, vor allem auf einer Platine oder innerhalb eines Systems. Der ADC Baustein MCP3008, der in dieser Untersuchung zum Einsatz kommt, besitzt eine SPI Schnittstelle. Diese Schnittstelle ist ein Master-Slave-Bussystem, das von Motorola entwickelt wurde. Ist nur ein Slave-Gerät von mehreren möglichen vorhanden, werden minimal vier Leitungen gebraucht:

1) Serial Clock (SCLK) – eine Taktleitung, die die Übertragungsgeschwindigkeit je nach Baustein bis maximal 70 MHz vorgibt;
2) Master Output, Slave Input (MOSI) – eine Datenleitung von Master in Richtung Slave;
3) Master Input, Slave Output (MISO) – eine Datenleitung von Slave in Richtung Master;
4) Chip select (CS) – gibt vor, welcher Slave-Chip kommunizieren soll.

Da die Schieberegister von den beiden Seiten – Master und Slave – benutzt werden, und es zwei Datenleitungen für jede Richtung gibt, erfolgt daher die Übertragung synchron-bidirektional, die Daten werden also gleichzeitig in beide Richtungen geschoben.

Die AD-Wandler werden vom Master konfiguriert, deshalb werden unterschiedliche, bausteinabhängige Parameter übertragen, z. B. die Auflösung, die Verstärkung, die Wortlänge, der Kanal bzw. die Anzahl der Kanäle, die Abtastrate, SPI mode u.a. SPI mode bezeichnet die Art der Übertragung, wo zwischen der fallenden und der steigenden Flanke bei den Daten- und Taktleitungen unterschieden wird. Insgesamt gibt es vier modes, die mit 0, 1, 2 und 3 gekennzeichnet sind. (Vgl. Kugelstadt 2009, o.S.) Bei dem MSCP3008 Baustein wird ein SAR-Verfahren angewendet, wobei die Eingangsspannung mit der Referenzspannung verglichen und die Referenzspannung der Eingangsspannung stufenweise angenähert wird. Die durchlaufenen Stufen (Quantisierungsstufen) ergeben ein Bitmuster. Die Bitreihenfolge hat eine bestimmte Auflösung, die sich je nach Baustein unterscheidet. (Vgl. ITWissen.info: SAR o.J., o.S)

Ein weiterer wichtiger Parameter ist die Abtastrate, die in Samples per Second (SPS) gemessen wird. Wenn die Spannung in die Quantisierungsstufen aufgeteilt wird, dann wird der zeitliche Verlauf in die zeitdiskrete Form durch Sample-and-Hold-Stufe umgewandelt. Nach der Diskretisierung sieht das Signal wie eine Reihe von Punkten aus, an denen die Spannungswerte entsprechend der Quantisierung aufgenommen wurden. Die maximale Abtastrate des MCP3008 Bausteins beträgt 200 kSPS (200.000 SPS) bei der Versorgungsspannung von 5 Volt. Wichtig bei dem Abtastverfahren ist dem Abtasttheorem zu folgen, welches besagt, dass die Abtastrate mindestens das Zweifache von der maximalen Frequenz des Signals betragen soll. Anderenfalls würde das zur Unterabtastung und zum verfälschten Ergebnis führen. (Vgl. Zinke o.J., o.S.)

Da es in dem Datenblatt zum MCP3008 Baustein keine Hinweise für die Außenbeschaltung gibt, wird er direkt am RPi, wie auf dem Schaltplan im Anhang A.2 dargestellt, angeschlossen. Nachdem auch der AD-Wandler mit dem Potentiometer am RPi angeschlossen ist, kann mit der Programmierung begonnen werden.

Wie die command Bytes generiert werden sollen, damit die Kommunikation stattfinden kann, wird in dem 5. Kapitel des o.g. Datenblattes beschrieben. Die Abbildung 3.1 verdeutlicht die Belegung der Konfigurationsbytes vor und nach der Konvertierung: command[0] trägt den Startbit, command[1] trägt die Information für die single-ended Konvertierung und für die Kanalnummer, command[2] trägt nur die dummy Bits.

Abbildung in dieser Leseprobe nicht enthalten

Abbildung 3.1: Command Bytes und das Ergebnis

[...]

---

^[1] https://www.raspberrypi.org/downloads/

^[2] https://sourceforge.net/projects/win32diskimager/

^[3] http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

^[4] http://pi4j.com/

^[5] http://get.pi4j.com/download/pi4j-1.1.deb

^[6] https://github.com/Pi4J/pi4j

^[7] http://pi4j.com/dependency.html

^[8] www.microchip.com