Sie sind auf Seite 1von 127

Anwendung des Raspberry Pi in Forschung und Lehre

Bachelor-Thesis

Nico Maas

Erstgutachter: Prof. Dr. Helmut G. Folz


Einreichung: 30. September 2014
Selbständigkeitserklärung
Ich versichere, dass ich die vorliegende Arbeit (bei einer Gruppenarbeit: den entspre-
chend gekennzeichneten Anteil der Arbeit) selbständig verfasst und keine anderen als
die angegebenen Quellen und Hilfsmittel benutzt habe.
Ich erkläre hiermit weiterhin, dass die vorgelegte Arbeit zuvor weder von mir, noch
von einer anderen Person an dieser oder einer anderen Hochschule eingereicht wurde.
Darüber hinaus ist mir bekannt, dass die Unrichtigkeit dieser Erklärung eine Beno-
tung der Arbeit mit der Note „nicht ausreichend“zur Folge hat und einen Ausschluss
von der Erbringung weiterer Prüfungsleistungen zur Folge haben kann.

Saarbrücken, 30. September 2014

Nico Maas

iii
Zusammenfassung
Linux Einplatinen Computer sind seit dem Erscheinen des Raspberry Pi in 2012 immer
präsenter in der IT und ermöglichen die schnelle und unkomplizierte Verbindung und
Steuerung realer Hardware mittels modernen Hochsprachen wie C, Python oder Ja-
va. Die nachfolgende Arbeit soll an konkreten Beispielen versuchen, die Möglichkeiten
des damit eröffneten „Physical Computing“, zur leichteren Darstellung komplexerer
Lehrinhalte zu verwenden und damit den Lernerfolg nachhaltig zu steigern.

v
Any sufficiently advanced technology
is indistinguishable from magic.
— Arthur C. Clarke [4]

Danksagung
Für die geleistete Hilfe möchte ich mich in aller Form bei meinem Betreuer, Prof. Dr.
Helmut G. Folz, dem Labor der Elektrotechnik, namentlich Dipl.-Ing. Thomas Bertel,
sowie Prof. Dr. Peter Sturm, dem Team der PiAndMore und meiner Familie bedanken.

vii
Inhaltsverzeichnis

Inhaltsverzeichnis ix

1 Einleitung 1

2 Plattform Evaluation 3
2.1 Raspberry Pi und BeagleBone Black . . . . . . . . . . . . . . . . . . . . . 3
2.1.1 Raspberry Pi Modell B+ . . . . . . . . . . . . . . . . . . . . . . . . 3
2.1.2 BeagleBone Black Revision C . . . . . . . . . . . . . . . . . . . . . 4
2.1.3 Vergleich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Raspberry Pi Modelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2.1 Unterschiede Modell A und B . . . . . . . . . . . . . . . . . . . . . 7
2.2.2 Modell B pre 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2.3 Modell A/B 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2.4 Compute Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2.5 Modell A+/B+ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3 Grundlagen und Installation 9


3.1 Peripherie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.1.1 SD Karte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.1.2 Netzteil mit Micro USB Anschluss . . . . . . . . . . . . . . . . . . 10
3.1.3 Netzwerkkabel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.1.4 HDMI auf DVI Adapterkabel / Display mit DVI Eingang . . . . 10
3.1.5 Weitere Komponenten . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2 Anschluss des Raspberry Pi . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.3 Raspbian . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.4 Installation mittels Image . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.4.1 Image downloaden . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.4.2 Formatieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.4.3 Image kopieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.4.4 Backup und Wiederherstellung . . . . . . . . . . . . . . . . . . . . 14
3.5 Installation mittels noobs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.5.1 noobs downloaden . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.5.2 Formatieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.5.3 noobs kopieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.5.4 Raspbian mit noobs installieren . . . . . . . . . . . . . . . . . . . . 16
3.5.5 Vorteile von noobs . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

ix
4 Konfiguration von Raspbian 19
4.1 Erster Boot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.1.1 raspi-config . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.2 WLAN Zugriff / eduroam . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.3 Updates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.3.1 rpi-update . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.3.2 apt-get . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.4 Einrichtung Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.4.1 Vorbereitung des I²C / SPI Bus . . . . . . . . . . . . . . . . . . . . 25
4.4.2 Vorbereitung der seriellen Schnittstelle . . . . . . . . . . . . . . . 26
4.5 Einrichtung Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.5.1 Installation von wiringpi2 . . . . . . . . . . . . . . . . . . . . . . . 27
4.5.2 Installation von wiringpi2-python . . . . . . . . . . . . . . . . . . 28
4.5.3 Test des SPI Bus (Optional) . . . . . . . . . . . . . . . . . . . . . . 29

5 GPIO Schnittstelle 31
5.1 Aufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.2 Sicherheitshinweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
5.2.1 Logik Level . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
5.2.2 Sicherungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
5.2.3 Belastbarkeit der Pins / 3,3 Volt Schiene . . . . . . . . . . . . . . . 32
5.2.4 Belastbarkeit der 5 Volt Schiene . . . . . . . . . . . . . . . . . . . . 32
5.2.5 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.3 GPIO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.3.1 GPIO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.3.2 PWM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.3.3 I2C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.3.4 I2S . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.3.5 SPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.3.6 Serial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.4 Das Erweiterungsboard . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.4.1 Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.4.2 Routing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.4.3 Testprogramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

6 Bash Programmierung 43
6.1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
6.1.1 Simon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
6.1.2 Ablaufdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.2 Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.2.1 Erweiterungsboard und Hilfsfunktionen . . . . . . . . . . . . . . 45
6.2.2 LED Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
6.2.3 Switch Eingabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
6.3 Abschluss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

x
7 Python Programmierung 49
7.1 Arbeiten auf dem Raspberry Pi . . . . . . . . . . . . . . . . . . . . . . . . 49
7.1.1 Python 2 / Python 3 . . . . . . . . . . . . . . . . . . . . . . . . . . 49
7.1.2 Programmierung mittels IDLE . . . . . . . . . . . . . . . . . . . . 49
7.1.3 Programmierung mittels CLI . . . . . . . . . . . . . . . . . . . . . 50
7.2 Grundlagen der Python Programmierung . . . . . . . . . . . . . . . . . . 50
7.2.1 Ausführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
7.2.2 Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
7.2.3 Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
7.2.4 Vergleiche und Schleifen . . . . . . . . . . . . . . . . . . . . . . . . 53
7.2.5 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
7.2.6 Bibliotheken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
7.3 Verwendung der GPIO mittels Python . . . . . . . . . . . . . . . . . . . . 57
7.3.1 Digitale Ausgabe: LEDs . . . . . . . . . . . . . . . . . . . . . . . . 57
7.3.2 Übungsaufgabe zur digitalen Ausgabe . . . . . . . . . . . . . . . 58
7.3.3 Digitale Eingabe: Schalter . . . . . . . . . . . . . . . . . . . . . . . 58
7.3.4 Übungsaufgabe zur digitalen Eingabe . . . . . . . . . . . . . . . . 58
7.3.5 Abschlussprojekt GPIO: Binärzähler . . . . . . . . . . . . . . . . . 59
7.4 Verwendung des I2C Bus mittels Python . . . . . . . . . . . . . . . . . . . 60
7.4.1 Adressierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
7.4.2 Register des Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . 61
7.4.3 Interpretation des Temperaturwertes . . . . . . . . . . . . . . . . 62
7.4.4 Übungsaufgabe zur Verwendung des I2C Bus . . . . . . . . . . . 62
7.5 Verwendung des SPI Bus mittels Python . . . . . . . . . . . . . . . . . . . 63
7.5.1 Adressierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
7.5.2 Kommunikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
7.5.3 Übungsaufgabe zur Verwendung des SPI Bus . . . . . . . . . . . 66

8 Mathematica 69
8.1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
8.2 Benutzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
8.2.1 Beispiele Free-form input . . . . . . . . . . . . . . . . . . . . . . . 70
8.2.2 Beispiele Wolfram Alpha query . . . . . . . . . . . . . . . . . . . . 70
8.3 Verwendung mittels Erweiterungsboard . . . . . . . . . . . . . . . . . . . 72

9 Fazit 75
9.1 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
9.2 Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

Literatur 77

Abbildungsverzeichnis 79

Tabellenverzeichnis 80

xi
Listings 81

Abkürzungsverzeichnis 82

A Vorgefertigtes Raspbian Image 85


A.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
A.2 Zusätzlich installierte Pakete . . . . . . . . . . . . . . . . . . . . . . . . . 85

B Raspberry Pi Hardware HTW 87


B.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

C Erweiterungsboard 89

D Code Listings 91
D.1 boardTest.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
D.2 gpio.sh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
D.3 demoLed.sh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
D.4 demoSwitch.sh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
D.5 simon.sh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
D.6 uebungAusgabe.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
D.7 uebungEingabe.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
D.8 binaryCounter.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
D.9 lm75b.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
D.10 uebungI2C.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
D.11 mcp3002.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
D.12 mcp3002lib.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
D.13 uebungSPI.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
D.14 wpi.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
D.15 wpi.tm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

xii
1 Einleitung
Mit dem Erscheinen des Raspberry Pi im Februar 2012 war zum ersten Mal ein klei-
ner, kostengünstiger und dennoch leistungsfähiger Linux Einplatinen Computer ver-
fügbar. Der ursprünglich zur Fortbildung von Kindern, im IT Bereich gedachte Rech-
ner, etablierte sich in kürzester Zeit im Umfeld von Universitäten, Industrie sowie im
Hobby und Freizeit Bereich. Andere Firmen entdeckten die potenziellen Möglichkeiten
des neuen Absatzmarktes und entwickelten konkurrierende Plattformen mit teils un-
terschiedlichen Zielsetzungen und Möglichkeiten. Dazu zählen der BeagleBone Black,
Intels Galileo, SECO / Aidilabs UDOO, Hardkernels Odroid sowie Adaptevas Paral-
lella - um nur einige wenige zu nennen. All diese Plattformen haben gemeinsam, dass
sie dazu genutzt werden können, als Lehrplattform für den Bereich des sogenannten
„Physical Computing“ zu dienen. Beim Physical Computing ist die Software in der La-
ge durch eine spezielle Hardware Schnittstelle (General-purpose input/output (GPIO))
sowohl Eingaben aus der Umwelt zu empfangen, als auch selbst Ausgaben zu erzeu-
gen. Dies könnte z.B. die Verwendung eines Schalters, Ultraschallsensors oder einer
Lichtschranke für die Eingabe, und einer LED, einem Display oder eines Motors für
die Ausgabe sein. Da durch verschiedene Frameworks und Libraries diese Schnittstel-
len nicht nur mittels spezieller Kommandos bedient werden können, sondern auch in
Standardsprachen wie z.B. Bash, C, Java oder Python verfügbar sind, ergibt sich damit
die Möglichkeit einer professionellen Entwicklung und die Integration dieser Einplati-
nen Computer in ganze Produkte und Automaten.
In der nachfolgenden Arbeit soll aufgezeigt werden, wie ein solcher Linux Einpla-
tinen Computer im Bereich der Forschung und Lehre dazu genutzt werden kann, um
Studenten konkrete Lerninhalte leichter zu vermitteln. Dies beinhaltet die Evaluation
des geeigneten Produktes aus der Vielzahl der konkurrierenden Systeme, die korrekte
Installation und Konfiguration sowie die konkrete Nutzung in verschiedenen Projekten
mit Verknüpfung zu den Vorlesungen an der HTW Saar.
Um diese Umsetzung einfacher zu gestalten, wurden im Rahmen dieser Thesis ei-
ne eigene Erweiterungsplatine für den Raspberry Pi entworfen und gefertigt, wodurch
auch die Lehre im Bereich Hardware naher Anwendungen, wie z.B. dem Inter-Integrated
Circuit (I2C) oder Serial Peripheral Interface (SPI) Bus möglich wird.
Verwendung finden sollen die vorgestellten Aufgaben in einem breitgefächerten Spek-
trum an Vorlesungen: „Betriebssystem Einführung“ (Bash Programmierung), „System-
sicherheit und Management“ (Python Einführung), „Digitaltechnik“ (Python: 4-bit Zäh-
ler), „Rechnerarchitektur“ und „Mikroprozessortechnik“ (SPI und I2C), „Mathematik
1-3“, „Informatikgrundlagen“ und „Graphentheorie“ (Mathematica).
Obwohl bereits einige Vorlesungsbereiche damit aufgegriffen werden, sind die Mög-
lichkeiten die dieser Einplatinen Computer bietet damit keinesfalls erschöpft und könn-

1
1 Einleitung

ten in Arbeiten anderer Studenten fortgeführt und ergänzt werden.

2
2 Plattform Evaluation
2.1 Raspberry Pi und BeagleBone Black
Wie bereits erwähnt gibt es neben dem Raspberry Pi noch zahlreiche weitere Kon-
kurrenzprodukte welche ähnliches leisten. Der direkte Konkurrent allerdings ist das
von Texas Instruments vorgestellte BeagleBone Black. Nachfolgend werden die beiden
Plattformen mit ihren Vor- und Nachteilen verglichen und auf die besondere Eignung
im Bereich der Lehre untersucht.

2.1.1 Raspberry Pi Modell B+


Der Raspberry Pi ist ein Einplatinen Computer mit der ungefähren Grundfläche ei-
ner Kreditkarte, nutzt Linux als Betriebssystem und ist zum Preis von knapp 33 e er-
hältlich. Er verwendet ein Broadcom BCM2835 System on a chip (SoC), welches einen
700 MHz starken ARM1176JZFS (ARM11/ARMv6) Prozessor beinhaltet sowie die 24
GFlops starke Videocore IV Grafikeinheit und 512 MB Arbeitsspeicher. Trotz des ge-
ringen Preises verfügt der Raspberry Pi über 4 USB Anschlüsse, einen 100 MBit Netz-
werkanschluss, einen Full HD fähigen HDMI Anschluss, sowie einen analogen Audio
und Cinch Video Ausgang (über ein Adapterkabel). Insgesamt stehen 40 GPIO Pins zur
Verfügung, welche neben generischen Ein- und Ausgängen auch als spezielle Schnitt-
stellen wie Serial, I2C, Inter-Integrated Sound (I2S) und SPI genutzt werden können.
Eine Besonderheit bietet der Raspberry Pi mit den Camera Serial Interface (CSI) bzw.
Display Serial Interface (DSI): Diese Schnittstellen bieten direkten Anschluss einer spe-
ziellen Kamera beziehungsweise eines demnächst verfügbaren TFT Displays an die Vi-
deocore IV Grafikeinheit. Durch den Anschluss der eigens entwickelten Kamera kön-
nen trotz der vergleichsweise geringen CPU Leistung Photos in 2592 x 1944 Pixel, re-
spektive Video ins Full HD Auflösung (1920 x 1080 Pixel) aufgezeichnet und mit Filtern
versehen werden. Weiterhin kann die GPU auch in begrenztem Umfang zur Beschleu-
nigung von eigenem Programmcode verwendet werden. Eine Micro SD Karte dient als
Massenspeicher und die Stromversorgung erfolgt mittels Micro USB Netzteil.
Als Betriebssystem kommt hauptsächlich Raspbian, eine für den ARMv6 optimierte
Version von Debian zum Einsatz. Weiterhin sind Versionen von Arch Linux (Arch), Fe-
dora (Pidora), XBMC (XBian, OpenElec, Raspbmc), RiscOS, Android und zahlreichen
anderen Betriebssystemen zum Download verfügbar. Die Verwendung des Echtzeitbe-
triebssystems QNX ist allerdings wegen des fehlenden Board Support Packages nicht
möglich.
Die Entwicklung des Einplatinen Computers wurde von Eben Upton geleitet. Die
Idee zu diesem Projekt kam ihm während seiner Zeit als Director of Studies in Compu-

3
2 Plattform Evaluation

ter Science am St John’s College (Universität Cambridge). Er stellte mit seinen Kollegen
fest, dass die Anzahl der Studienbewerber im Bereich der Informatik seit dem Beginn
des Jahrtausend stetig rückgängig waren. Die heutigen Jugendlichen und Kinder wür-
den sich zwar immer intensiver mit IT befassen, diese aber nur noch passiv Konsumie-
ren anstatt aktiv damit zu arbeiten. Er sah die Begründung darin, dass eine günstige,
„hackbare“ Plattform fehlen würde, sowie er sie selbst in seiner Kindheit in Form des
BBC Micro erlebt hatte. [2]
Der erste Entwurf des Raspberry Pi war daher nicht der Computer wie er heute ver-
kauft wird, sondern eine Art Klone des BBC Micro auf Basis eines Atmel ATMega 644
(22.1 MHz, 512K SRAM, 320x240 Pixel). Dieser wurde von Eben Upton 2006 während
seiner Zeit an der Universität Cambridge entworfen, das Projekt aber schnell einge-
stellt.
Im gleichen Jahr wechselte Eben Upton zum Chiphersteller Broadcom und arbeitete
am BCM2835, welcher später auch die Basis für den heutigen Raspberry Pi werden soll-
te. Insbesondere die Tatsache der guten Multimedia Unterstützung dieses SoC bewog
Upton die Arbeit am Raspberry Pi wiederaufzunehmen. Er befürchtete dass der BBC
Micro Klone bei der heutigen, mit Facebook und anderen grafischen Anwendungen
vertrauten Jugend keinen Anklang finden könnte - ein Computer mit dem BCM2835
hingegen doch. Er gründete die Raspberry Pi Foundation, welche auf Basis des Einpla-
tinen Computers auch Materialien für die Nutzung im Unterricht und der Fortbildung
von Kindern und Jugendlichen in den sogenannten MINT Fächern erstellte. Damit ging
der erste Raspberry Pi im Februar 2012 in den Verkauf und wurde seither mehr als 3
Millionen mal verkauft [24].

2.1.2 BeagleBone Black Revision C


Das BeagleBone Black entstammt einer Reihe von verschiedenen Einplatinen Compu-
tern, welche ihre Entwicklung 2008 in Form des BeagleBoard, einem 150 US Dollar
teuren, 600 MHz schnellen Cortex-A8 Linux Boards begannen. Alle diese Entwick-
lungsboards haben die Gemeinsamkeit, dass sie von Texas Instruments Entwicklern
entwickelt wurden und jeweils als SoC den aktuellen Kern aus dem Portfolio der ge-
nanten Firma beinhalteten. Der aktuelle BeagleBone Black (53 e) verwendet ein Texas
Instruments AM335X SoC, welches eine 1 GHz starke ARM Cortex A8 CPU beinhaltet,
sowie eine PowerVR SGX530 Grafikeinheit mit 1,6 GFlops und 512 MB Arbeitsspei-
cher. Die Konnektivität nach außen geschieht beim Bone über einen USB Host Port,
einen USB Client Port, einen 100 Mbit Netzwerkanschluss sowie einen Micro HDMI
Port. Der BeagleBone Black bietet 92 GPIO Pins, welche sich auf zwei Pinleisten ver-
teilen, allerdings je nach verwendeter Peripherie (z.B. dem HDMI Ausgang, oder dem
Onboard Speicher) nicht alle verfügbar sind. Als Protokolle dienen dort gleich mehre-
re Serial Schnittstellen, I2C und SPI Busse sowie ein Controller Area Network (CAN)
und I2S Bus zur Verfügung. Als Massenspeicher dienen entweder die verbauten 4 GB
eMMC Flashspeicher oder eine Micro SD Karte. Die Stromversorgung erfolgt über den
USB Client Port oder über ein 5 Volt, 1 Ampere Netzteil. Als Besonderheit existieren

4
2.1 Raspberry Pi und BeagleBone Black

beim BeagleBone Black zwei Programmable Realtime Unit (PRU), welche jeweils mit
200 MHz getaktet sind und unabhängig von der ARM CPU funktionieren. Diese 32
bit Microcontroller sind mit hoher Bandbreite, sowohl an den eigenen, als auch an den
Arbeitsspeicher der ARM CPU angeschlossen und können dazu verwendet werden, re-
chenintensive oder zeitkritische Aufgaben zu übernehmen, ohne die CPU zu belasten.
Alle Geräte der BeagleBoard und BeagleBone Reihe verwendeten Anfangs ein spe-
ziell angepasstes Ångström Linux, seit Anfang des Jahres wird das neue BeagleBone
Black allerdings mit einer Anpassung von Debian vorinstalliert verkauft. Weiterhin ste-
hen Ubuntu und Android sowie das Echtzeitbetriebssystem QNX zur Wahl.

2.1.3 Vergleich
Raspberry Pi und BeagleBone Black scheinen auf den ersten Blick beide gleich gut zur
Verwendung im Bereich der Lehre geeignet zu sein, jedoch gibt es bei genauerer Be-
trachtung einige wesentliche Unterschiede. Der größte und wesentliche, welcher sich
sowohl im Design der Hardware, Software und verfügbaren Materialien widerspie-
gelt, ist die angepeilte Zielgruppe. Während der Raspberry Pi von Anfang an darauf
ausgelegt war im Bereich der Lehre verwendet zu werden und erst später aufgrund
des günstigen Preises von Hobbyisten und der Industrie aufgegriffen wurde, war das
BeagleBone Black als ein Entwicklungs- und Demoboard für das entsprechende, frei
zu erwerbenden SoC gedacht: Beide Hersteller haben die Baupläne ihres Produktes
offengelegt, was die eigene Produktion eines solchen Boards ermöglichen würde. Al-
lerdings ist nur der Kern des BeagleBone Black in kleinen, und nicht industriell übli-
chen Mengen erhältlich. Damit wird schnell klar, dass die Zielsetzung des BeagleBone
Black ebenfalls das eines Referenzdesigns zur Integration in die eigene Schaltung ist.
Weiterhin unterstützt wird diese These durch die Ausstattung in Hardware und Soft-
ware: Während der Raspberry Pi mittels digitalem HDMI, sowie analogem Video und
Audioanschlüssen, sowie vier USB Ports direkt als Standalone Rechner in fast allen Si-
tuationen eingesetzt werden kann, bietet der BeagleBone Black nur den digitalen HD-
MI Anschluss im unüblichen Micro HDMI Format, sowie einen USB Port - zu wenig
um die übliche Kombination aus USB Maus, Tastatur und WLAN Dongle ohne zusätz-
liches Zubehör anschließen zu können. Dies gilt allerdings nicht nur für den Bereich
der Hardware, sondern auch der Software: Während der Raspberry Pi mit einer Fülle
von Entwicklungswerkzeugen und Software (Python, Mathematica, Scratch, Verweis
auf Unterrichtsmaterialien uvm.) vorinstalliert kommt, verfügt der BeagleBone Black
neben verschiedenen Systemprogrammen ausschließlich über einen Texteditor, Termi-
nal, File Browser, Chrome sowie ein IRC Chat Tool. Zusammengefasst lässt sich also
festhalten, dass der BeagleBone Black sicherlich ein gutes Werkzeug für die industrielle
Entwicklung auf Basis des verwendeten Chips ist, allerdings für den Einsatz in der Leh-
re und der Verdeutlichung des Zusammenspiels von Hard- und Software nur bedingt
geeignet ist. Nicht zuletzt auch wegen des mehr als anderthalbfach so hohen Preises
und der bestehenden Lieferengpässe (Juli 2014), wurde der Raspberry Pi als Basis für
die folgende Arbeit gewählt.

5
2 Plattform Evaluation

Tabelle 2.1: Übersicht [6]

Raspberry Pi Modell B+ BeagleBone Black Rev. C

SoC Broadcom BCM2835 Texas Instruments AM3358


CPU ARM1176 / ARMv6 ARM Cortex-A8 / ARMv7
700 MHz, Hardware FPU 1 GHz, Hardware FPU
RAM 512 MB 512 MB
GPU Broadcom VideoCore IV PowerVR SGX530
24 GFlops 1,6 GFlops
Int. Speicher - 4 GB
Ext. Speicher Micro SD Micro SD
Netzwerk 10/100 Mbit 10/100 Mbit
Stromversorgung 5 V @ 2 A USB Micro 5 V @ 1 A USB Mini
5V @ 2.1mm Stecker
Abmessungen 85.6 mm x 56 mm 86.4 mm x 53,3 mm
Gewicht 45 g 40 g
Preis 33 e 53 e

Tabelle 2.2: I/O und Peripherie [6]

Raspberry Pi Modell B+ BeagleBone Black Rev. C

Digitale I/O Pins 28 @ 3,3V 65 @ 3,3V


Analoge Eingänge - 7 @ 12-bit ADC (0-1,8V)
PWM Ausgänge 2 8
Serial 1 4
SPI 2 2
I2C 1 2
USB Host 4 USB A Anschlüsse 1 USB A Anschluss
USB Client - 1 Mini B Anschluss
Video Eingang CSI -
Video Ausgang HDMI, Cinch, DSI Micro HDMI
Audio Ausgang HDMI, Analog Micro HDMI
Stromversorgung 3,3V @ 50 mA, 5V @ 1,2 A 3,3V @ 250 mA, 5V @ 1 A
Besonderheiten - PRU, CAN Bus

6
2.2 Raspberry Pi Modelle

2.2 Raspberry Pi Modelle


Seit Beginn der Entwicklung sind einige, verschiedene Modelle des Raspberry Pi er-
schienen. Am weitesten verbreitet ist das Modell B in der Version 2.0, weshalb auch der
Hardware Anteil dieser Bachelor Thesis mit diesem Raspberry Pi durchgeführt wurde.
Das neuste Modell, welches zukünftig als Standard dienen soll, ist der Raspberry Pi
Modell B+. Die Unterschiede der einzelnen Plattformen sollen nachfolgend kurz erläu-
tert werden.

2.2.1 Unterschiede Modell A und B


Der prinzipielle Unterschied zwischen Modell A und B liegen in der Bestückung der
Platinen. Das Modell A verfügt mit 256 MB nur über die Hälfte des Arbeitsspeichers
des Modell B. Weiterhin wurde der SMSC LAN9512 entfernt. Dieser Chip diente zeit-
gleich als USB Hub für die beiden Ports des Modell B, wie auch als Netzwerkinterface.
Damit verfügt das Modell A über nur einen USB Port und keinen Netzwerkanschluss.
Dadurch wurde zum einen das Gewicht, der Stromverbrauch und schließlich der Preis
auf 25 e reduziert. Besonders für mobile Anwendungen ist dieses Modell daher sehr
geeignet.

2.2.2 Modell B pre 2.0


Das Modell B in der Version pre 2.0 war der erste erschiene Raspberry Pi im Februar
2012 und verfügte über 256 MB Arbeitsspeicher, da für das Modell A ursprünglich 128
MB Arbeitsspeicher geplant waren.

2.2.3 Modell A/B 2.0


Beim Übergang zu Revision 2.0 gab es einige Detailänderungen, so wurden z.B. wenige
Pins inklusive des I2C Bus auf der GPIO Leiste um rangiert. Zum ersten Mal gab es
auch das funktionsreduzierte Modell A.

2.2.4 Compute Module


Das Compute Module entstand aus der Notwendigkeit eine kleinere, besser in indus-
trielle Systeme und kommerzielle Produkte integrierbare Plattform zu entwickeln. Das
Compute Module wurde daher im Format eines DDR2 SODIMM Riegels entworfen,
und lässt sich damit leicht und platzsparend integrieren. Zusätzlich zu dem Compute
Module wurde weiterhin ein Referenzdesign zur Verfügung gestellt, welches die not-
wendige Hardware zum Betrieb des Moduls enthielt. Aufgrund des kleinen Formfak-
tors und der hohen Anzahl an ausgeführten Ports über die SODIMM Leiste, konnte
die Anzahl der nutzbaren GPIO Ports von 17 (Modell A/B 2.0) auf 46 gesteigert wer-
den. Zusätzlich erhielt das Compute Modul jeweils zwei Anschlüsse für die CSI und
DSI Systeme, was das Modul zur Anbindung von zwei speziellen Displays, sowie dem

7
2 Plattform Evaluation

Einsatz im Bereich von stereoskopischen Kameraanwendungen befähigte. Das Compu-


te Module verwendet, ähnlich wie der BeagleBone Black (Rev. C), einen 4 GB großen
eMMC Flashspeicher.

2.2.5 Modell A+/B+


Das Modell B+ wurde im Juli 2014 vorgestellt und beinhaltete einige Verbesserungen
im Vergleich zur Revision 2.0. So verfügt der Raspberry Pi über eine neue, energie-
sparendere Stromversorgung, einen rauschärmeren analogen Audioausgang, vier statt
zwei USB Ports sowie anstatt der bisherigen 26, 40 GPIO Pins. Von diesen 40 Pins sind
28 (vorher 17) für eigene Projekte nutzbar, beim Rest handelt es sich um verschiedene
Spannungsschienen (3,3V / 5V), Masse oder die neue Schnittstelle für Erweiterungs-
module (Pi Hats). Das Modell A+ wurde noch nicht veröffentlicht, jedoch ist geplant
ähnlich wie beim Übergang von Modell B, Revision 2.0 eine neue Version des Modell A
herauszubringen, welche vermutlich ebenfalls die Verbesserungen im Bereich Strom-
versorgung und GPIO Erweiterung enthalten wird.

8
3 Grundlagen und Installation
In dem nachfolgenden Kapitel werden die Grundlagen zur Nutzung des Raspberry Pi
gelegt. Dies umfasst das benötigte Zubehör zum Betrieb, sowie die Vorbereitung der
SD Karte mittels der noobs Software beziehungsweise eines Images. Am Ende dieses
Kapitels wird der Raspberry Pi angeschlossen sein und zum ersten Mal booten.

3.1 Peripherie
Um den Raspberry Pi das erste Mal einzusetzen, ist es empfehlenswert diesen wie einen
handelsüblichen Personal Computer anzuschließen. Neben dem Raspberry Pi ist dazu
folgende Hardware nötig:

• SD Karte

• Netzteil mit Micro USB Anschluss

• USB Maus

• USB Tastatur

• Netzwerkkabel

• HDMI auf DVI Adapterkabel

• Display mit DVI Eingang

Bei der erwähnten Hardware sind allerdings noch einige Dinge zu beachten, bzw. kann
diese auch im Bedarfsfall durch andere Komponenten ersetzt werden.

3.1.1 SD Karte
Hier sollte mindestens eine 8 GB SD Karte eines Markenherstellers mit einer entspre-
chenden hohen Class eingesetzt werden. Die aktuelle Version von Raspbian belegt al-
leine etwas weniger als 4 GB Speicher, so dass beim Einsatz einer 4 GB Karte wenig
Platz für eigene Projekte und Erweiterungen blieb, weshalb eine 8 GB Karte empfoh-
len wird. In den Anfängen der Entwicklung der Raspberry Pi Firmware gab es große
Probleme bei der Verwendung von SD Karten unbekannterer Hersteller. Diese Proble-
me sind zum jetzigen Zeitpunkt fast ausgeschlossen, jedoch empfiehlt es sich dennoch
weiterhin aus Gründen der Datensicherheit in das Produkt eines Markenherstellers zu
investieren. Die Class beschreibt die Geschwindigkeitseinstufung einer SD Karte. Eine

9
3 Grundlagen und Installation

möglichst hohe Class, wie z.B. Class 10 empfiehlt sich bei der Verwendung des Raspber-
ry Pi, damit diese nicht zum limitierenden Faktor bei Schreib- und Lesezugriffen wird.
Alternativ kann die SD Karte auch durch eine Micro SD Karte mit entsprechendem
Adapter ersetzt werden, was beim Raspberry Pi Modell B+ zwingend erforderlich ist.

3.1.2 Netzteil mit Micro USB Anschluss


Als Netzteil könnte beim Raspberry Pi (Modell A und B) prinzipiell ein altes Handyla-
degerät verwendet werden. Jedoch sollte man aufpassen, dass dieses mindestens 1,2
Ampere Strom liefern kann. Der Raspberry Pi könnte dank seiner auf 1,1 Ampere fest-
gelegten Polyfuse bis zu 5 Watt an Leistung aufnehmen, oder weitere Leistung bis zu
dieser maximalen Grenzen an angeschlossene Verbraucher weitergeben. Da besonders
günstigere Netzteile den Strom bei höherer Belastung nicht konstant halten können,
geht daher die Empfehlung an ein entsprechend starkes Netzteil mit 1,2 Ampere oder
höher. Zu niedrige Versorgungsleistung kann sich in Schreib- / Lesefehlern bei der SD
Karte, Fehlfunktionen des RPi, bis hin zum Einfrieren des gesamten Systems äußern.
Beim Raspberry Pi Modell B+ sind dank der gesunkenen Anforderungen an Strom-
bedarf ein Netzteil mit 1,2 Ampere weiterhin verwendbar, bei der Nutzung aller vier
USB Ports empfiehlt sich allerdings die Verwendung eines Netzteils mit mindestens 2
Ampere Leistung, da die 1,1 Ampere Polyfuse durch eine 2 Ampere Polyfuse ersetzt
wurde.

3.1.3 Netzwerkkabel
Das Netzwerkkabel soll den Raspberry Pi mit einem Netzwerk, welches Internetzu-
gang wie auch DHCP Service anbietet, verbinden. Dies ist bei normalen Heim Routern
wie z.B. einer Fritz!Box Standard. Bei Firmen- oder Universitätsnetzwerken können
weitere Schritte zur Einrichtung der Internetverbindung notwendig sein.

3.1.4 HDMI auf DVI Adapterkabel / Display mit DVI Eingang


Um die Videoausgaben des Computers möglichst komfortable anzuzeigen, empfiehlt
es sich eine HDMI auf DVI Adapterkabel zu verwenden und dieses mit dem DVI Ein-
gang eines Computer Displays zu verwenden. Alternativ kann der Raspberry Pi auch
direkt mit einem HDMI Kabel an einem HDMI Display oder modernen Fernseher an-
geschlossen werden. Letztere Methode hat den Vorteil, dass die Audiosignale zusam-
men mit dem Videosingal übertragen werden, was es zu einer idealen Anschlussart für
Multimedia Anwendungen macht. Bei der Verwendung des DVI Eingangs muss das
Audiosignal zusätzlich vom Raspberry Pi mittels 3,5 mm Klinkekabels abgegriffen und
z.B. zu einem Paar Aktivboxen weitergeleitet werden. Sollten weder DVI noch HDMI
kompatible Displays verfügbar sein, könnte man im letzten Schritt über die Chinch
Buchse einen alten Röhrenfernseher anschließen.

10
3.2 Anschluss des Raspberry Pi

3.1.5 Weitere Komponenten


Je nach Einsatzzweck kann es erforderlich sein, weitere Komponenten zu verwenden.
Aufgrund der Tatsache, dass der 5V Eingang des Raspberry Pi (Modell A und B) mit
einer 1,1 Ampere Polyfuse abgesichert ist [20] (S.1, oben, F1), welches den gesamten
Raspberry Pi versorgt wird schnell klar, dass die beiden USB Ports nicht wie sonst 500
mA pro Port liefern können. Daher müssen Geräte mit höherem Strombedarf (USB Fest-
platten, größere USB Sticks, etc) an einem aktiven USB Hub betrieben werden, um zum
einen die Anzahl der verfügbaren USB Anschlüsse zu erhöhen und zum anderen auch
Geräte mit erhöhter Leistungsaufnahme sicher am Raspberry Pi betreiben zu können.
Beim Modell B+ ist, insbesondere mit der Verwendung eines 2 Ampere Netzteils, die
Problematik zumindest bei größeren USB Sticks und WLAN Dongles behoben wurden.
Für besonders energiehungrige Endgeräte empfiehlt sich allerdings auch hier ein akti-
ver USB Hub. Weiterhin werden für die erste Inbetriebnahme ein aktueller Windows
Rechner mit SD Karten Lesegerät und Internetzugriff vorausgesetzt um die SD Karte
vorzubereiten.

3.2 Anschluss des Raspberry Pi


Für den weiteren Verlauf des Dokumentes wird vorausgesetzt, dass die angegebenen
Komponenten vorhanden und der Raspberry Pi angeschlossen, allerdings stromlos und
ohne SD Karte bereit steht.

3.3 Raspbian
Das bereits erwähnte Raspbian ist die Standard Distribution für den Raspberry Pi. Es
handelt sich dabei um ein Debian Derivat, welches den Anforderungen und der Archi-
tektur des ARMv6 Prozessors des Einplatinen Computers angepasst wurde. Zusätzlich
zu dem reinen Betriebssystem werden auch viele der unter Debian verfügbaren Soft-
ware Pakete über den Paketmanager apt mit den entsprechenden Anpassungen ange-
boten. Um Raspbian auf der SD Karte zu installieren bieten sich zwei Möglichkeiten an.
Zum einen die Verwendung des sogenannten noobs Systems der Raspberry Pi Foun-
dation oder das bitweise Kopieren eines fertigen Images.

3.4 Installation mittels Image


Die „traditionelle“ Art ein Betriebssystem per Image zu installieren ist auch nach der
Einführung des noobs Systems weiterhin beliebt. Dies ist darin begründet, dass diese
Art der Installation relativ schnell funktioniert. Weiterhin lassen sich auf gleichem Weg
Backups von vorhandenen Installationen erstellen und wiederherstellen. Zu guter Letzt
ist es auch für weniger bekannte Distributionen ohne Integration in noobs die einzige
Möglichkeit diese für die Nutzung auf dem Raspberry Pi vorzubereiten.

11
3 Grundlagen und Installation

3.4.1 Image downloaden


Um das Raspbian Image zu installieren, müssen wir es erst von der Website der Raspber-
ry Pi Foundation herunterladen. Man findet es unter der Adresse http://www.raspberrypi.
org/downloads/. Dort kann man sich entscheiden, ob man das Image von Raspbian per
direktem HTTP Download oder per Torrent erhalten möchte. Für die meisten Einsatz-
zwecke sollte der Download als ZIP Datei die geeignete Wahl sein. In dieser Arbeit wird
das aktuelle Image vom Juni 2014 verwendet (Release 20.06.2014, Kernel 3.12, 788 MB).
Nach dem erfolgreichen Download muss die Datei mittels einem geeigneten Werkzeug
(z.B. 7-zip: http://www.7-zip.org/) entpackt werden. Bei der resultierenden, fast 3 GB
großen Datei mit der Endung „.img“ handelt es sich um die besprochene Image Datei,
welche bitweise die Kopie des Raspbian Betriebssystems enthält. Diese Datei wird in
den nächsten Schritten auf die vorhandene SD Karte kopiert.

3.4.2 Formatieren
Um das Image auf die SD Karte kopieren zu können, muss deren Inhalt zuerst ge-
löscht, die Karte also formatiert werden. Dies ist bei der Verwendung einer neuen und
leeren SD Karte nicht notwendig, da die Karte im nächsten Schritt bitweise überschrie-
ben wird. Beim Überschreiben werden normalerweise zwei Partitionen angelegt: Eine
FAT32 Partition wie man sie auch bei USB Sticks kennt, sowie eine EXT Partition un-
terschiedlicher Version. Das EXT Dateisystem entstammt dem Linux Bereich und ist
unter Windows nicht lesbar. Will man nun also eine bereits für den Raspberry Pi ver-
wendete SD Karte ein weiteres Mal neu beschreiben, oder ein Backup wiederherstellen,
so erscheint die ggf. mehrere GB große SD Karte als nur knapp 56 MB großer, FAT32
formatierter USB Stick im Dateisystem. Durch die Formatierung kann das ursprüngli-
che Format wiederhergestellt und anschließend mit der vollen Größe auch ein Image
wieder zurück gespielt werden.
Um unter Windows die SD Karte korrekt zu formatieren, sollte man nicht das Win-
dows eigene Tool verwenden, sondern den SD Formatter der SD Association. Man kann
dieses Tool kostenlos unter https://www.sdcard.org/downloads/formatter_4/ per Klick
auf „Download SD Formatter for Windows“ herunterladen. Nachdem man die EULA
angenommen hat, startet der Download der wenigen MB großen ZIP Datei. Sobald
man die enthaltene Setup Datei entpackt und das Tool installiert hat, startet man dieses
einfach.
Das Tool selbst ist relativ einfach gehalten: Unter „Drive“ wählt man das korrekte
Laufwerk aus und per Klick auf „Format“ startet man die Formatierung der SD Karte.
Dabei ist jedoch darauf zu achten, dass das Tool alle Wechselmedien unter „Drive“
auflistet. Man muss also darauf achten wirklich seine SD Karte zu formatieren, und
nicht versehentlich einen USB Stick mit wichtigen Daten. Bevor man allerdings den
Vorgang startet, sollte man unter „Option“ noch eine Anpassung vornehmen.
In jedem Fall, besonders bei der Vorbereitung einer SD Karte für die Verwendung von
noobs, sollte man hier das „Format Size Adjustment“ auf „On“ stellen und den Dialog
per Klick auf „OK“ verlassen, sowie die Formatierung per Klick auf „Format“ starten.

12
3.4 Installation mittels Image

Abbildung 3.1: SD Formatter

Abbildung 3.2: SD Formatter Optionen

13
3 Grundlagen und Installation

Nachdem zwei weitere Sicherheitsabfragen bestätigt wurden, beginnt der Vorgang und
endet mit einer Übersicht über die tatsächliche Größe der SD Karte. Der Vorgang ist
damit abgeschlossen und das Tool kann beendet werden.

3.4.3 Image kopieren


Um das bereits heruntergeladene Image auf die nun vorbereitete SD Karte zu kopie-
ren, benötigen wir ein weiteres Tool, die Freeware Win32 Disk Imager. Dieses Werkzeug
kann man unter der URL http://sourceforge.net/projects/win32diskimager/ per
Klick auf „Download unamed sequel here“ herunterladen, installieren und anschlie-
ßend starten.

Abbildung 3.3: Win32 Disk Imager

Wie bereits beim SD Formatter gibt es auch hier ein Feld zur Auswahl des korrek-
ten Wechsellaufwerkes („Device“). Es ist auch dieses Mal genaustens darauf zu achten
die SD Karte und nicht einen anderen Wechseldatenträger, wie z.B. einen USB Stick
auszuwählen, da im nächsten Schritt alle Dateien auf diesem überschrieben werden.
Nachdem die SD Karte als Laufwerk ausgewählt wurde, wählen wir per Klick auf
den Dateiordner das vorher heruntergeladene Raspbian Image aus (hier: 2014-06-20-
wheezy-raspbian.img). Nach dem Klick auf „Öffnen“ ist das Tool dann auch schon fer-
tig konfiguriert. Per Klick auf „Write“ beginnt nach einer weiteren Sicherheitsabfrage
der Schreibvorgang. Nach Abschluss des selbigen kann die SD Karte ausgeworfen, aus
dem Lesegerät entfernt und in den Raspberry Pi eingesetzt werden. Dies schließt das
Kopieren des Raspbian Image auf die SD Karte ab. Der Raspberry Pi kann nun an die
Stromversorgung angeschlossen werden um Raspbian zu booten.

3.4.4 Backup und Wiederherstellung


Wie bereits eingangs erwähnt kann das Win32 Disk Imager Tool auch dazu verwendet
werden, Backups einer bestehenden Raspbian Installation anzufertigen, bzw diese Wie-
derherzustellen.

14
3.5 Installation mittels noobs

Wollen wir ein Backup erstellen, so setzen wir die SD Karte in das Lesegerät ein und
starten den Win32 Disk Imager. Anders als beim bisherigen Vorgang wählen wir diesmal
über den Dateiordner kein fertiges Image aus, sondern geben im entsprechenden Dia-
logfeld einen eigenen, nicht existierenden Dateinamen ein, z.B. „RaspbianBackup.img“.
Nach dem Klick auf „Öffnen“ sind wir wieder im Hauptdialog und können durch Klick
auf den Button „Read“ das Auslesen der SD Karte in die neu angelegte Datei starten.
Die Datei wird später die Größe der verwendeten SD Karte haben und kann ohne weite-
re Änderungen auch nur auf eine solch große, oder größere SD Karte wiederhergestellt
werden.
Zur Wiederherstellung gehen wir ähnlich vor wie beim Kopieren des Raspbian Images:
Wir führen zuerst eine Formatierung der SD Karte wie unter 3.4.2 angegeben durch,
anschließend kopieren wir das Backup Image anstelle des Raspbian Images auf die SD
Karte wie unter 3.4.3 beschrieben.

3.5 Installation mittels noobs


Um den Einstieg in die Welt des Raspberry Pi zu vereinfachen erfand die Raspberry Pi
Foundation die sogenannte noobs oder New Out Of Box Software. Es handelt sich dabei
um einen Installationsassistenten welcher, nachdem er auf der SD Karte installiert wur-
de, den Boot des Raspberry Pi und dort die Auswahl des gewünschten Betriebssystems
erlaubt. Erst dann findet die eigentliche Installation statt. Noobs gibt es auch vorinstal-
liert auf Micro SD Karten samt Adapter im Handel zu kaufen, um den Einstieg mit dem
Raspberry Pi zu einer echten „Plug and Play“ Lösung zu machen. Sollte der Installer
jedoch beschädigt werden, man noobs selbst auf einer leeren SD Karte installieren wol-
len oder andere Probleme auftreten, ist es gut die wenigen Schritte bis zur Einrichtung
und Nutzung dieses Systems zu kennen, welche nachfolgenden aufgelistet werden.

3.5.1 noobs downloaden


Wie auch bei der direkten Installation von Raspbian muss das noobs Paket erst von
der Raspberry Pi Website heruntergeladen werden. Dazu navigieren wir zu http://
www.raspberrypi.org/downloads/ und wechseln zum Eintrag „noobs“. Die New Out
Of Box Software gibt es in zwei Versionen: Full und Lite. Bei der Full Version sind al-
le wichtigen Betriebssysteme bereits auf der SD Karte hinterlegt, so dass eine Offline
Installation nach dem Download möglich ist. Die Lite Version benötigt, da nur der In-
staller auf der Karte untergebracht ist, bei der Installation eine Internetverbindung um
die Images herunterzuladen. Je nach Einsatzzweck downloaden wir die passende Ver-
sion per Klick auf den „Download ZIP“ Button.

3.5.2 Formatieren
Wie bereits bei 3.4.2 erklärt muss nun auf gleichem Wege die SD Karte formatiert wer-
den. Nachdem dies abgeschlossen ist, kann noobs selbst im nächsten Schritt auf die SD

15
3 Grundlagen und Installation

Karte kopiert werden.

3.5.3 noobs kopieren

Abbildung 3.4: noobs nach dem Entpacken auf die SD Karte

Nachdem wir die SD Karte vorbereitet haben, entpacken wir den Inhalt des herun-
tergeladenen Paketes direkt ins Hauptverzeichnis der SD Karte unter Beibehaltung der
Datei- und Ordnerstruktur. Auch hierbei wird empfohlen einen bewährten Entpacker
wie z.B. 7-zip (http://www.7-zip.org/) dem Windows eigenem Tool vorzuziehen. An-
schließend kann die SD Karte sicher entfernt und schließlich in den Raspberry Pi ein-
gesetzt werden. Damit ist noobs erfolgreich eingerichtet und wir können den Raspberry
Pi an die Stromversorgung anschließen, um Raspbian zu installieren.

3.5.4 Raspbian mit noobs installieren


Nach dem Boot des Raspberry Pi erscheint die Oberfläche von noobs, welche uns die
Möglichkeit gibt, zum einen die Sprachoptionen und Tastatureinstellungen zu ändern,
sowie zum anderen ein Betriebssystem zur Installation auszuwählen und den Prozess
zu starten. Da wir, wie auch in der manuellen Methode, Raspbian installieren wollen,
aktivieren wir diesen Eintrag mit einem Klick in das entsprechende Kästchen und kli-
cken anschließend auf „Install“. Nach einer Sicherheitsabfrage beginnt die Installation
die nun einige Zeit dauern kann.
Nach dem Abschluss der Einrichtung informiert noobs den Nutzer mittels Dialogbox.
Nach dem Klick auf „OK“ startet der Raspberry Pi neu und bootet Raspbian.

3.5.5 Vorteile von noobs


Der Vorteil der Installation nach dieser Methode liegt zum einen darin, dass die Sprach-
optionen und Tastatureinstellungen welche in noobs eingegeben wurden nach Raspbian

16
3.5 Installation mittels noobs

Abbildung 3.5: Installation von Raspbian unter noobs

übernommen werden, zum anderen aber auch darin, dass man jederzeit beim Booten
des Raspberry Pi die Shift Taste gedrückt halten kann, um das noobs Menü erneut auf-
zurufen. Damit hat man die Möglichkeit Einstellungen zu ändern, wie auch ohne den
Einsatz eines PCs andere Betriebssysteme zu installieren. Weiterhin ermöglicht noobs
die gleichzeitige Installation mehrerer Betriebssysteme auf einer SD Karte und dient
als Bootmanager.

17
4 Konfiguration von Raspbian
Nachdem der Raspberry Pi im letzten Kapitel zum ersten Mal in Betrieb genommen
wurde, muss nun die Grundkonfiguration erfolgen. Dies bedeutet zum Beispiel das
Tastaturlayout, die Zeitzone und die Internationalisierungsoptionen einzustellen. An-
schließend werden die Schritte zur Installation neuer Software und Update bestehen-
der, sowie dem Upgrade der Firmware beschrieben. Am Ende dieses Kapitels werden
alle notwendigen Vorbereitung zur Nutzung der GPIO Schnittstelle in verschiedenen
Programmiersprachen getroffen sein.

4.1 Erster Boot


Nachdem Raspbian nun auf der SD Karte installiert und der Raspberry Pi nun boo-
tet, muss ersteres nun in einer Grundkonfiguration für die Verwendung beim Nutzer
eingerichtet werden. Im Idealfall wird dies direkt am Raspberry Pi durch die Verwen-
dung von Maus, Tastatur und Bildschirm erledigt. Sollte dies nicht möglich sein, bzw.
eine Einrichtung headless, also ohne Bildschirm über das Netzwerk erfolgen, so kann
man dies unter Verwendung eines SSH Tools wie z.B. PuTTY (http://www.chiark.
greenend.org.uk/~sgtatham/putty/download.html) tun. Die Login Daten bei Raspbi-
an sind, wie auch auf der Downloads (http://www.raspberrypi.org/downloads/) Sei-
te vermerkt, Nutzer: pi sowie Passwort: raspberry. Dabei ist zu beachten, dass beim di-
rekten Login über die Tastatur, so diese nicht von noobs auf QWERTZ umgestellt wurde,
im QWERTY Format Eingaben entgegen nimmt, also u.a. die Position von Z und Y auf
der Tastatur vertauscht ist.

4.1.1 raspi-config
Nachdem der Raspberry Pi zum ersten Mal gebootet ist, erscheint das Software Con-
figuration Tool, auch bekannt als raspi-config. Sollte man diese Schritte in einer headless
Installation nachvollziehen wollen, so muss man nach Login über PuTTY das Tool ma-
nuell durch die Eingabe von sudo raspi-config starten.
raspi-config ermöglicht viele Änderungen und Grundeinstellungen. So kann man in
diesem Werkzeug z.B. die Verteilung des gemeinsam von CPU und GPU genutzten
RAMs ändern, das Nutzerpasswort ändern, den Boot in die grafische Benutzeroberflä-
che aktivieren oder die Raspberry Pi Kamera aktivieren. Alle Hardwarenahen Ände-
rungen, wie z.B. Übertaktungseinstellungen werden vom Tool in Form der config.txt
[8] Datei in der FAT32 Partition der SD Karte abgelegt und sind auch manuell von ei-
nem normalen Windows PC änderbar und damit auch eine Wiederherstellung bei z.B.

19
4 Konfiguration von Raspbian

Abbildung 4.1: raspi-config

fehlerhaft konfigurierten Übertaktungseinstellungen möglich. Im Normalfall empfiehlt


sich allerdings die Verwendung dieses Tools um Fehler zu vermeiden.
Die Navigation in raspi-config erfolgt über folgende Tastenkombinationen:

Pfeiltasten Hoch, Runter

Page UP, Page Down Schnell Hoch, Schnell Runter

Enter Menü betreten

ESC Menü verlassen

Leertaste Menüpunkt markieren, bei [ ] Auswahl

Wir beginnen die Konfiguration im Menü 8 Advanced Options, in dem wir unter Punkt
A3 Memory Split den Anteil der Grafikkarte am Gesamtarbeitsspeicher des RPi festle-
gen. Im Normalfall reicht die Standardeinstellung von 64 MB. Bei sogennaten Headless
Konfigurationen, also dem Betrieb des RPi ohne Bildschirm, Maus und Tastatur als Ser-
ver, kann dort der Anteil der GPU auch auf 16 MB gesenkt werden. Der Name des RPi
im Netzwerk kann unter A2 Hostname festgelegt werden. Es empfiehlt sich dort einen
sprechenden Namen einzugeben und nicht alle RPi mit dem Standardnamen „raspber-
rypi“ zu belassen.
Unter 7 Overclock: Kann man die Übertaktung des Raspberry Pi einstellen, um eine
Leistungssteigerung zu erhalten. Die einzigen beiden sinnvollen Parameter sind dabei
None oder Turbo: Mit None betreibt man den Raspberry Pi innerhalb der Standardpara-
meter, mit Turbo erhält man eine sehr starke Übertaktung und Steigerung u.a. der CPU
Geschwindigkeit von 700 MHz auf 1 GHz. Dennoch bleibt bei der Nutzung der Turbo
Einstellung die Garantie erhalten, da die CPU automatisch diese Übertaktung zurück-
regelt, sobald die Temperatur der CPU 85 Grad Celsius erreicht [23]. Diese Einstellung
ist allerdings auf Grund von Fertigungstoleranzen nicht auf jedem Raspberry Pi zu er-
reichen. Sollte es Probleme geben, so kann man durch Halten der Shift Taste beim Boot

20
4.1 Erster Boot

des Raspberry Pi in den abgesicherten Modus wechseln um diese Einstellung zu igno-


rieren.
Sollte man die Raspberry Pi Kamera nutzen wollen, so muss vor dem Anschluss die-
ses Moduls die Unterstützung für diese mit der Einstellung 5) Enable Camera aktiviert
werden. Danach kann man die Kamera an den ausgeschalteten Raspberry Pi anschlie-
ßen und nach einem erneuten Start nutzen.
Um den Raspberry Pi sinnvoll in Deutschland zu nutzen, stellen wir nun unter 4 In-
ternationalization Options die Internationalisierungsoptionen auf unseren Standort und
unsere Sprache um. Wir beginnen mit I1 Change Locale und wählen im erscheinenden
Menü den Punkt [*] de_DE.UTF-8 UTF-8 aus, bestätigen die Wahl und beantworten die
Frage nach dem Default locale mit de_DE.UTF-8. Nun werden die Standortparameter
erstellt, was einen kurzen Moment dauern kann.
Als nächstes ändern wir die Zeitzone unter dem Punkt I2 Change Timezone in dem wir
zuerst als Geographic area Europe und dann als Timezone Berlin angeben. Der Raspberry
Pi bezieht sich seine Zeitinformationen per NTP über das Netzwerk und stellt die Uhr
direkt korrekt ein.
Abschließend muss die Einstellung der Tastatur auf das deutsche Schema angepasst
werden. Der korrekte Unterpunkt dafür ist I3 Change Keyboard Layout.

• Generic 105-key (Intl) PC

• Other

• German

• German

• The default for the keyboard layout

• No compose key

• <No>

Anschließend wird die neue Keymap erstellt und mit dem nächsten Login aktiv.
Um beim nächsten Bootvorgang nicht wieder in der Kommandzeile zu landen, son-
dern direkt zum Desktop zu booten, aktivieren wir nun unter 3 Enable Boot to Desktop/S-
cratch die Option Desktop Log in as user ’pi’ at the graphical desktop.
Aus Sicherheitsgründen empfiehlt es sich im vorletzten Schritt das Passwort des
Standardnutzers pi unter 2 Change User Password zu ändern.
Zu guter Letzt möchten wir, dass der Raspberry Pi nicht nur die knapp 3 GB Speicher,
welche durch das Image bereitgestellt wurden nutzt, sondern die gesamte SD Karte be-
legt. Daher führen wir als letzte Aktion 1 Expand Filesystem aus. Mit der Bestätigung von
Finish im Hauptmenü beenden wir raspi-config und beantworten die Frage nach dem
gewünschten Reboot mit Yes. Mit dem Neustart wird das Dateisystem angepasst und
der Raspberry Pi bootet schließlich zur grafischen Benutzeroberfläche, dem Desktop.

21
4 Konfiguration von Raspbian

Abbildung 4.2: Raspbian Desktop

4.2 WLAN Zugriff / eduroam


Sollte ein Zugriff auf das eduroam WLAN benötigt werden, muss der Raspberry Pi zu-
vor mit einem USB WLAN Dongle ausgestattet werden. Eine entsprechende Kompati-
bilitätsliste geeigneter Modelle kann unter http://elinux.org/RPi_USB_Wi-Fi_Adapters
gefunden werden. Anschließend kann unter Nutzung des Wifi Config Tools des RPi
unter dem Punkt „Manage Networks“ und „Add“ das WLAN eduroam hinzugefügt
werden:

Tabelle 4.1: Einstellungen für eduroam

Einstellung Wert

SSID eduroam
Authentication WPA2-Enterprise (EAP)
Encryption CCMP
EAP method PEAP
Identity nutzername@htw-saarland.de
Password Passwort
CA certificate /etc/wpa_supplicant/deutsche-telekom-root-ca-2.crt
Inner auth EAP-MSCHAPV2

Anschließend kann über den Reiter „Current Status“ und die Schaltfläche „Connect“
eine Verbindung hergestellt werden.

22
4.3 Updates

4.3 Updates
Nachdem wir nun die Grundkonfiguration des Raspberry Pi durchgeführt haben, ist es
zwingend erforderlich, zum einen die neuste Firmware wie auch Software Updates zu
installieren und die grundlegende Arbeit mit dem Paketmanager apt zu erlernen.

4.3.1 rpi-update
Das Firmware Paket besteht aus dem Kernel von Raspbian, dem GPU Bootloader sowie
den benötigten Modulen für den Kernel. Sobald der Raspberry Pi mit Strom versorgt
wird sucht die GPU automatisch auf der FAT32 Partition der SD Karte nach einem
passenden Bootloader. Mit diesem kann die Grafikeinheit dann die CPU und die rest-
liche Peripherie initialisieren und schließlich den Kernel booten. Die Firmware auf ei-
nem aktuellen Stand zu halten ist wichtig, da man nur auf diese Art von Verbesserun-
gen wie z.B. verbesserter Hardwareunterstützung oder Fehlerbeseitigung profitieren
kann. Die aktuelle Kernelversion kann man sich mit dem Kommando uname -a anzei-
gen lassen. Dazu verwenden wir das Tool LXTerminal welches in der oberen, linken
Ecke des Desktops abgelegt ist. Als Beispiel sei hier die Ausgabe unseres neu installier-
ten Raspbian angegeben:
Linux raspberrypi 3.12.22+ #691 PREEMPT Wed Jun 18 18:29:58 BST 2014 armv6l GNU/Linux
Wie man erkennen kann, handelt es sich hierbei um den Kernel Version 3.12.22+ wel-
cher am 18. Juni 2014 gegen 18:29:58 kompiliert wurde. Die Zahl #691 ist die Versions-
nummer des Kernels. Die Version der GPU Firmware lässt sich durch das Kommando
/opt/vc/bin/vcgencmd version herausfinden:

Jun 18 2014 18:46:58


Copyright (c) 2012 Broadcom
version 1a6f79b82240693dcdb9347b33ab16f656b5f067 (clean) (release)
Um nun ein Update auf die neuste Version durchzuführen, reicht das Kommando su-
do rpi-update. Da es sich hierbei um ein Kommando handelt welches tiefgreifend in
wichtige Bereiche des Linux Betriebssystems eingreift, zu welchen unser Standardnut-
zer pi keinen Zugriff hätte, müssen wir das Kommando sudo vorstellen. Durch dieses
Kommando wird der nachfolgende Befehl (hier: rpi-update) mit den Rechten des Linux
Administrators, root durchgeführt:
sudo rpi-update
*** Raspberry Pi firmware updater by Hexxeh, enhanced by AndrewS
*** Performing self-update
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 135 100 135 0 0 227 0 --:--:-- --:--:-- --:--:-- 299
100 7037 100 7037 0 0 8049 0 --:--:-- --:--:-- --:--:-- 8049
*** Relaunching after update

23
4 Konfiguration von Raspbian

*** Raspberry Pi firmware updater by Hexxeh, enhanced by AndrewS and Dom


*** We're running for the first time
*** Backing up files (this will take a few minutes)
*** Backing up firmware
*** Backing up modules 3.12.22+
*** Downloading specific firmware revision (this will take a few minutes)
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 168 100 168 0 0 350 0 --:--:-- --:--:-- --:--:-- 465
100 21.2M 100 21.2M 0 0 902k 0 0:00:24 0:00:24 --:--:-- 525k
*** Updating firmware
*** Updating kernel modules
*** depmod 3.12.25+
*** Updating VideoCore libraries
*** Using HardFP libraries
*** Updating SDK
*** Running ldconfig
*** Storing current firmware revision
*** Deleting downloaded files
*** Syncing changes to disk
*** If no errors appeared, your firmware was successfully updated to
774062f644162e209214bc2d3a7ba79fdf765ba3
*** A reboot is needed to activate the new firmware
Um die Installation der neuen Firmware abzuschließen, müssen wir den Raspber-
ry Pi neustarten. Dies geschieht entweder rechts unten im Desktop über die Abmelden
Schaltfläche, den Shutdown Icon auf dem Desktop oder mittels Kommandozeile über
die Befehle sudo shutdown -h now zum herunterfahren oder sudo shutdown -r now zum
neustarten. Nachdem wir nun die Firmware des Raspberry Pi aktualisiert haben, möch-
ten wir uns im nächsten Schritt um seine Software kümmern.

4.3.2 apt-get
APT ist der sogenannte Paket Manager unter dem von Debian abstammenden Raspbi-
an Linux. Pakete können die unterschiedlichsten Arten von Software, Libraries und
anderen Abhängigkeiten enthalten. Der Paket Manager selbst verwaltet die Installati-
on sowie die benötigten Grundlagen / Abhängigkeiten um die gewünschte Software
auf dem Rechner zu betreiben. Weiterhin können über den Paket Manager nicht nur
Software installiert und gelöscht, sondern auch aktualisiert werden. Unter der Nut-
zung von LXTerminal führen wir den Befehl sudo apt-get update aus. Damit lädt sich
der Paket Manager die aktuellen Paketlisten herunter um zu wissen, welche Software
in welcher Version für den Nutzer zur Verfügung steht. Mit dem Kommando sudo apt-
get upgrade starten wir schließlich das Software update. Der Paket Manager berechnet
die Abhängigkeiten, benötigten neuen Pakete und verlangt schließlich die Bestätigung

24
4.4 Einrichtung Hardware

seitens des Nutzers.

sudo apt-get upgrade


Paketlisten werden gelesen... Fertig
Abhängigkeitsbaum wird aufgebaut.
Statusinformationen werden eingelesen.... Fertig
Die folgenden Pakete werden aktualisiert (Upgrade):
cups-bsd cups-client cups-common dbus dbus-x11 gnupg gpgv libcups2
libcupsimage2 libdbus-1-3 libjpeg8 libsmbclient libwbclient0 libxml2
openssh-client openssh-server python-picamera python-rpi.gpio
python3-picamera python3-rpi.gpio rpi-update samba-common smbclient ssh
tzdata
25 aktualisiert, 0 neu installiert, 0 zu entfernen und 0 nicht aktualisiert.
Es müssen 13,2 MB an Archiven heruntergeladen werden.
Nach dieser Operation werden 100 kB Plattenplatz zusätzlich benutzt.
Möchten Sie fortfahren [J/n]?
Nachdem diese Frage mit J und der Eingabe von Enter bestätigt wurde, führt der
Raspberry Pi die Updates durch. Danach empfiehlt sich ein Neustart von Raspbian.
Die Installation von neuen Paketen funktioniert mit dem Kommando sudo apt-get
install <Paketname> respektive die Entfernung mit sudo apt-get remove <Paketname>.
Diese Kommandos werden wir gleich u.a. bei der Installation von wiringpi2 verwenden.

4.4 Einrichtung Hardware


Wie bereits erwähnt, verfügt der Raspberry Pi über eine GPIO Schnittstelle. Die 26 (Mo-
dell A,B) respektive 40 Pins (Modell B+) lassen sich je nach Programmierung entwe-
der als digitaler Ein- oder Ausgang verwenden um die unterschiedlichsten Aufgaben
zu erfüllen. Einige dieser Pins verfügen noch über spezielle Alternativfunktionen, wie
z.B. einen I2C Bus, einen SPI Bus oder einen Universal asynchronous receiver/trans-
mitter (UART) in Form einer RS-232 seriellen Schnittstelle. Die ersten beiden Funktio-
nen sind standardmäßig deaktiviert um dem Nutzer mehr freie GPIO Pins zu bieten,
die letztere wird aktiv als serielle Konsole von Raspbian verwendet. Wenn man diese
Schnittstellen und Funktionen also für eigene Projekte verwenden möchte, muss man
sie erst aktivieren respektive aus der Nutzung anderer Dienste entfernen.

4.4.1 Vorbereitung des I²C / SPI Bus


Um die I2C bzw SPI Funktionen der GPIO Pins zu verwenden, führen wir zunächst ein
Update des Paket Managers mit sudo apt-get update durch und installieren anschlie-
ßend mit sudo apt-get install i2c-tools python-smbus die Pakete für die I2CTools so-
wie die Python Bibliothek für den SPI Bus.
Nachdem dies erfolgt ist, müssen wir die Module für I2C und SPI von der Blacklist
entfernen. Die Blacklist verhindert dass diese Module beim Start geladen und damit

25
4 Konfiguration von Raspbian

die alternativen Funktionen auf der GPIO zur Verfügung stehen. Um dies zu bewerk-
stelligen können wir entweder mittels LXTerminal und vi über Kommandozeile die ent-
sprechenden Dateien editieren, oder per LXTerminal mit dem Kommando sudo leafpad
den Texteditor Leafpad mit root Rechten starten um anschließend die sonst schreibge-
schützten Dateien zu editieren.
Im ersten Schritt öffnen wir die Datei /etc/modprobe.d/raspi-blacklist.conf und
kommentieren die beiden blacklist Befehle für die Module spi-bcm2708 und i2c-bcm2708
mittels vorangestelltem # Zeichen aus:
# blacklist spi and i2c by default (many users don't need them)

#blacklist spi-bcm2708
#blacklist i2c-bcm2708
Danach speichern wir die Datei.
Als nächstes müssen wir die beiden Module in /etc/modules vermerken, damit diese
auch beim Start des RPi geladen werden. Dazu hängen wir einfach nach dem letzten
Eintrag in der genannten Datei die folgenden Zeilen an:
i2c-bcm2708
spi-bcm2708
i2c-dev
Das Ergebnis sieht wie folgt aus:
# /etc/modules: kernel modules to load at boot time.
#
# This file contains the names of kernel modules that should be loaded
# at boot time, one per line. Lines beginning with "#" are ignored.
# Parameters can be specified after the module name.

snd-bcm2835
i2c-bcm2708
spi-bcm2708
i2c-dev
Abschließend müssen wir nur noch den Standardnutzer pi zu den entsprechenden
Linux Gruppen hinzufügen, damit er die Berechtigung zur Nutzung dieser Dienste
erhält. Standardmäßig sind die Berechtigungen für die SPI und GPIO Gruppe schon
erteilt ( groups pi zeigt die zugeteilten Gruppen an). Daher müssen wir nur noch mit
dem Befehl sudo adduser pi i2c den Nutzer pi die Rechte für die Gruppe I2C geben.
Die durchgeführten Änderungen werden erst nach einem Neustart aktiv.

4.4.2 Vorbereitung der seriellen Schnittstelle


Da im Standardfall die serielle Schnittstelle des RPi von Raspbian als Terminal genutzt
wird, kann diese nicht direkt dazu verwendet werden um z.B. einen Global Positio-

26
4.5 Einrichtung Software

ning System (GPS) Empfänger oder eine Microcontroller Unit (MCU) wie den Ardui-
no anzuschließen. Um diese Funktionalität zu entfernen müssten wir aus der Datei
/boot/cmdline.txt die Einträge console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 entfer-
nen sowie in der Datei /etc/inittab den Eintrag T0:23:respawn:/sbin/getty -L ttyAMA
0 115200 vt100 durch voranstellen eines # Zeichens auskommentieren [10]. Da die-
se Änderung jedoch so häufig durchgeführt wurde und ins besondere Fehler in der
/boot/cmdline.txt zu einem nicht bootfähigen System führen können, hat der Nut-
zer lurch auf Github das Programm rpi-serial-console (https://github.com/lurch/
rpi-serial-console) geschrieben, welches diese Änderung vollautomatisch durch-
führt. Die Installation erfolgt mit den Befehlen
sudo wget https://raw.github.com/lurch/rpi-serial-console/master/rpi-serial-console
-O /usr/bin/rpi-serial-console Enter
sudo chmod +x /usr/bin/rpi-serial-console Enter
was dafür sorgt, dass das Programm nach /usr/bin/rpi-serial-console herunterge-
laden und anschließend ausführbar gemacht wird.
Anschließend können wir mit sudo rpi-serial-console disable die serielle Konsole
von Raspbian deaktivieren. Mit dem Parameter enable diese im Übrigen wieder akti-
viert und mit status der aktuelle Zustand der UART abgefragt werden.
Wie auch bei den Änderungen für I2C und SPI werden die Änderungen erst nach
einem Neustart des RPi aktiv.

4.5 Einrichtung Software


Nachdem nun die Hardware soweit vorbereitet ist, beginnen wir damit die entspre-
chenden Schnittstellen zur Software zu installieren. Als wichtigstes wäre da das Frame-
work wiringpi2 (http://wiringpi.com/), welches die Schnittstelle zwischen Hardware
und weiteren, spezialisierten Libraries für unterschiedliche Programmiersprachen wie
Python oder Java bereitstellt.

4.5.1 Installation von wiringpi2


Um wiringpi2 zu installieren, wechseln wir mit dem Kommando cd ~ ins Heimverzeich-
nis unseres Nutzers pi. Anschließend laden wir mittels git clone git://git.drogon
.net/wiringPi den Quellcode der Software herunter und wechseln mit cd wiringPi/
in das entsprechende Verzeichnis. Mit dem Kommando ./build starten wir schließ-
lich den Build Prozess, sorgen also dafür dass das Programm kompiliert und installiert
wird. Dies kann einige Minuten dauern. Nach dem Abschluss des Vorgangs kann man
als ersten Test mit dem Kommando gpio -v Informationen über die Software, sowie
den verwendeten RPi Type (Model B, Rev.2) ausgeben lassen.

gpio version: 2.20


Copyright (c) 2012-2014 Gordon Henderson
This is free software with ABSOLUTELY NO WARRANTY.

27
4 Konfiguration von Raspbian

For details type: gpio -warranty

Raspberry Pi Details:
Type: Model B, Revision: 2, Memory: 512MB, Maker: Sony

Und schließlich mittels gpio readall alle GPIO Pins auf ihren Status abfragen.

+-----+-----+---------+------+---+-Model B2-+---+------+---------+-----+-----+
| BCM | wPi | Name | Mode | V | Physical | V | Mode | Name | wPi | BCM |
+-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
| | | 3.3v | | | 1 || 2 | | | 5v | | |
| 2 | 8 | SDA.1 | ALT0 | 1 | 3 || 4 | | | 5V | | |
| 3 | 9 | SCL.1 | ALT0 | 1 | 5 || 6 | | | 0v | | |
| 4 | 7 | GPIO. 7 | IN | 0 | 7 || 8 | 1 | ALT0 | TxD | 15 | 14 |
| | | 0v | | | 9 || 10 | 1 | ALT0 | RxD | 16 | 15 |
| 17 | 0 | GPIO. 0 | IN | 0 | 11 || 12 | 0 | IN | GPIO. 1 | 1 | 18 |
| 27 | 2 | GPIO. 2 | IN | 0 | 13 || 14 | | | 0v | | |
| 22 | 3 | GPIO. 3 | IN | 0 | 15 || 16 | 0 | IN | GPIO. 4 | 4 | 23 |
| | | 3.3v | | | 17 || 18 | 0 | IN | GPIO. 5 | 5 | 24 |
| 10 | 12 | MOSI | ALT0 | 0 | 19 || 20 | | | 0v | | |
| 9 | 13 | MISO | ALT0 | 0 | 21 || 22 | 0 | IN | GPIO. 6 | 6 | 25 |
| 11 | 14 | SCLK | ALT0 | 0 | 23 || 24 | 1 | ALT0 | CE0 | 10 | 8 |
| | | 0v | | | 25 || 26 | 1 | ALT0 | CE1 | 11 | 7 |
+-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
| 28 | 17 | GPIO.17 | IN | 0 | 51 || 52 | 0 | IN | GPIO.18 | 18 | 29 |
| 30 | 19 | GPIO.19 | IN | 0 | 53 || 54 | 0 | IN | GPIO.20 | 20 | 31 |
+-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
| BCM | wPi | Name | Mode | V | Physical | V | Mode | Name | wPi | BCM |
+-----+-----+---------+------+---+-Model B2-+---+------+---------+-----+-----+

4.5.2 Installation von wiringpi2-python


Als Bindeglied zwischen wiringpi2 und der Programmiersprache Python dient die Li-
brary wiringpi2-python (https://github.com/Gadgetoid/WiringPi2-Python). Um die-
se einzurichten, müssen wir vorher noch einige Erweiterungen für Python installieren:
sudo apt-get update Enter
sudo apt-get install python-setuptools python-dev Enter
Anschließend erfolgt die eigentliche Installation:
cd ~ Enter
git clone https://github.com/Gadgetoid/WiringPi2-Python.git Enter
cd WiringPi2-Python/ Enter
sudo python setup.py install Enter
Um die Funktionalität der Library zu testen möchten wir, wie auch mit gpio -v er-
mittelt, die Revision unseres RPi Boards anzeigen lassen - diesmal allerdings in Python.

28
4.5 Einrichtung Software

Wir beginnen also in dem wir mit dem Befehl sudo python die Umgebung starten. An-
schließend importieren wir die wiringpi2 Library mittels import wiringpi2 und lassen
uns die Revision des Boards ausgeben wiringpi2.piBoardRev(). Als Ausgabe erhalten
wir wieder >> 2. Damit war der Test erfolgreich und wir können Python mit exit()
verlassen.

4.5.3 Test des SPI Bus (Optional)


Um Funktionalität des SPI Bus zu testen, müssen wir die GPIO Pins 9 (MISO) und 10
(MOSI) kurzschließen. Anschließend muss das Testskript heruntergeladen, kompiliert
und ausgeführt werden:
cd ~ Enter
wget http://www.nico-maas.de/spidev_test.c Enter
gcc spidev_test.c -o spidev_test Enter
./spidev_test Enter
Sofern die Ausgabe nicht ausschließlich aus Nullen besteht, war der Loopback Test
erfolgreich:

spi mode: 0
bits per word: 8
max speed: 500000 Hz (500 KHz)
FF FF FF FF FF FF
40 00 00 00 00 95
FF FF FF FF FF FF
FF FF FF FF FF FF
FF FF FF FF FF FF
DE AD BE EF BA AD
F0 0D

Damit wären alle Vorbereitungen abgeschlossen und wir können mit der Nutzung
des Raspberry Pi beginnen.

29
5 GPIO Schnittstelle
Nachdem alle Vorbereitungen zur Nutzung der GPIO Schnittstelle in den letzten Kapi-
teln getroffen wurden, wird das Ziel in diesem Kapitel sein, mehr über diese Schnittstel-
le und deren Funktionen zu lernen. Es werden die grundlegenden Sicherheitshinweise
im Umgang mit der Schnittstelle erörtert, wie auch die Funktion der einzelnen Bus Sys-
teme. Zum Schluss wird das Erweiterungsboard, welches für diese Arbeit entwickelt
wurde, erklärt und mittels einer Testsoftware in C auf Funktionalität getestet.

5.1 Aufbau
Die GPIO Schnittstelle ist eine der besonderen Eigenschaften, welche den Raspberry
Pi von einem normalen PC unterscheidet. Durch diese Anschlüsse kann der RPi mit
zahlreichen Sensoren, Aktoren und Schaltern verbunden werden, um eine Vielzahl von
Einsatzzwecken zu ermöglichen. Zu diesem Zweck verfügt die GPIO Leiste über meh-
rere Arten von Pins:

• Einfache GPIO Pins

• GPIO Pins mit Zusatz- / Alternativfunktionen

• 3,3 Volt / 5 Volt / Ground Anschlüsse

Die genannten Pins können in nachfolgender Abbildung 5.1 eingesehen werden:

Abbildung 5.1: GPIO Schnittstelle Raspberry Pi Modell A / B / B+ [11]

Im vorangegangenen Kapitel 4 haben wir bereits die Alternativfunktionen einiger


Pins erwähnt und diese auch für die spätere Nutzung aktiviert. Bevor wir uns aller-

31
5 GPIO Schnittstelle

dings näher mit den Pins und deren Funktion beschäftigten, müssen wir uns zuerst mit
den Einschränkungen des Raspberry Pi und dessen GPIOs vertraut machen.

5.2 Sicherheitshinweise
5.2.1 Logik Level
Der Raspberry Pi arbeitet mit einem Logik Level von 3,3 Volt. Dies bedeutet, dass die
interne Schaltung des Einplatinen Computers die Spannung 3,3 Volt als „HIGH“ oder
„TRUE“ erkennt, während 0 V (Ground) als „LOW“ oder „FALSE“ interpretiert wird.
Im Bereich der MCU (z.B. Arduino) und SoC (z.B. Raspberry Pi) sind die Verwendung
von Spannungen im Bereich von 1,8 Volt, 3,3 Volt und 5 Volt üblich. Im Unterschied
zu z.B. dem Arduino ist der Raspberry Pi allerdings keines Falls 5 Volt tolerant, was
bedeutet, dass niemals mehr als 3,3 Volt direkt an einen der GPIO Pins angelegt werden
dürfen, da sonst das SoC beschädigt werden könnte.

5.2.2 Sicherungen
Der Raspberry Pi verfügt über eine 1,1 Ampere (Modell A und B), respektive 2 Ampere
(Modell B+) starke Polyfuse welche direkt an den Micro USB Port der Spannungsver-
sorgung angeschlossen ist. Die GPIO Pins selbst verfügen über keinerlei Schutz gegen
Verpolung, Kurzschluss oder Überspannung. Daher sollten Änderungen an den GPIO
Pins nur im ausgeschalteten / stromlosen Zustand des RPi gemacht werden.

5.2.3 Belastbarkeit der Pins / 3,3 Volt Schiene


Die 3,3 Volt Versorgung des Raspberry Pi wurde ursprünglich so entworfen, das jeder
der 17 Pins mit 3 mA belastet werden konnte, was eine Gesamtbelastbarkeit von 51
mA ergibt. Allerdings bezieht sich diese Bewertung nur darauf, wenn alle Pins genutzt
werden. Prinzipiell ist jeder Pin in der Lage bis zu 16 mA belastet zu werden - solange
die feste Gesamtlast 51 mA nicht überschreitet, weil sonst Schäden an der Hardware
auftreten können [16].
Diese Zahlen beziehen sich ausschließlich auf die Raspberry Pi Modelle A und B, das
neue Modell B+ erhielt eine neue Spannungsversorgung und stellt weitere GPIO Pins
zur Verfügung. In wieweit dadurch die Versorgung der GPIO Pins verbessert wurde,
ist noch nicht publiziert wurden.

5.2.4 Belastbarkeit der 5 Volt Schiene


Die 5 Volt Versorgung wird beim Raspberry Pi Modell A und B durch eine 1,1 Ampe-
re Polyfuse eingeschränkt, welche selbst ca. 100 mA Stromabfall bewirkt. Daher ist die
Belastbarkeit durch die Differenz aus der Beschränkung der Polyfuse und dem Eigen-
bedarf des Raspberry Pi, sowie weiterer angeschlossener Geräte zu errechnen. Beim
Raspberry Pi Modell A (ca. 500 mA) erhält man daher 500 mA, beim Modell B (ca. 700

32
5.3 GPIO

mA) 300 mA Reserven für z.B. Erweiterungsplatinen oder USB Geräte. Beim Modell B+
wurde die Polyfuse auf 2 Ampere erhöht und zusätzlich durch die neue Spannungsver-
sorgung der Strombedarf des Raspberry Pi selbst reduziert, weshalb man davon ausge-
hen kann, dass die zusätzlichen Reserven dort - je nach verwendetem Netzteil - mehr
als 1,3 Ampere betragen können.

5.2.5 Zusammenfassung
• Nur im ausgeschalteten Zustand an der GPIO Leiste arbeiten

• Keine Spannungen über 3,3 Volt an den Raspberry Pi anschließen

• Keine Pins kurzschließen

• Schaltung immer doppelt auf Verpolung / falsche Belegung überprüfen

• Belastbarkeit beachten, größere Lasten z.B. mit Transistor schalten

5.3 GPIO
Wie bereits in Abbildung 5.1 dargestellt, verfügt die GPIO Schnittstelle über eine Viel-
zahl an unterschiedlichen Pins deren Möglichkeiten wir nun genauer erörtern werden.

5.3.1 GPIO
Die in grüner Farbe gekennzeichneten Pins stellen die normalen GPIO Pins ohne wei-
tere Zusatzfunktionen da. Diese Pins dienen je nach Nutzereinstellung als digitale Ein-
oder Ausgabe und können entweder über Einsatz des gpio Programms aus dem wiring-
pi2 Package, oder direkt per echo angesteuert werden. Als erster Schritt muss zuerst der
entsprechende GPIO Pin exportiert, also für die Nutzung im Linux Userspace vorbe-
reitet werden. Anschließend muss die Art der Verwendung angegeben werden, also
ob der Pin zur Ein- oder Ausgabe dienen soll. Abschließend kann der Status des Pins
ausgelesen, beziehungsweise „HIGH“ oder „LOW“ gesetzt werden - je nach Einsatz-
zweck.

# Beispiel für die direkte Verwendung in Bash mittels echo


# Pin 24 exportieren
sudo echo "24" > /sys/class/gpio/export
# Pin 24 als Ausgabe festlegen
echo "out" > /sys/class/gpio/gpio24/direction
# Pin 24 auf HIGH setzen
echo 1 > /sys/class/gpio/gpio24/value
# Pin 24 auf LOW setzen
echo 0 > /sys/class/gpio/gpio24/value
# Export von Pin 24 aufheben

33
5 GPIO Schnittstelle

echo "24" > /sys/class/gpio/unexport

# Pin 27 exportieren
sudo echo "27" > /sys/class/gpio/export
# Pin 27 als Eingabe festlegen
echo "in" > /sys/class/gpio/gpio27/direction
# Pin 27 auslesen
cat /sys/class/gpio/gpio27/value
# Export von Pin 27 aufheben
echo "27" > /sys/class/gpio/unexport
Die Verwendung mit dem Tool gpio geht noch etwas einfacher und benötigt keine
root Rechte:
# Beispiel für die direkte Verwendung in Bash mittels gpio
# Pin 24 exportieren und als Ausgabe festlegen
gpio export 24 out
# Pin 24 auf HIGH setzen
gpio -g write 24 1
# Pin 24 auf LOW setzen
gpio -g write 24 0
# Export von Pin 24 aufheben
gpio unexport 24

# Pin 27 exportieren und als Eingabe festlegen


gpio export 27 in
# Pin 27 auslesen
gpio -g read 27
# Export von Pin 27 aufheben
gpio unexport 27

5.3.2 PWM
Pulse-width modulation (PWM) ist ein Verfahren mit welchem die Breite eines ausge-
gebenen Stromimpulses kontrolliert werden kann. In diesem Zusammenhang wird der
Begriff „duty cycle“ verwendet, um die Dauer des „HIGH“ Zustandes des Pins inner-
halb einer Zeiteinheit zu beschreiben. Entspricht der „duty cycle“ z.B. 60%, so führt
der Pin in genau diesem Prozent einer Zeiteinheit Strom. Durch das lückenhafte Ver-
sorgen des Gerätes mit Strom sinkt die Spannung je nach „duty cycle“ von 100% auf
bis 0% ab. Mit dieser Technik können damit nicht nur die Helligkeit von LEDs kon-
trolliert werden, sondern im Sonderfall auch die Stellung von Servo Motoren. PWM ist
bei dem Raspberry Pi auf dem GPIO 18 verfügbar. Aufgrund der besonderen Technik
(prinzipiell dem schnellen, kontrollierten Ein- / Ausschalten des Pins) ist eine sinnvolle
Nutzung mittels echo Befehls nicht gegeben. Allerdings kann auch in diesem Fall das
Programm gpio genutzt werden:

34
5.3 GPIO

# Beispiel für die direkte Verwendung in Bash mittels gpio


# Pin 18 exportieren und als Ausgabe festlegen
gpio export 18 out
# Pin 18 in PWM Modus versetzen
gpio -g mode 18 pwm
# Pin 18 als PWM auf 100% duty cycle setzen
gpio -g pwm 18 1023
# Pin 18 als PWM auf 25% duty cycle setzen
gpio -g pwm 18 256
# Pin 18 als PWM auf 10% duty cycle setzen
gpio -g pwm 18 102
# Pin 18 als PWM auf 1% duty cycle setzen
gpio -g pwm 18 10
# Pin 18 als PWM auf 0% duty cycle setzen
gpio -g pwm 18 0
# Export von Pin 18 aufheben
gpio unexport 18

5.3.3 I2C
Inter-Integrated Circuit (I2C) ist ein Bussystem, welches 1982 von der Firma Philips
(heute: NXP Semiconductors) veröffentlicht wurde. Dieses System sollte vorrangig da-
zu genutzt werden, einzelne Komponenten innerhalb eines geschlossen Systems mit-
einander zu verbinden, z.B. Mikrocontroller mit verschiedenen Arten von Sensoren,
Speichern und Analog/Digital bzw. Digital/Analog Wandlern. Da das System neben
der Versorgungsspannung und Masse nur zwei Leitungen (SDA für Daten, SCL für
Takt) benötigt wird es auch als Two Wire Interface (TWI) bezeichnet. SDA wie SCL müs-
sen durch einen hochohmigen Widerstand an die Versorgungsspannung angeschlossen
werden, da der Bus im Leerlauf Konstant „HIGH“ signalisiert (Pull-Up). In einem nor-
malen I2C Netzwerk erzeugt der Master, meist ein Mikrocontroller, den Takt für den
SCL Port und fragt die einzelnen Slaves, meist simple Sensoren oder Signalwandler,
unter Verwendung des SDA Ports ab. Es ist allerdings auch möglich Master-Master
Netzwerke zu erstellen und Teilnehmer bei aktivem Netzwerk an- und abzuklemmen
(Hot-Swap) [25], S. 444 / [19].
Der Raspberry Pi verfügt über zwei I2C Busse. Bei der Revision pre 2.0 wurde nur der
Bus 0 auf dem GPIO Header ausgeführt. Mit dem Wechsel zur Revision 2.0 wanderte
der Bus 0 auf ein zusätzliches Verbindungsfeld (P5) und auf dem GPIO Header lag
nun der Bus 1 an. Beim Modell B+ änderte sich dieser Zustand dahingehend, dass der
Header P5 wieder entfiel, der Bus 1 weiterhin auf seiner Stelle auf dem GPIO Header
verblieb und der Bus 0 fortan als ID_I2C geführt wurde und für die Nutzung durch den
Anwender nicht mehr verfügbar war.
Der I2CBus auf dem Raspberry Pi arbeitet in der Standard Geschwindigkeit (100
kHz) und im Fast-Mode (400 kHz). Theoretisch kann ein I2C Bus bis zu 127 Teilneh-

35
5 GPIO Schnittstelle

mer adressieren.
Mittels des Befehls i2cdetect -y 1 können alle Geräte auf dem Bus 1 angezeigt wer-
den:

0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- UU -- -- -- --
40: -- -- -- -- -- -- -- -- 48 -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

Unter anderem ist hier die Adresse 0x48 angezeigt, welches die hexadezimale Adres-
se eines LM75B Temperatursensors ist. Da laut Datenblatt dieses Sensors die Tempera-
tur bei diesem Gerät im ersten Register liegt, können wir nun mit dem Befehl i2cget
-y 1 0x48 0x00 auf dem Bus 1 an der Geräteadresse 48 das Register 0 auslesen. Wir
erhalten die Antwort in Form einer hexadezimalen Notation, z.B. 0x23, was im dezimal
System einer Temperatur von 35 Grad Celsius entspricht.

5.3.4 I2S
Nach dem Erfolg von I2C folgte 1986 Philips Erweiterung I2S. Dabei handelt es sich
um ein Bussystem, welches ausschließlich zur Verwendung innerhalb von Audiogerä-
ten vorgesehen war. Es wurden hierbei wieder ein Takt Signal (SCK) und ein Daten
Signal (SD) verwendet, zusätzlich wurden diese beiden Leitungen allerdings noch um
eine sogenannte Word Select (WS) Leitung ergänzt. Je nachdem ob sich Word Select
im Zustand „LOW“ oder „HIGH“ befindet, werden die übertragenen Daten dem lin-
ken, respektive rechtem Audiokanal zugeordnet. Da die Übertragung vollständig digi-
tal geschieht, ist sie verlustfrei und daher für die Verbindung von z.B. Digitalen Signal
Prozessoren und Digital/Analog Wandlern geeignet.
Beim Raspberry Pi ist der I2S Bus bei der Revision pre 2.0 nicht vorhanden, bei der
Revision 2.0 auf dem Header P5 zu finden und bei dem Modell B+ auf dem GPIO
Header. [21]

5.3.5 SPI
Der Serial Peripheral Interface (SPI) Bus wurde 1979 von Motorola in Form eines Mikro-
controllers auf Basis des Motorola 68000 Mikroprozessors veröffentlicht. Im Gegensatz
zum I2C Bus von Philips wurde er nicht getrennt formal beschrieben, sondern ist nur
vage in den Unterlagen des Controllers als Teil dessen definiert [15]. Das SPI System
verwendet vier Anschlüsse: Takt (SCLK), Master Out - Slave In (MOSI), Master In -

36
5.3 GPIO

Salve Out (MISO), sowie Slave Select (SS). Der Takt wird hierbei konstant vom Mas-
ter über SCLK vorgegeben, und die Daten je nach Senderichtung entweder über MOSI
(vom Master zum Slave) oder MISO (vom Slave zum Master) ausgetauscht. Zusätzlich
muss für jedes zu adressierende Gerät im Bus eine Slave Select Leitung bereitstehen.
Diese wird vom Master auf „LOW“ gezogen, um den Slave in Empfangsbereitschaft
zu schalten. Der Vorteil dieses Systems liegt in der vollduplexfähigen Kommunikation,
der Nachteil in der Anzahl der benötigten n Slave Select Leitungen pro n Geräte in der
Sternverbindung. Sollte man kompatible Slave Geräte gleicher Bauart verwenden, so
können diese auch kaskadiert werden, womit nur eine Slave Select Leitung nötig ist.
Die Geräte können dann wie ein Schieberegister ausgelesen werden [25], S. 440.
Auf dem Raspberry Pi sind drei SPI Controller verfügbar, jedoch nur einer auf die
GPIO Leiste ausgeführt. Der Controller kann auf 0.5 MHz, 1 MHz, 2 MHz, 4 MHz, 8
MHz, 16 MHz und 32 MHz Taktrate eingestellt werden [13]. Die maximal verwendbare
Taktrate hängt aber auch vom verwendeten Slave ab.
SPI kann unter Raspberry Pi am besten über die entsprechende Library mittels Py-
thon oder C angesteuert werden.

5.3.6 Serial
Die serielle Schnittstelle (auch V.24 oder RS-232-C genannt) wurde 1969 von der Electro-
nic Industries Association (EIA) für die Nutzung im Computer Umfeld definiert, was
den ursprünglichen Einsatzzweck von RS-232 im Umfeld der Fernschreiber erweiterte
[7]. Serielle, asynchrone Verbindungen wurden vor den Zeiten der Breitbandverbin-
dungen genutzt um Modems mit dem Computer zu verbinden um Zugriff zum Inter-
net oder dem Telefonnetz herzustellen. Mit dem Aufkommen von A-/S-DSL und Ka-
belbreitbandverbindungen wurde diese Schnittstelle an regulären Rechnern immer un-
wichtiger, kann aber bis heute vorgefunden werden. Eine besondere Bedeutung nimmt
dieses Interface weiterhin bei eingebetteten Systemen, Mikrocontrollern, GPS Emp-
fängern, wissenschaftlichen Geräten sowie Netzwerkequipment und Servern ein. Die
Übertragung der seriellen Schnittstelle erfolgt prinzipiell über zwei Adern: RX (Recie-
ve) und TX (Transmit). Die Verbindung muss direkt zwischen Sender und Empfänger
hergestellt und die beiden Datenadern überkreuzt angeschlossen werden, also RX des
Senders auf TX des Empfängers und umgekehrt. Zusätzlich muss die Masse (GND)
beider Systeme miteinander verbunden werden. Als Geschwindigkeiten werden häu-
fig 4800, 9600, 19200 und 115200 Baud (Zeichen pro Sekunde) verwendet. Eine Beson-
derheit ist im Bereich von eingebetteten Systemen, Mikrocontrollern, GPS Empfängern
und anderen Klein- und Kleinstgeräten zu beachten: Im Gegensatz zu den im RS-232-
C definierten Signalpegeln von -15 Volt bis +15 Volt [12] setzen diese Geräte oft einen
sogenannten TTL Pegel (Transistor-Transistor Logic) ein, welcher zwischen 0 Volt und
3,3 Volt, respektive 5 Volt liegen kann. Dies trifft auch auf den Raspberry Pi zu, wes-
halb dessen serielle Schnittstelle in keinem Fall direkt mit dem PC zu verbinden ist,
da sonst eine Beschädigung des SoC des Raspberry Pi möglich ist. Durch die Nutzung
eines TTL-Serial Konverters ist diese Verbindung gefahrlos möglich.

37
5 GPIO Schnittstelle

Auf dem Raspberry Pi kann die serielle Schnittstelle auf verschiedene Arten genutzt
werden. Zum einen um einen GPS Empfänger anzuschließen, einen Mikrocontroller
mit Arduino Bootloader zu programmieren oder um Modell A Boards ohne Netzwer-
kinterface per PPP (Point-to-Point Protocoll) in ein Netzwerk zu integrieren.
Ein einfaches und empfehlenswertes Tool um die serielle Schnittstelle zu nutzen,
stellt minicom dar.

5.4 Das Erweiterungsboard


Um die Nutzung der GPIO des Raspberry Pi zu ersten Testzwecken so einfach wie
möglich zu machen, wurde im Rahmen dieser Thesis ein Erweiterungsboard entworfen
und zur Verwendung im Rahmen der Lehre der HTW Saar in zehnfacher Stückzahl
aufgebaut.

5.4.1 Design
Das Design sollte so ausgelegt sein, dass es möglichst klein, kostengünstig und dennoch
vielseitig verwendbar sein sollte. Durch die Entwicklung des Boards sollten besonders
Fehler die beim Aufbau der Schaltungen mit der GPIO Leiste auftreten könnten verhin-
dert werden, und der Fokus auf die Entwicklung der Software gelegt werden. Da zum
Zeitpunkt des Beginns dieser Thesis der Raspberry Pi Modell B+ noch nicht verfügbar
war, wurde die Platine auf Basis des Modell A/B Rev. 2.0 entwickelt und ist auf beiden
Versionen ohne Einschränkungen verwendbar. Ebenfalls ist die Nutzung mit dem neu-
en Modell B+ möglich, wobei allerdings keine korrekte mechanische Entlastung wie bei
den Modellen A/B Rev. 2.0 durch ein passendes Bohrloch gegeben ist.
Das Erweiterungsboard stellt folgende Merkmale zur Verfügung:

• Vier einfarbige LEDs

• Vier Taster

• LM75B (I2C Temperatursensor)

• MCP3002 (SPI Zweikanal Analog/Digital Wandler) mit angeschlossenem Light


Dependent Resistor (LDR)

Dabei sind die LEDs in einem Steuerkreuz angeordnet und den betreffenden Tastern
zugeordnet.

5.4.2 Routing
Die Belegung und Anschlüsse der einzelnen Komponenten auf dem Erweiterungs-
board lässt sich der angefügten Grafik und Tabelle entnehmen.

38
5.4 Das Erweiterungsboard

Bauteil Bemerkung GPIO

LED North grün, PWM 18


LED East rot 23
LED West gelb 25
LM75B
LED South blau 24
Switch North Pull-Down 4
Switch East Pull-Down 17
Nor
th
Switch West Pull-Down 22
Switch South Pull-Down 27
East
LM75B SDA 2
SCL 3
West
MCP3002 MOSI 10
MISO 9
Sout
h
MCP3002 SCLK 11
CS / SS 8

Abbildung 5.2 & Tabelle 5.1: Erweiterungsboard und Routing der Komponenten

Als Besonderheiten sei dabei zu erwähnen, dass die erste LED (LED North / grün)
am PWM Anschluss des RPi angeschlossen ist, um die Nutzung dieses Verfahrens zu
demonstrieren.
Die LEDs selbst werden nicht direkt von den GPIO Pins versorgt, sondern schalten
einen Transistor, welche wiederum die Schaltlast übernimmt und die LEDs mit 5 Volt
Spannung versorgt.
Weiterhin werden die Taster durch einen Pull-Down Widerstand konstant auf „LOW“
gezogen, sind also mit der Masse des Raspberry Pi verbunden. Es ist üblich Taster ent-
weder per Pull-Down auf „LOW“ oder per Pull-Up auf „HIGH“ zu ziehen, um einen
stets definierten Zustand zu erreichen. Erst beim Schließen des Kontaktes wird der ent-
sprechende GPIO Port mit 3,3 Volt Spannung verbunden.
Zur Temperaturmessung steht ein LM75B zur Verfügung, ein I2C Sensor, welcher di-
rekt auf dem Board verbaut ist. Durch das normale Auslesen des Wertes mittels i2cget
erhält man den Temperaturwert in 8 bit Darstellung, also nur Abstufungen von einzel-
nen Grad. Möchte mit die kompletten 11 bit Auflösung des Sensors ausnutzen, also eine
Auflösung von bis zu 0,125 Grad Celsius Unterschied erreichen, so muss das entspre-
chende Register in doppelter Byte Länge ausgelesen und ausgewertet werden. Dazu
kommen wir in einem späteren Kapitel.
Der erwähnte Lichtsensor (LDR) verhält sich wie ein Widerstand und erreicht je nach
einfallendem Licht Werte zwischen 40,5 k und 1 M Ohm. Da der Raspberry Pi allerdings

39
5 GPIO Schnittstelle

über keinen Analog/Digital Wandler verfügt um z.B. eine Spannungsmessung durch-


zuführen, wird der an einem MCP3002 angeschlossen, einem externen Analog Digital
Converter (ADC) welcher über SPI angesprochen wird.
Insgesamt bleiben damit ausschließlich die GPIO Pins 14 und 15 (TX/RX der Serial
Verbindung) und GPIO 7 (SPI Slave Select 1) ungenutzt.

5.4.3 Testprogramm
Um die Funktionalität des Erweiterungsboards zu überprüfen, gibt es im Home Ver-
zeichnis des Raspberry Pi Hauptnutzers pi den Unterordner RPi_HTW/boardTest, wel-
chen das in C geschrieben Testprogramm boardTest beinhaltet. Es verwendet die bereit
vorher installierte wiringpi2 Library, um die unterschiedlichen Funktionen des Erwei-
terungsboards auf Funktionalität zu überprüfen. Dazu gehören die LEDs, die PWM
Funktionalität, die Schalter wie auch der I2C Bus mit dem angeschlossenen LM75B
Temperatursensor und dem SPI Bus mit dem MCP3002 ADC Wandler. Letzterer gibt
auf Kanal 0 den Helligkeitswert des angeschlossenen LDR wieder. Um es zu nutzen
muss es zuerst kompiliert werden, was der Aufruf von make erledigt. Anschließend
kann das Programm unter Verwendung von sudo sudo ./boardTest gestartet werden.
Eine Beispielausgabe sieht wie folgt aus:

LED Test beginnt


NORTH: LED gruen
EAST: LED rot
WEST: LED gelb
SOUTH: LED blau
LED Test beendet
PWM Test beginnt
PWM Test beendet
Switch Test beginnt
NORTH: Switch druecken
NORTH: Switch ok
EAST: Switch druecken
EAST: Switch ok
WEST: Switch druecken
WEST: Switch ok
SOUTH: Switch druecken
SOUTH: Switch ok
Switch Test beendet
LM75B Temperatursensor Test beginnt
LM75B: 34.12 Grad Celsius
LM75B: 34.25 Grad Celsius
LM75B: 34.12 Grad Celsius
LM75B: 34.12 Grad Celsius
LM75B: 33.88 Grad Celsius

40
5.4 Das Erweiterungsboard

LM75B: 34.00 Grad Celsius


LM75B: 34.00 Grad Celsius
LM75B: 34.00 Grad Celsius
LM75B: 34.12 Grad Celsius
LM75B: 34.00 Grad Celsius
LM75B Temperatursensor Test beendet
MCP3002 ADC Test beginnt
MCP3002 - Channel 0: 232
MCP3002 - Channel 0: 320
MCP3002 - Channel 0: 348
MCP3002 - Channel 0: 72
MCP3002 - Channel 0: 48
MCP3002 - Channel 0: 300
MCP3002 - Channel 0: 332
MCP3002 - Channel 0: 724
MCP3002 - Channel 0: 612
MCP3002 - Channel 0: 616
MCP3002 ADC Test beendet
Die boardTest.c ist im Anhang D.1 verzeichnet. Sollte ein eigenes Programm ohne die
make File kompiliert werden, so ist es wichtig, den Schalter -lwiringPi anzugeben. Bei-
spielsweise: gcc -o test test.c -lwiringPi.

41
6 Bash Programmierung
In diesem Kapitel soll die Nutzung des Erweiterungsboards unter Verwendung der
Bash anhand eines Beispielprojektes aufgezeigt werden: Ziel wird es sein, einen Klon
des alten elektronischen Spiels „Simon“ zu erstellen, und damit die in der Vorlesung
„Betriebssystem Einführung“ gelernten Grundlagen zu vertiefen und festigen.

6.1 Grundlagen
6.1.1 Simon
Simon ist ein 1977 erfundenes, elektronisches reaktions- und Merkspiel auf Basis des
Texas Instruments TMS1000 Mikrocontrollers [18]. Simon verfügt über vier LEDs (grün,
rot, blau, gelb) und entsprechend, den Farben zugewiesene Taster. Das Spiel beginnt in
dem eine zufällige Farbe auf dem Spielzeug aufleuchtet und der Spieler eben dem die-
ser Farbe entsprechenden Schalter drückt. War er erfolgreich, werden in der nächsten
Runde die Farbe des ersten Zyklus plus eine weitere Farbe vorgegeben, welcher der
Spieler wieder in der richtigen Reihenfolge eingeben muss. Das Spiel endet falls der
Spieler eine falsche Kombination eingibt.

Abbildung 6.1: Simon

43
6 Bash Programmierung

6.1.2 Ablaufdiagramm
Ein prinzipieller grober Ablauf des Spiels ist in Abbildung 6.2 aufgezeigt. Darüber hin-
aus empfiehlt es sich zusätzlich den Start und das Ende des Programms durch die Ver-
wendung aller LEDs zu kennzeichnen und gegeben falls einen rekursiven Aufruf beim
Ende durchzuführen.

Abbildung 6.2: Flowchart Simon

6.2 Programmierung
Alle genannten Dateien sind im Home Verzeichnis des Hauptnutzers pi im Unterord-
ner RPi_HTW/Simon zu finden.

44
6.2 Programmierung

6.2.1 Erweiterungsboard und Hilfsfunktionen


Das Erweiterungsboard bietet für dieses Projekt die vier genannten LEDs, nebst den
benötigten Schaltern. Um die Entwicklung zu vereinfachen steht die gpio.sh im Anhang
D.2 zur Verfügung, welche die benötigten Funktionen zur Nutzung der an die GPIO
Pins angeschlossenen LEDs und Schalter bereitstellt. Für jede LED existiert jeweils ei-
ne Funktion, um diese ein-, beziehungsweise auszuschalten. Für die Schalter gibt es
jeweils eine Funktion, welche den aktuellen Status zurück gibt (0 für „LOW“ bezie-
hungsweise nicht gedrückt, 1 für „HIGH“ beziehungsweise gedrückt).

• ledNorthOn()

• ledNorthOff()

• ledEastOn()

• ledEastOff()

• ledWestOn()

• ledWestOff()

• ledSouthOn()

• ledSouthOff()

• switchNorth()

• switchEast()

• switchWest()

• switchSouth()

Neben diesen Funktionen gibt es noch mehrere Hilfsfunktionen:

• ledOn()

• ledOff()

• ledBlink()

• ledBlinkFast()

Die beiden ersten Hilfsfunktionen schalten alle LEDs an, beziehungsweise aus. Die
letzteren beiden lassen jeweils alle LEDs einmal mit einem Abstand von 0,5, respekti-
ve 0,25 Sekunden aufblinken. In den nachfolgenden beiden Unterkapiteln werden wir
diese Funktionen nutzen.

45
6 Bash Programmierung

6.2.2 LED Ausgabe


Um eine LED per Bash anzusteuern, können wir unter Verwendung der gpio.sh folgen-
des Skript erstellen:
# !/ bin / bash
source gpio . sh
ledNorthOn
sleep 2
ledNorthOff

Mit source gpio.sh binden wir die gpio.sh und ihre Hilfsfunktionen ein, welche wir
mit ledNorthOn beziehungsweise ledNorthOff nutzen um die grüne LED an- beziehungs-
weise auszuschalten. sleep 2 rundet das ganze Programm ab und erzeugt eine Pause
von zwei Sekunden, damit der sonst zu schnelle Schaltvorgang für das menschliche
Auge sichtbar wird. Das Codelisting der demoLed.sh ist als Langversion auch im An-
hang D.3 verfügbar. Nachdem die Datei erstellt wurde, muss sie unter Verwendung des
Befehls chmod +x dateiname ausführbar gemacht, und anschließend mittels ./dateiname
gestartet.

6.2.3 Switch Eingabe


Die Eingabe ist wie die LED Ausgabe ebenfalls sehr einfach zu bewerkstelligen:
# !/ bin / bash
source gpio . sh
while :
do
if [ $ ( switchNorth ) = 1 ]
then
echo " North gedrueckt "
ledNorthOn
else
ledNorthOff
fi
done

Das Programm läuft in diesem Beispiel in einer endlosen Schleife, welche mittels
der Tastenkombination Strg + C unterbrochen werden kann. Durch die while Schleife
wird ständig geprüft, ob der Schalter North gedrückt wurde. Ist dies der Fall, wird eine
entsprechende Nachricht ausgegeben, und die dazu passende LED angeschaltet. Sollte
dem nicht so sein, wird die LED ausgeschaltet. Es gibt auch die Möglichkeit Pins nicht
per polling, also dauerndem Abfragen auf einen Wechsel des Zustandes zu überprüfen,
sondern per Interrupt. Dies setzt aber eine höhere Programmiersprache voraus und
ist daher leider in Bash nicht möglich (siehe dazu: http://wiringpi.com/reference/
priority-interrupts-and-threads/).

46
6.3 Abschluss

6.3 Abschluss
Mit den hier gelernten Grundlagen, sowie dem Wissen aus der Vorlesung „Betriebs-
system Einführung“ sollte es nun möglich sein, einen einfachen Klon des Spiels Simon
mittels des Raspberry Pi und dem Erweiterungsboard zu erschaffen. Das Musterpro-
gramm simon.sh ist im Anhang D.5 zu finden, allerdings nicht auf der SD Karte vorin-
stalliert, um die Studenten zur Entwicklung einer eigenen Lösung anzuhalten.

47
7 Python Programmierung
Nachdem wir im vorangegangenen Kapitel die Nutzung der GPIO mittels Bash gelernt
haben, wollen wir diese Fähigkeiten nun mit der Programmiersprache Python vertie-
fen. Dieses Kapitel soll als leichter Einstieg in die Sprache Python die Grundlagen für
die Vorlesung „Systemmanagement und Sicherheit“ liefern, wie auch die praktische
Nutzung von Bus Systemen, wie sie in „Rechnerarchitektur“ und „Mikroprozessor-
technik“ gelehrt werden verdeutlichen. Am Ende dieses Kapitels werden sowohl die
Grundlagen zur Nutzung von Python gelegt, als auch der I2C, wie auch der SPI Bus, in
die Nutzung eingeflossen sein.

7.1 Arbeiten auf dem Raspberry Pi


7.1.1 Python 2 / Python 3
Python ist ähnlich wie PHP, eine Skriptsprache die zur Ausführung einen Interpreter
benötigt. Von Python gibt es inzwischen zwei verschiedene Versionen: Python 2 (2.7.x)
und Python 3 (3.4.x). Python 3 enthält Verbesserungen, welche allerdings die Kompa-
tibilität unter anderem wegen der Entfernung redundanter Befehle zu alten Skripten
brechen kann. Da die Version 2 bereits länger existiert, viele Bibliotheken nur in dieser
Version funktionieren, und dieser Branch immer noch mit aktuellen Updates versorgt
wird, ist Python 2 auch auf dem Raspberry Pi die empfohlene und verwendete Stan-
dardversion. Sollten durch den vorzeitigen Abbruch eines Programms LEDs im aktiven
Zustand verbleiben, können die GPIO Pins mittels des CLI Kommandos gpio reset zu-
rückgesetzt und damit die LEDs ausgeschaltet werden.

7.1.2 Programmierung mittels IDLE


Verwendet man den Raspberry Pi als vollwertigen PC, empfiehlt sich die Nutzung des
Python Integrated Development Environment (IDE) IDLE. IDLE liegt auf dem RPi in
zwei Versionen vor. Einmal als IDLE (zur Nutzung mittels Python 2) als auch als IDLE3
(welches Python 3 einsetzt). Wie bereits erwähnt werden wir Python 2, und damit das
normale IDLE nutzen. Da die Nutzung der GPIO Pins root Rechte erfordert, sollte man
IDLE nicht per Klick auf das Desktop Icon, sondern mittels LXTerminal unter Verwen-
dung des Befehls sudo idle & starten, um die Anwendung im Kontext des root Nutzers
zu starten. Die Nutzung selbst ist sehr einfach: Über das Menü File, New Window kann
man ein neues Editor Fenster erstellen, in welchem man seinen Python Code schreiben,
laden und speichern kann. Ausgeführt wird dieser Code über das Menü Run per Klick
auf Run Module.

49
7 Python Programmierung

7.1.3 Programmierung mittels CLI


Sollte man den RPi Headless verwenden, also ohne Bildschirm und Eingabegeräte,
empfiehlt sich die Nutzung eines Texteditors wie vi in Kombination mit python direkt
auf Ebene des Command Line Interface (CLI) / der Shell. Dazu sollte man seinen Pro-
grammcode mit einem Editor seiner Wahl schreiben, speichern und schließlich direkt
unter Verwendung von sudo python dateiname ausführen.

7.2 Grundlagen der Python Programmierung


7.2.1 Ausführung
Es gibt drei prinzipielle Möglichkeiten ein Python Programm auszuführen: 1.) Die di-
rekte Eingabe der Befehle in eine interaktive Shell wie IDLE oder python auf dem
CLI. 2.) Der direkte Aufruf einer geschriebenen Skriptdatei mittels python dateiname
.py im CLI. 3.) Die Verwendung der Shebang Zeile (#!/usr/bin/python) als erste Zeile
in einer Skriptdatei, gefolgt vom setzen des X / Ausführungbarkeits-Bits (./chmod +x
dateiname.py) und dem anschließenden Aufruf im CLI (./dateiname.py). Um Python
kennen zu lernen empfiehlt sich besonders am Anfang die Arbeit in einer interaktiven
Shell, für die spätere Programmentwicklung die Methoden Zwei und Drei.

7.2.2 Variablen
Variablen werden bei Python durch Zuweisung eines Wertes angelegt:
# !/ usr / bin / python
meinInteger =2+3
meinFloat =5.0
meinString = " Hallo Welt "
print ( meinInteger )
print ( meinInteger / 2)
print ( meinFloat / 2)
print ( meinString + " ! " + " Binaer % s Hex % s " % ( bin ( meinInteger ) , hex (
meinInteger ) ) )

Dies erzeugt die Ausgabe:
5
2
2.5
Hallo Welt ! Binaer 0 b101 Hex 0 x5


7.2.3 Operatoren
Python verwendet die üblichen arithmetischen Operatoren. Besondere Beachtung fällt
dabei auf den verwendeten Datentyp: Sollte ein Integer Wert geteilt werden, so ist das

50
7.2 Grundlagen der Python Programmierung

Tabelle 7.1: Arithmetische Operatoren

Operation Ergebnis Bezeichnung

5+5 10 Summe
5-1 4 Differenz
5*1 5 Produkt
5/2 2 Quotient (Integer)
5.0 / 2 2.5 Quotient (Float)
5%2 1 Modulo
2 ** 3 8 Power

Ergebnis ebenfalls ein Integer. Wenn im Rahmen dieser Rechenoperation eine rationale
Zahl entsteht, so wird diese abgerundet und als ganze Zahl dargestellt.
Die Vergleichsoperatoren sind ebenfalls bekannt sofern man Vorkenntnisse in Java
besitzt:

Tabelle 7.2: Vergleichsoperatoren

Operation Bezeichnung

x == y Gleichheit
x != y Ungleichheit
x>y Größer
x<y Kleiner
x >= y Größer-gleich
x<= y Kleiner-gleich

Da in diesem Dokument mit hardwarenahen Anwendungen gearbeitet wird, ist es


auch von Bedeutung die binären, bitweisen Operatoren zu kennen. Dies ist besonders
wichtig da Geräte in Bussystemen wie I2C oder SPI ihre Ergebnisse in einzelnen Re-
gistern speichern, welche meist wenige Byte umfassen. Dabei besitzt häufig jedes Bit
eines Bytes eine eigene Relevanz, zum Beispiel die Konfiguration eines Pins als Ein-
oder Ausgang, je nachdem ob dessen Bit gesetzt ist oder nicht. Durch die binären, bit-
weisen Operationen können diese Werte entsprechend schnell gesetzt beziehungsweise
ausgelesen werden. Um einen Wert in binärer Schreibweise eingeben zu können, muss
ihm der Präfix 0B vorgestellt werden. So würde zum Beispiel die Zahl 0B11110000 von
Python als 240 verstanden werden. Alternativ können die binären, bitweisen Operatio-
nen auch mit den Werten in beliebiger anderer, zum Beispiel dezimaler Schreibweise
angewandt werden.
Die vier wichtigsten Operationen, welche auch schon in den Vorlesungen „Digital-

51
7 Python Programmierung

technik 1“ und „Mikroprozessortechnik“ gelehrt wurden, sollen an dieser Stelle noch


einmal kurz wiederholt werden:
1.) Binäres Und:
Es werden jeweils die Werte gleicher Position beider binärer Notationen per „Und“
miteinander verknüpft. Sollten diese beide „Wahr“ entsprechen, ist auch das Ergebnis
„Wahr“ - sonst „Falsch“.

Tabelle 7.3: Binäres Und

x y x&y

0 0 0
0 1 0
1 0 0
1 1 1

2.) Binäres Oder:


Das binäre „Oder“ entspricht der gleichen Wirkungsweise wie „Und“, allerdings wird
die Ausgabe „Wahr“ solange entweder eine oder beide Werte „Wahr“ sind.

Tabelle 7.4: Binäres Oder

x y x|y

0 0 0
0 1 1
1 0 1
1 1 1

3.) Binäres XOR:


XOR, welches auch zur Verschlüsselung genutzt wird, erwartet als Voraussetzung für
eine „Wahre“ Ausgabe zwei unterschiedliche Eingaben.

Tabelle 7.5: Binäres XOR

x y xˆy

0 0 0
0 1 1
1 0 1
1 1 0

52
7.2 Grundlagen der Python Programmierung

4.) Binäres 1er Komplement:


Das 1er Komplement wird zur Berechnung im Bereich der Mikrocontroller verwendet
und negiert alle Eingaben.

Tabelle 7.6: Binäres 1er Komplement

x ˜x

0 1
1 0

Tabelle 7.7: Binäre, bitweise Operatoren

Operation Ergebnis Bezeichnung

x&y 0000 0001 / 1 Binäres Und


x|y 1111 1111 / 255 Binäres Oder
xˆy 1111 1110 / 254 Binäres XOR
˜x 1111 0000 / -16 Binäres 1er Komplement

7.2.4 Vergleiche und Schleifen


Eine wichtige Besonderheit bei Python ist das Fehlen von Klammern zum Kapseln von
Schleifen oder Befehlsfolgen. Stattdessen verwendet Python Einrückungen wie die Ta-
bulator Taste, um den Programmcode zu formatieren und strukturieren. Dies erzeugt
sauberen und lesbaren Code, welcher ohne diese Einrückungen nicht lauffähig ist. Im
nächsten Beispiel wird eine while Schleife und eine verschachtelte if Anweisung ge-
zeigt. Da die letzte Zeile sich auf der gleichen Ebene wie die Vergleiche befinden, ist sie
kein Teil davon und wird nach der Abarbeitung der Vergleiche aufgerufen.
# !/ usr / bin / python
meinInteger =40
while meinInteger < 45:
if meinInteger == 42:
print ( " Integer ist 42! " )
elif meinInteger < 42:
print ( " Integer ist kleiner als 42 " )
else :
print ( " Integer ist groesser als 42 " )
meinInteger += 1

Dies erzeugt die Ausgabe:
Integer ist kleiner als 42
Integer ist kleiner als 42

53
7 Python Programmierung

Integer ist 42!


Integer ist groesser als 42
Integer ist groesser als 42

Die for Schleife kann auf mehrere Art genutzt werden:
# !/ usr / bin / python
# Zaehlschleife , Werte zwischen 0 und 5 ( von 0 -4) ausgeben
for i in range (0 ,5) :
print ( i )

# Äquivalent zur for each


# jedes Element einer Liste verwenden
sprachen = [ " Python " , " Java " , " C " , " Haskell " ]
for i in sprachen :
print ( " % s ist eine Programmiersprache " % i )

# jeden Buchstaben eines Strings ausgeben


meinString = " Hallo Welt "
for i in meinString :
print ( i )

Dies erzeugt die Ausgabe:
0
1
2
3
4

Python ist eine Programmiersprache


Java ist eine Programmiersprache
C ist eine Programmiersprache
Haskell ist eine Programmiersprache

H
a
l
l
o

W
e
l
t


7.2.5 Funktionen
Funktionen werden in Python mittels def definiert. Als Beispiel wollen wir an dieser
Stelle zwei Algorithmen aus der Vorlesung „Programmierung 1“ [9] verwenden, in die-
sem Fall die Berechnung des größten gemeinsamen Teilers.

54
7.2 Grundlagen der Python Programmierung

# !/ usr / bin / python


import timeit
# Importiere die Python Bibliothek timeit zur Laufzeitmessung von
Funktionen

def ggTintuitiv (m , n ) :
# Definiere die erste Funktion ggTintuitiv , welche die Teiler einzeln
probiert
m = abs ( m )
n = abs ( n )
teiler = 1;
groessterTeiler = 1
while (( teiler <= m ) and ( teiler <= n ) ) :
if ( ( m % teiler == 0 ) and ( n % teiler == 0) ) :
groessterTeiler = teiler
teiler += 1
return groessterTeiler

def ggTeuklid (m , n ) :
# Definiere die zweite Funktion ggTeuklid , welche den Algorithmus nach
Euklid verwendet
m = abs ( m )
n = abs ( n )
r = m % n
while ( r > 0) :
m = n
n = r
r = m % n
return n

t_intuitiv = timeit . Timer ( " ggTintuitiv (12345678 , 23456789) " , " from
__main__ import ggTintuitiv " )
# Erstelle ein neues Objekt von der Klasse Timer .
# Der erste Parameter ist die zur Messung auszuführende Funktion ,
# der zweite Parameter die einmalig auszuführende Setup Anweisung , bei
der wir die zu messende
# Funktion nocheinmal in den Kontext einbinden
zeit_intuitiv = t_intuitiv . timeit (1)
# Führe die Messung einmal durch und schreibe die vergangene Zeit in
die Variable

t_euklid = timeit . Timer ( " ggTeuklid (12345678 , 23456789) " , " from __main__
import ggTeuklid " )
zeit_euklid = t_euklid . timeit (1)

print ( " Inuitiv : " + str ( ' {:.2 f } '. format ( zeit_intuitiv ) ) + "
Sekunden " )
print ( " Euklid : " + str ( ' {:.10 f } '. format ( zeit_euklid ) ) + " Sekunden
")
# Gebe jeweils die abgelaufene Zeit für beide Berechnungen aus
# '{:.2 f } '. format ( Variable ) beschränkt die Anzahl der Nachkommastellen
print ( " Euklid ist : " + str ( ' {:.2 f } '. format ( zeit_intuitiv / zeit_euklid
) ) + " x schneller " )

55
7 Python Programmierung

# Berechne wie vielfach Euklid schneller ist , wandle den Float in einen
String um und gebe den Wert aus

Im direkten Vergleich zu den Folien (Seite 16/18) von Herrn Folz kann man erken-
nen, dass die nötigen Anpassungen in den Algorithmen minimal waren. Die Beispie-
lausgabe zeigt dass die Berechnung die geringen Ressourcen des Raspberry Pi stark
beanspruchen und wie massiv der Unterschied zwischen beiden Implementationen in
der Laufzeit aussieht:
Inuitiv : 28.54 Sekunden
Euklid : 0.0000569820 Sekunden
Euklid ist : 500789.60 x schneller

Besonders interessant wird es, wenn man diese Werte jeweils der entsprechenden
Implementation in Java und C++ auf einem Intel Core i7-620M mit 2,66 GHz (JDK 1.6
und GNU C++) gegenüberstellt:

Tabelle 7.8: Laufzeiten beider Algorithmen in Sekunden

RPi Python i7 Java i7 C++

ggTintuitiv 28,54 0,163 0,043


ggTeuklid 0.0000569820 0,00000011 0,00000016

Wie man erkennen kann bleibt die effiziente Implementierung nach Euklid auch auf
dem Raspberry Pi mit seinen geringen Ressourcen gut verwendbar, während die intui-
tive Version spürbare Verzögerungen erzeugt. Es zeigt sich, dass im Bereich der Embed-
ded Systeme auch heute noch eine ressourcensparende Programmierung notwendig ist
und unabhängig von der verwendeten Programmiersprache zum guten Stil gehören
sollte.

7.2.6 Bibliotheken
Im vorangegangen Abschnitt haben wir bereits mit timeit eine Bibliothek verwendet,
ohne auf die Verwendung dieser genauer einzugehen. Bibliotheken können, wie auch
in anderen Sprachen dazu genutzt werden, den Funktionsumfang zu erweitern. In
Python werden Bibliotheken normal durch die Verwendung von import, gefolgt vom
Bibliotheksname eingebunden. Beispielsweise import time, womit die gesamte Biblio-
thek time eingebunden wird. Möchte man nur einzelne Module aus der Bibliothek ein-
binden, so kann man dies mit dem Schema from time import sleep tun. Damit wird
nur das Modul sleep aus der Bibliothek time eingebunden. Um einer doppelten Nutzung
des gleichen Namespaces vorzubeugen, kann man Module und Bibliotheken auch beim
Import mittels as umbenennen: So kann nach dem Import mit import time as zeit das
Modul sleep unter Verwendung von zeit.sleep() aufgerufen werden.

56
7.3 Verwendung der GPIO mittels Python

7.3 Verwendung der GPIO mittels Python


Nachdem wir bereits die GPIO in Bash mittels der abstrahierenden gpio.sh verwen-
det haben, werden wir diesmal die Pins mittels der wiringpi2-python Bibliothek di-
rekt ansprechen. Die wichtigsten Funktionen sind in der WiringPi API Dokumentation
(https://projects.drogon.net/raspberry-pi/wiringpi/functions/) bzw. WiringPi
Referenz (http://wiringpi.com/reference/) nachlesbar.

7.3.1 Digitale Ausgabe: LEDs


Beginnen wir mit der digitalen Ausgabe unter Verwendung des Erweiterungsboards.
Zur Hilfestellung sei an dieser Stelle die entsprechenden LEDs und ihre GPIO Num-
mern vermerkt:

Tabelle 7.9: LEDs auf dem Erweiterungsboard

Bauteil Bemerkung GPIO

LED North grün, PWM 18


LED East rot 23
LED West gelb 25
LED South blau 24

# !/ usr / bin / python


import wiringpi2 as wpi
# Importiere die Python Bibliothek wiringpi2 unter
# dem Namen wpi zur Nutzung der GPIO
from time import sleep
# Importiere das Modul sleep aus der
# Python Bibliothek time
wpi . wiringPiSetupGpio ()
# Initialisiert die Bibliothek unter Nutzung des
# BCM GPIO Namenschema
wpi . pinMode (18 ,1)
# Definiert den Port der gruenen LED als Ausgabe
wpi . digitalWrite (18 ,1)
# Setzt den Port der gruenen LED auf HIGH
sleep (0.5)
# Wartet eine halbe Sekunde
wpi . digitalWrite (18 ,0)
# Setzt den Port der gruenen LED auf LOW

Dieses Listing entspricht dem Hello World des Physical Computing: Es schaltet die
grüne LED an, aus und beendet das Programm.

57
7 Python Programmierung

7.3.2 Übungsaufgabe zur digitalen Ausgabe


Um das Verständnis für die grundlegende Nutzung von Python und der GPIO zu Ver-
tiefen empfiehlt sich folgende Übungsaufgabe: Man erstelle einen Programmcode um
alle LEDs, beginnend mit der Grünen, im Uhrzeigersinn einzuschalten. Anschließend
sollen, wieder beginnend mit der Grünen, alle LEDs wieder ausgeschaltet werden.
Nachdem Durchlauf dieser Prozedur soll dieser Vorgang bis zur Eingabe von Strg
+ C wiederholt werden.
Die Lösung der Aufgabe findet sich im Anhang unter D.6.

7.3.3 Digitale Eingabe: Schalter


Nachdem wir nun die digitale Ausgabe beherrschen, wenden wir uns der digitalen
Eingabe zu. Wir beginnen mit der Auflistung der Schalter auf dem Erweiterungsboard:

Tabelle 7.10: Schalter auf dem Erweiterungsboard

Bauteil Bemerkung GPIO

Switch North Pull-Down 4


Switch East Pull-Down 17
Switch West Pull-Down 22
Switch South Pull-Down 27

# !/ usr / bin / python


import wiringpi2 as wpi
wpi . wiringPiSetupGpio ()

wpi . pinMode (4 ,0)


# Definiert den Port des North Switches als Eingabe

while True :
print ( " North Switch : % d " % ( wpi . digitalRead (4) ) )
# Wert des North Switches auslesen und ausgeben

In diesem Fall nutzen wir pinMode mit dem Pin des ersten Schalters und setzen
seinen Modus auf 0, was der Eingabe entspricht. Anschließend können wir in einer
endlos Schleife den Wert dieses Pins abfragen und auf der Python Konsole ausgeben.

7.3.4 Übungsaufgabe zur digitalen Eingabe


Als Übung zur digitalen Eingabe verwenden wir ein kleines Reaktionsspiel unter Nut-
zung der vier LEDs und einem Schalter. Wie bei der vorherigen Übung sollen bei die-
sem Programm alle LEDs zum Leuchten gebracht werden. Es gilt weiterhin die Rich-
tung im Uhrzeigersinn, allerdings soll diesmal die blaue LED den Anfang machen.

58
7.3 Verwendung der GPIO mittels Python

Weiterhin sollen die LEDs nicht dauerhaft an- oder ausgeschaltet werden, sondern in
jedem Zyklus einmal kurz aufblinken. Zwischen jeder LED soll eine Pause von einer
halben Sekunde liegen. Ziel des Spieles soll es sein, den äußerten Schaltern (South /
S) zu drücken, kurz bevor die grüne LED leuchtet. Sollte dies erfolgreich sein, so soll
die LED zweimal kurz aufblinken, die Pause zwischen dem aufleuchten der einzelnen
LEDs um den Wert 0.05 reduziert, die aktuelle Rundenanzahl ausgegeben werden und
das Spiel wieder bei der blauen LED starten. Sollte man zu früh oder zu spät drücken,
so soll die falsche LED aufleuchten und eine entsprechende Nachricht auf dem Bild-
schirm angezeigt werden und das Programm sich selbst beenden. Gleiches gilt, falls
man gar nicht den Schalter in der Runde betätigt.
Die Lösung der Aufgabe findet sich im Anhang unter D.7.

7.3.5 Abschlussprojekt GPIO: Binärzähler


Als Abschlussprojekt soll an dieser Stelle ein Vier-Bit-Binärzähler programmiert wer-
den. Dabei sollen zwei Schalter und alle vier LEDs verwendet werden. Der äußerte
Schalter (South / S) soll dabei bei jeder Betätigung im Python Programm eine Zählva-
riable um 1 erhöhen, während der darüber liegende Schalter (West / W) den Zähler
auf 0 zurücksetzen soll. Das Programm soll bis zu 15 zählen und danach wieder zu 0
umbrechen und von vorne zu zählen beginnen. Die LEDs sollen bei diesem Projekt die
Ausgabe der Zahl in binärer Notation ermöglichen. Dabei ist jede LED als eine Stelle
einer vierstelligen, binären Notation zu verstehen:

2⁰
2³ 2¹

Abbildung 7.1: Festlegung des binären Wertes jeder LED

Zusätzlich zu der Ausgabe der Zahl über die LEDs, soll das Programm weiterhin den
Wert über die Konsole in den Formen Dezimal, Binär und Hexadezimal ausgeben.
Die Lösung der Aufgabe findet sich im Anhang unter D.8.

59
7 Python Programmierung

7.4 Verwendung des I2C Bus mittels Python


Im nachfolgenden Beispiel wird schrittweise erörtert, wie der I2C Bus mit wiringpi2,
hier in Python verwendet wird. Als Beispiel dazu dient der verbaute LM75B Tempe-
ratursensor. Die nachfolgenden technischen Daten lassen sich im Datenblatt des Sen-
sors unter [14], respektive in der Datei RPi_HTW/Datenblaetter/LM75B.pdf auf dem
Raspberry Pi finden.

7.4.1 Adressierung
Wie bereits unter Abschnitt 5.3.3 erklärt, hat jeder Teilnehmer im I2C Bus eine eindeu-
tige, hexadezimal notierte Adresse. Da allerdings verschiedene Anwendungszwecke
mehrere Geräte einer Art erfordern könnten (zum Beispiel mehrere LM75B in einem
Bus, um die Temperatur an verschiedenen Punkten eines Raumes zu überwachen), ha-
ben viele Hersteller die Möglichkeit mitgegeben, die Adresse ihres I2C Gerätes durch
Adressanschlüsse zu verändern. Diese Adresspins können wir in dem Pinout des Da-
tenblattes unter 6.1, Figure 2 (Pin configuration for SO8) einsehen:

Abbildung 7.2: LM75B Pinout

Da hier mit A0, A1 und A2 gleich drei Pins zur Verfügung stehen, können also je
nach unterschiedlichen Verbindungen mit „HIGH“ (3,3V) und „LOW“ (Ground) bis zu
23 , also acht unterschiedliche Adressen erzeugt werden. Dies bedeutet, dass bis zu acht
Geräte im gleichen Bus ohne Adresskonflikt angeschlossen werden können. Wie sich
diese Konfiguration der Pins auf die Adresse auswirkt, ist unter 7.3, Table 4 ersichtlich:

Abbildung 7.3: LM75B Adresstabelle

Die ersten vier Bit sind immer die Folge „1001“. Anschließend wird die Wertigkeit
der Bits (Eins oder Null) dadurch bestimmt, ob die Adresspins entweder „HIGH“ (1)

60
7.4 Verwendung des I2C Bus mittels Python

oder „LOW“ (0) sind. In dem Fall des vorliegenden Erweiterungsboards wurden alle
Adresspins mit Ground verbunden, entsprechen also Null. Dadurch entsteht die fertige
Geräteadresse von 1001000 oder 0x48. Das fehlende, letzte Bit wird im I2C Bus verwen-
det um festzulegen, ob es sich um lesende oder schreibende Anfrage im Bus handelt.
Dies wird allerdings durch die verwendete Bibliothek durchgeführt.
In unserem Beispiel öffnen wir die entsprechende I2C Verbindung wie folgt:
lm75b_file = wpi . wiringPiI2CSetup (0 x48 )
# Verbindung zu LM75B oeffnen
if lm75b_file < 0:
print ( " Kann den I2C Bus nicht oeffnen ! " )
else :


7.4.2 Register des Sensors


In I2C System wird sowohl die Konfiguration, als auch der Datenaustausch über 8 oder
16 Bit tiefe Register erledigt. Der LM75B hat, wie unter 7.4, Table 5 zu sehen ist vier
davon:

Abbildung 7.4: LM75B Register

Das 16 Bit tiefe Temperaturregister (0x00), das 8 Bit tiefe Konfigurationsregister (0x01)
sowie zwei 16 Bit tiefe Register für Temperaturschwellwerte bei denen der Sensor un-
terschiedliche Aktionen unternehmen kann: Hysteresis (0x02) und Overtemperature
shutdown (0x03). Damit ist klar, dass wir für die Auswertung der Temperatur das Re-
gister 0x00 mit 16 Bit auslesen müssen.
lm75_temp = wpi . wiringPiI2CReadReg16 ( lm75b_file , 0)
# Register 0 von LM75B in 16 Bit Tiefe auslesen


61
7 Python Programmierung

7.4.3 Interpretation des Temperaturwertes


Wie der ausgelesene Wert zu interpretieren ist, findet sich im Bereich 7.4.3, Table 9:

Abbildung 7.5: LM75B Temperatur Register

Die dort gekennzeichneten Bits D10-D0 enthalten den nötigen, 11 Bit langen Tem-
peraturwert. Die restlichen Bits des LSByte (Stellen 4-0) sind durch das „X“ als „Don’t
Care“ gekennzeichnet und sollten ignoriert werden. Am einfachsten erhält man den
Temperaturwert, in dem man den ausgelesenen Wert wie im Datenblatt beschrieben in
den MSB und den LSB Bereich aufteilt. Der LSB Bereich muss anschließend um fünf
Stellen nach rechts geshiftet werden und mit einer sieben verundet werden, um die
übrigen Stellen in dem Byte gleich Null zu setzen. Anschließend muss das HSB um
drei Stellen nach links geshiftet und mit dem vorbereiten LSB Bereich logisch durch ein
Order verbunden werden. Damit werden die beiden Bestandteile sauber zusammen-
gesetzt. Zum Schluss muss nur noch der erhaltene Wert mit 0.125 multipliziert, oder
durch acht geteilt werden, um die Temperatur in Grad Celsius zu erhalten.
lm75b_hi = ( lm75_temp & 0 xFF )
lm75b_lo = ( lm75_temp >> 8)
# In 2x 8 Bit Werte ( High und Low Bit ) umwandeln
n = lm75b_hi << 3 | (( lm75b_lo >> 5) & 0 x07 )
# gemaess Datasheet des Sensors aus den ausgelesenen
# 2 Bytes die korreten 11 Bits fuer den Temperaturwert
# extrahieren und shiften
lm75b_temp = n / 8.0
# 11 Bit Wert in Temperatur umwandeln

Das gesamte Listing ist im Anhang D.9 einsehbar.

7.4.4 Übungsaufgabe zur Verwendung des I2C Bus


Um die gelernten Fähigkeiten zu festigen, soll in dieser Übung eine Temperatursteue-
rung unter Verwendung des LM75B entwickelt werden. Der Sensor soll zum Start die
Umgebungstemperatur messen und diese als Standardtemperatur verwenden. Sollte
die Temperatur ein Grad unter diese Temperatur fallen, soll mit der blauen LED ange-
zeigt werden, dass der Raum abgekühlt ist. Sollte die Temperatur hingegen ein Grad
über diese Temperatur steigen, soll dies mit der roten LED repräsentiert werden. Die
Idealtemperatur soll mit der grünen LED dargestellt werden. Zusätzlich zu den Über-
gängen dieser Zustände, soll - sofern der Zustand stabil ist - der Name des Zustandes
und die aktuelle Temperatur ausgegeben werden.
Die Lösung der Aufgabe findet sich im Anhang unter D.10.

62
7.5 Verwendung des SPI Bus mittels Python

7.5 Verwendung des SPI Bus mittels Python


Nachdem nun die Kommunikation über den I2C Bus erfolgreich funktioniert, wenden
wir uns dem letzten Bauteil auf dem Erweiterungsboard zu, dem MCP3002 2 Kanal 10
Bit Analog/Digital Wandler mit SPI Bus. Damit erweitern wir den RPi um zwei ana-
loge Eingänge. In unserem Beispiel wird der erste Kanal, Kanal 0 dazu genutzt den
Wert eines angeschlossenen Lichtsensors / LDR auszulesen. Da es sich um einen 10
Bit Wandler handelt, kann dieser die angelegte analoge Spannung von 0 bis 3,3 V in
einem digitalen Wertebereich von 0 bis 1024 (210 ) darstellen. Das bedeutet, dass jede
analoge Spannungssteigerung von 3,3 mV sich in einer Erhöhung des digitalen Wertes
um 1 auswirkt. Die folgenden technischen Daten lassen sich im Datenblatt des Wand-
lers unter [17], respektive in der Datei RPi_HTW/Datenblaetter/MCP3002.pdf auf dem
Raspberry Pi finden.

7.5.1 Adressierung
Wie bereits in Abschnitt 5.3.5 beschrieben haben die SPI Bus Teilnehmer keine eige-
ne Adresse, sondern werden über eine eigene Leitung zum Master (Slave Select) in
den Kommunikationsmodus geschaltet. In dem Fall des Erweiterungsboards wurde
der MCP3002 auf den Slave Select 0 gelegt, den ersten der beiden Slave Selects. Diese
sind in keinem Fall mit den internen beiden ADC Kanälen des MCP3002 zu verwech-
seln, welche nicht zur Kommunikation dienen, sondern zur Messung von analogen
Spannungen - der eigentlichen Aufgabe des MCP3002. Da wir weiterhin die Übertra-
gungsgeschwindigkeit beim Öffnen des SPI Bus angeben müssen, suchen wir im Da-
tenblatt nach den entsprechenden Angaben. Auf Seite drei findet man unter Timing
Parameters, Clock Frequency die entsprechenden Angaben:

Abbildung 7.6: MCP3002 SPI Bus Geschwindigkeit

Da der MCP3002 auf dem Erweiterungsboard mit 3,3 V Spannung versorgt wird,
liegt die maximale Geschwindigkeit für den SPI Bus bei 1,2 MHz. Da der Controller
des RPi allerdings ganze vielfache bevorzugt, werden wir eine Geschwindigkeit von 1
MHz verwenden - sowie den Slave Select 0.
# !/ usr / bin / python
import wiringpi2 as wpi
from binascii import hexlify
from binascii import unhexlify

mcp3002_channel =0

if wpi . wiringPiSPISetup (0 ,1000000) < 0:


print ( " Kann den SPI Bus nicht oeffnen ! " )

63
7 Python Programmierung

else :


7.5.2 Kommunikation
Die Kommunikation beim SPI Bus verläuft bidirektional, in dem eine gewisse Anzahl
an Bytes in Form eines Bytebuffers über den Bus versendet, und gleichzeitig wieder
von der Gegenstelle mit Daten gefüllt wird. Das heißt, dass nach erfolgter Kommu-
nikation der Sendebuffer mit den Zieldaten überschrieben wurde. Der Ablauf dieser
Kommunikation kann im Datenblatt der Abbildung 6-2 entnommen werden:

Abbildung 7.7: MCP3002 SPI Kommunikation

DIN beziehungsweise „MCU Transmitted Data“ beschreibt dabei die Kommunika-


tion vom RPi zum MCP3002, DOUT beziehungsweise „MCU Received Data“ die um-
gekehrte Richtung. Wie wir sehen beginnt die Kommunikation im ersten Byte bei DIN
mit einem „Don’t Care“, gefolgt von einem feststehenden Startbit. Anschließend fol-
gen drei Bits welche bestimmte Optionen festlegen: „SGL/DIFF“, „ODD/SIGN“ und
„MSBF“. Beendet wird das Byte mit weiteren drei „Don’t Care“ Bits. Das zweite Byte
besteht völlig aus „Don’t Care“ Bestandteilen, die wir beliebig mit Eins und Null füllen
könnten. Für die bessere Lesbarkeit werden wir allerdings alle „Don’t Care“ Bits mit
Null füllen. Unser bisheriger Kommunikationsbuffer sieht also so aus:

Tabelle 7.11: Vorläufiger Kommunikationsbuffer

Bit 0 1 2 3 4 5 6 7 | 8 9 10 11 12 13 14 15

Mode 0 1 ? ? ? 0 0 0 | 0 0 0 0 0 0 0 0

Die Bedeutung und korrekten Einstellungen für die noch fehlenden Werte von „SGL/-
DIFF“ und „ODD/SIGN“ kann man in der Tabelle 5-1 nachlesen:

64
7.5 Verwendung des SPI Bus mittels Python

Abbildung 7.8: MCP3002 Konfigurationsbits

Es handelt sich dabei um Konfigurationsbit mit welchem man die Funktionsart des
MCP3002 einstellen kann. „SGL/DIFF“ bestimmt ob der Analog/Digital Wandler ent-
weder die Spannung an einem seiner beiden Kanäle lesen (Einstellung 1) oder ob er
den Unterschied zwischen beiden Kanälen feststellen soll (Einstellung 0). Da wir die
Spannung am Kanal 0, an dem auch der LDR angeschlossen ist messen wollen, müssen
wir das „SGL/DIFF“ Bit auf 1 setzen. In diesem Modus wird das „ODD/SIGN“ Bit da-
zu genutzt, den Kanal auszuwählen. Ist das Bit auf 0 gesetzt, wird Kanal 0 gemessen,
wird es auf 1 gesetzt, wird der Kanal 1 gemessen. Somit sind unsere Einstellungen für
„SGL/DIFF“ 1 und für „ODD/SIGN“ 0. Das letzte Bit, „MSBF", sorgt dafür, dass die
Kommunikation im MSB Format abläuft, wenn es gesetzt ist. Ansonsten arbeitet der
Wandler mit LSB. Wir lassen diese Einstellung auf 0.
Damit steht unser Buffer für die Kommunikation fest:

Tabelle 7.12: Kommunikationsbuffer

Bit 0 1 2 3 4 5 6 7 | 8 9 10 11 12 13 14 15

Mode 0 1 1 0 0 0 0 0 | 0 0 0 0 0 0 0 0

Wir müssen diese Werte nur entsprechend in Python in das entsprechende Format
bringen und auf Slave Select 0 übertragen:
buffer =((6+ mcp3002_channel ) < <12)
buffer = ' {0: x } '. format ( int ( buffer ) )
# Wandle den dezimalen Integer in einen
# hexadezimalen String um , ohne das Praefix
# 0 x davorzustellen
buffer = unhexlify ( buffer )
# Wandle den Hex String in einen Byte String um

if ( wpi . wiringPiSPIDataRW (0 , buffer ) == -1) :


# Anforderung auf den SPI Bus auf Slave
# Select 0 schreiben und

65
7 Python Programmierung

# gleichzeitig ( bi - direktional ) mit der


# Antwort den Buffer ueberschreiben
print ( " Schreibfehler auf SPI Bus !\ n " )
else :

Nachdem die Kommunikation beendet ist, befindet sich im Buffer bereits die Ant-
wort in Form eines Byte Strings, welche dann nur noch in einen Integer Wert umge-
wandelt werden muss:
buffer = hexlify ( buffer )
# Wandle den Byte String nach Hex um
buffer = int ( buffer , 16)
# Wandle den Hex String in einen
# dezimalen Integer Wert um

Dieser Wert kann nun noch formatiert und ausgegeben werden. Das gesamte Lis-
ting ist im Anhang D.11 einsehbar. Zusätzliches zu der hier beschriebenen, manuellen
Kommunikation bietet wiringpi2 bereits eine Bibliothek, welche die Kommunikation
mit dem MCP3002 vereinfacht. Das entsprechende Listing befindet sich im Anhang
D.12

7.5.3 Übungsaufgabe zur Verwendung des SPI Bus


Nachdem nun die Nutzung des SPI Bus erlernt wurde, soll in der nachfolgenden Übungs-
aufgabe der Einsatz des LDR als Näherungssensor realisiert werden:
Um die Messwerte leichter zu visualisieren, soll dazu die Bibliothek curses verwen-
det werden. Mit dieser Bibliothek kann in der Konsole ein virtuelles Fenster erzeugt
werden, in dessen Koordinatensystem man zum Beispiel eine horizontale Linie zeich-
nen kann. Wichtig ist dabei zu erwähnen, dass diese Bibliothek nicht in IDLE läuft und
daher der Aufruf direkt aus LXTerminal wie in Abschnitt 7.2.1 als 2) und 3) beschrieben
erfolgen muss. Wegen dem Aufruf von curses wird das Programm in diesem Fall durch
das Drücken einer beliebigen Taste beendet und sollte nicht per Strg + C abgebrochen
werden.
# !/ usr / bin / python
import curses
from time import sleep

screen = curses . initscr ()


# curses in der Konsole initialisieren
dims = screen . getmaxyx ()
# y , x Groesse des Bildschirms in Array ablegen
# dims [0] entspricht y Wert
# dims [1] entspricht x Wert
screen . nodelay (1)
# nodelay Modus aktivieren um screen . getch ()
# im non - Blocking Modus zu betreiben

while ( screen . getch () == -1) :


# fuehre die Schleife aus solange keine

66
7.5 Verwendung des SPI Bus mittels Python

# Taste gedrueckt wurde


screen . erase ()
# Bildschirm loeschen
screen . hline (20 , 0 , ' - ' , 40)
# horinzontale Linie aus - Zeichen malen
# hline (y Koordinate , x Beginn , ch Zeichen , n Laenge )
screen . refresh ()
# Bildschirm neu laden
sleep (0.1)
curses . endwin ()
# Beenden

Die Aufgabe wird nun sein, dieses Skript dahingehend zu ergänzen, dass die hori-
zontale Linie jeweils den aktuellen Messwert des an den MCP3002 angeschlossenen
LDR anzeigt. Wichtig wird dabei sein, jeweils zum Start des Skriptes den aktuellen
Messwert als Maximalwert zu erfassen, sowie den Wert jeweils korrekt zu skalieren,
damit der Lichtsensor als Eingabegerät für z.B. ein Spiel verwendbar werden könnte.
Die Lösung befindet sich im Anhang D.13.

67
8 Mathematica
In dem letzten Kapitel dieser Arbeit soll die Einführung in die Nutzung der Software
Mathematica und deren Verwendung mit den GPIO Pins im Vordergrund stehen. Dabei
soll gegen Ende des Kapitels sowohl die grundlegende Nutzung der Software selbst,
wie auch die Verwendung in Kombination mit dem Erweiterungsboard verständlich
geworden sein. Diese Software könnte besonders in den Vorlesungen „Mathematik 1-
3“, sowie „Informatikgrundlagen“ und „Graphentheorie“ Verwendung finden.

8.1 Grundlagen
Die Software Wolfram Mathematica ist ein mathematisch-naturwissenschaftliches Pro-
gramm zur Lösung unterschiedlichster Probleme. Dies beinhaltet die Lösung von Glei-
chungen, Zeichnung von Plots, Darstellung und Visualisierung von Problemen sowie
Datenanalyse. Damit kann Mathematica im Bereich der Mathematik, Computerwissen-
schaften, Physik, Biologie, Medizin, Ingenieurswesen, Finanz- und Sozialwissenschaf-
ten eingesetzt werden. Die Besonderheiten dieser Software umfassen neben zahlreichen
Sonderfunktionen wie Cloud- und Grindcomputing, wissensbasiertem Programmie-
ren, Integration neuer Technologien wie Internet of Things und webbasierten Sensoren
auch eine leistungsfähige API, sowie die Möglichkeit eigene Programme mittels des
MathLink Protokolls als Datenquelle und -senke in Wolfram zu integrieren.
Aufgrund des großen Funktionsumfangs und der Leistungsfähigkeit dieser Software
ist diese im Normalfall für Studenten nur eingeschränkt oder gar nicht zugänglich.
Durch die kostenlose Integration der aktuellen Version von Wolfram Mathematica in
Raspbian, dem Betriebssystem des Raspberry Pi, wird dieses Werkzeug also für einen
größeren Nutzerkreis verfügbar.
Weiterhin können durch die Nutzung des Raspberry Pi als Schnittstelle auch I2C, SPI
und GPIO Sensoren und Aktoren mittels MathLink Protokolls von anderen Raspberry
Pis oder vollwertigen Mathematica Arbeitsplätzen verwendet werden.

8.2 Benutzung
Mathematica ist auf dem RPi in zwei Varianten installiert: wolfram, die CLI basierte
Form von Mathematica, welche ausschließlich zur Verwendung im reinen Textmodus
und in Verbindung mit Skripten gedacht ist, sowie mathematica, welche alle Features
in der grafischen Benutzeroberfläche bietet - inklusive der Ausgabe von Grafiken und
Plots. Für unsere Einsatzzwecke werden wir mathematica einsetzen.

69
8 Mathematica

8.2.1 Beispiele Free-form input


Zu berechnende Ausdrücke werden in Mathematica einfach in das sogenannte Sketch-
book, dem Hauptfenster der Software eingegeben und durch Bestätigung mittels ⇑ +
Enter ausgewertet. Diese Form von Eingabe nennt sich „Free-form input“ und wird von
Mathematica offline auf dem RPi gelöst. So können Berechnungen wie 1+1, 3/4*(5-2)^2
oder ganze Gleichungen (Solve[x^3+x^2-8x-12==0,x]) und auch bestimmte Integrale
(Integrate[Sin[x],{x,0,Pi}]) einfach und direkt gelöst werden. Die möglichen Be-
fehle und Verwendungsmöglichkeiten können in der ausführlichen Sprachreferenz von
Wolfram unter http://reference.wolfram.com/language/ nachgelesen werden.

8.2.2 Beispiele Wolfram Alpha query


Wesentlich leistungsfähiger ist allerdings die Nutzung der „Wolfram Alpha query“,
welches die Eingaben online an die Wolfram Alpha Compute Engine weiterleitet. Wie
in Abbildung 8.1 gezeigt, erfolgt die Umstellung dieser Eingabe per Klick auf das „+“
Zeichen im Sketchbook.

Abbildung 8.1: Umstellung der Eingabeart in Wolfram

Wichtig ist, dass die Nutzung dieses Softwareteils nur bei aktiver Internetanbindung
möglich ist. Die Stärke von Wolfram Alpha liegt in der Auswertung natürlicher Spra-
che in mathematische Zahlen. Kombiniert mit der Menge der in der Compute Engine

70
8.2 Benutzung

hinterlegten Daten, sind dadurch interessante Auswertungen mit sehr geringem Auf-
wand möglich. So zum Beispiel die wissenschaftlich nicht relevante Berechnung der
Anzahl aller Einwohner von Frankreich mal der Höhe des Eiffelturms:

Abbildung 8.2: Berechnung mittels Wolfram Alpha

Weitere Beispiele und mögliche Einsatzzwecke sind in der Dokumentation von Wolf-
ram Alpha unter http://www.wolframalpha.com/examples/ zu finden.

71
8 Mathematica

8.3 Verwendung mittels Erweiterungsboard


Wie bereits erwähnt können die Sensoren und Aktoren des Erweiterungsboards auch
mittels Mathematica genutzt werden, um z.B. Temperatur- oder Helligkeitsdaten zu
sammeln und grafisch auszuwerten. Es wäre auch möglich die Schalter des Boards zur
Zählung von z.B. Besuchern einer Veranstaltung oder der Auslastung einer Straße ein-
zusetzen, wie es häufig für statistische Erfassungen getan wird. Damit diese Peripherie
in Mathematica verfügbar wird, muss zuerst die entsprechende Library eingebunden
werden. Da es für Mathematica noch keine Erweiterung zur Nutzung der I2C und SPI
Bus Systeme gibt, wurde im Rahmen dieser Arbeit unter Nutzung von C, wiringpi2 und
dem MathLink Protokoll eine eigene geschrieben. Der Quellcode für diese wpi genannte
Library kann auf dem Raspberry Pi im Unterverzeichnis RPi_HTW/Mathematica/ des
Hauptnutzers pi, beziehungsweise im Anhang unter D.14 und D.15 gefunden werden.
Erzeugt wird das fertige Programm unter Aufruf von mcc wpi.c wpi.tm -o wpi -luuid
-lwiringPi.
Wichtig zu erwähnen ist, dass - unabhängig ob nun Mathematica oder Wolfram ge-
nutzt werden soll - beide Programme mit root Rechten über die CLI gestartet werden
müssen. Sonst kann der Zugriff auf die GPIO nicht erfolgen. Wir starten also Mathe-
matica durch den Befehl sudo mathematica im LXTerminal. Nachdem die Software gela-
den ist, können wir durch den Befehl SetDirectory["/home/pi/RPi_HTW/Mathematica"]
das Heimverzeichnis von Mathematica temporär ändern und mit dem weiteren Befehl
link = Install["wpi"] die Library wpi laden.
Solange die Sitzung von Mathematica beziehungsweise Wolfram aktiv ist, sind ab
nun folgende weitere Befehle verfügbar:

setPinMode[pin, mode]
setDigitalWrite[pin, value]
setPwmWrite[pin, value]
getDigitalRead[pin]
getLM75B[]
getMCP3002[channel]

Zu jedem Befehl kann die entsprechende Hilfe durch das Vorstellen eines Fragezei-
chens (z.B. ?getLM75B) und die anschließende Auswertung per ⇑ + Enter ausgegeben
werden. Die ersten vier angegebenen Befehle sind die bekannten Kommandos der wi-
ringpi2 Bibliothek, die anderen beiden basieren auf dem bereits in Abschnitt 7.4 und
Abschnitt 7.5 entwickelten Python Code zur Nutzung des LM75B Temperatur Sensors
und des MCP3002 ADC.
Dementsprechend einfach ist die Verwendung der GPIOs in Mathematica, um zum
Beispiel die grüne LED zu aktiveren:
setPinMode[18, 1]
(* Definiert den Port der gruenen LED als Ausgabe *)
setDigitalWrite[18, 1]
(* Setzt den Port der gruenen LED auf HIGH *)

72
8.3 Verwendung mittels Erweiterungsboard

Auch die Überprüfung des ersten Schalters und die entsprechende Ausgabe des Zu-
standes auf die erste LED ist sehr einfach:
setPinMode[18, 1]
(* Definiert den Port der gruenen LED als Ausgabe *)
setPinMode[4, 0]
(* Definiert den Port des North Switches als Eingabe *)
If[getDigitalRead[4]==1, setDigitalWrite[18,1], setDigitalWrite[18,0]]
(* Sollte der North Switch zur Zeit der Auswertung gedrueckt wurden sein,
schalte die gruene LED ein, sonst aus *)
Als nächstes sollen die Möglichkeiten von Mathematica in der grafischen Auswer-
tung aufgezeigt werden, hier in Verbindung mit dem Temperatur Sensor:
t={}
(* Definiert die leere Liste t, fuer die Temperaturwerte *)
RunScheduledTask[(AppendTo[t,getLM75B[]]),1];
(* Definiert einen Task der jede Sekunde ablaeuft und den
aktuellen Wert des Temperatur Sensors in die Liste schreibt *)
Dynamic[ListLinePlot[t,Joined->True,PlotRange->Automatic]]
(* Erzeugt einen dynamischen Plot in Form einer Linie welcher sich
mit jedem neuen Wert der Liste neu zeichnet und sich selbst
skaliert *)
Der entstehende Plot wird mit der Erweiterung der Liste dynamisch aktualisiert bis
entweder eine gegebene, zeitliche Grenze erreicht wurde oder z.B. unter „Evaluation“
die Option „Dynamic Updating Enabled“ abgeschaltet wurde.

Abbildung 8.3: Plot des Temperatur Sensors über 400 Sekunden

Als letzten Punkt wollen wir die Messwerte des Lichtsensors in Form eines analogen
Messwerkes darstellen. Dazu verwenden wir wieder die Methode RunScheduledTask

73
8 Mathematica

um die Messwerte zu erfassen. Das Auswertung wird diesmal jedoch nicht über einen
ListLinePlot, sondern über AngularGauge erfolgen:

RunScheduledTask[val = getMCP3002[0], 1]
(* Definiert einen Task der jede Sekunde ablaeuft und den
aktuellen Wert des Lichtsensors in eine Variable schreibt *)
AngularGauge[Dynamic[val], {0, 1023}]
(* Erzeugt einen dynamischen Plot in Form eines analogen
Messwerkes welches sich mit jedem neuen Wert in der
Variable neu aktualisiert. Der Wertebereich wird mit 0
- 1023 vorgegeben *)

Abbildung 8.4: Darstellung des Lichtsensor Wertes als analoges Messwerk

Die Verbindung zur Library kann jederzeit durch den Befehl Uninstall[link] been-
det werden, sollte z.B. ein Fehler auftreten. Weiterhin können alle Zellen und Auswer-
tungen einzeln markiert, gelöscht oder angehalten werden. Es empfiehlt sich möglichst
wenige dynamische Objekte gleichzeitig zu erstellen, um den RPi nicht völlig auszu-
lasten.

74
9 Fazit
9.1 Zusammenfassung
Im Rahmen dieser Bachelor Thesis wurde der Raspberry Pi dazu genutzt unterschiedli-
che Themen des Studienganges „Praktische Informatik“ aufzugreifen und deren Lehre
anhand von praktischen Beispielen und konkreten Projekten zu unterstützen. Dies um-
fasst folgende Punkte:

Tabelle 9.1: Stakeholder dieser Thesis

Veranstaltung / Labor Aufgabe

Mikroprozessortechnik Evaluation von Beagle Bone Black und Raspberry Pi


Elektrotechnik Labor Erstellung eines Grundlagen Handbuches zum RPi
Systemtechnik Labor Erstellung Standard Image zur Verwendung im STL
Betriebssystem Einführung Praktisches Bash Projekt zur Vorbereitung der Klausur
Systemmanagement & Sicherheit Einführung in die Sprache Python
Programmierung 1 Darstellung Nachteile ineffizienter Programmierung
Digitaltechnik 1 Binäre Logik / Binärer Zähler
Rechnerarchitektur Grundlagen I2C / SPI Bussysteme & Verwendung
Theoretische Informatik Primitiver Automat mit I2C / SPI Sensoren
Mathematik 1-3 Vorstellung von Wolfram Alpha / Mathematica

Darüber hinaus wurden zum Erreichen dieser Ziele, als Bestandteil dieser Thesis, das
in diesem Dokument besprochene Erweiterungsboard entwickelt und in zehnfacher
Stückzahl hergestellt, um anschließend mit den gleichzeitig vorbereiten Raspberry Pis
aktiv in der Lehre der HTW Saar eingesetzt zu werden.
Zum Abschluss lässt sich sagen, dass die gesteckten Ziele dieser Arbeit im Rahmen
der Möglichkeiten erreicht werden konnten und sich der Raspberry Pi trotz seines ge-
ringen Preises als gute Plattform für den Bereich der Forschung und Lehre erwiesen
hat.

75
9 Fazit

9.2 Ausblick
Aufgrund der gegebenen, zeitlichen Begrenzung dieser Thesis, war es leider nicht mehr
möglich die Assembler Programmierung des verbauten ARMv6 SoC zu erläutern, oder
eine Einführung in die objektorientierte Programmierung unter Python zu geben, was
den gegebenen Rahmen gesprengt hätte. Neben diesen Projekten ließen sich auch wei-
tere Möglichkeiten finden den Raspberry Pi in Zukunft aktiv in die Lehre einfließen zu
lassen:

Tabelle 9.2: Ausblick auf mögliche Projekte

Veranstaltung / Labor Aufgabe

Mikroprozessortechnik Assembler Programmierung und Betriebssysteme [3]


Betriebssysteme Verwendung RPi mit RTOS ChibiOS [1]
Parallele Programmierung Nutzung RPi GPU zur parallelen Berechnung [22]
Verteilte Systeme 1 Einführung in MPICH [5]
Netzwerktechnik Praktische Konfiguration von IPv4/IPv6 Servern

Weitere mögliche Anwendung wäre der Einsatz in der Vorlesung „Einführung in die
Robotik“, als Plattform für ein „Gamification“ Projekt, bei interdisziplinäre Arbeiten im
Bereich der Elektrotechnik bzw. Medizin- und Biotechnologie oder als Ausstellungsob-
jekt für den Tag der offenen Tür.

76
Literatur
[1] Steve Bate. ChibiOS/RT on the Raspberry Pi. Okt. 2012. URL: http://www.stevebate.
net/chibios-rpi/GettingStarted.html.
[2] Charles C. Mann. Eben Upton, 34. 2012. URL : http://www2.technologyreview.
com/tr35/profile.aspx?TRID=1307.
[3] Alex Chadwick. Baking Pi - Operating Systems Development. Juli 2013. URL: http:
//www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/.
[4] Arthur C. Clarke. Profiles of the Future: An Inquiry Into the Limits of the Possible.
An Indigo paperback. Indigo, 2000. ISBN: 9780575402775. URL: http://books.
google.de/books?id=fVp0PwAACAAJ.
[5] Simon J. Cox. „Iridis-pi: a low-cost, compact demonstration cluster“. English. In:
Cluster Computing 17.2 (2014), S. 349–358. ISSN: 1386-7857. DOI: 10.1007/s10586-
013-0282-7. URL: http://dx.doi.org/10.1007/s10586-013-0282-7.
[6] Tony Dicola. Embedded Linux Board Comparison. Adafruit. Mai 2014. URL: https:
//learn.adafruit.com/embedded-linux-board-comparison/overview.
[7] EIA Engineering Dept. Interface between data terminal equipment and data communi-
cation equipment employing serial binary data interchange. EIA standard. Electronic
Industries Association, Engineering Dept., 1969. URL: http://books.google.de/
books?id=Tp08AAAAIAAJ.
[8] Elatllat. RPiconfig. Juni 2014. URL: http://elinux.org/RPiconfig.
[9] Prof. Dr. Helmut G. Folz. Programmierung 1: Kontrollstrukturen. HTW. Mai 2013.
URL : http://www.htwsaar.de/ingwi/fakultaet/personen/profile/helmut-
folz/prog1/folien2013/folien2013-00-08.zip/view.
[10] Geertivp. RPi Serial Connection. Feb. 2014. URL: http://elinux.org/RPi_Serial_
Connection.
[11] Matt Hawkins. Raspberry Pi B+ GPIO Header Details And Pinout. Juni 2014. URL:
http://www.raspberrypi-spy.co.uk/2014/07/raspberry-pi-b-gpio-header-
details-and-pinout/.
[12] Heinrich Hübscher, Carsten Rathmann, Klaus Richter, Hans J Petersen und Dirk
Scharf. IT-Handbuch IT-Systemelektroniker/-in Fachinformatiker/-in: 7. Auflage, 2011.
7. Auflage. Westermann Schulbuch, Jan. 2011. ISBN: 9783142250427. URL: http:
//amazon.de/o/ASIN/3142250425/.
[13] Gordon Henderson. Understanding SPI on the Raspberry Pi. Aug. 2012. URL: https:
//projects.drogon.net/understanding-spi-on-the-raspberry-pi/.

77
Literatur

[14] LM75B. 6. Aufl. NXP. Aug. 2014. URL: http://www.nxp.com/documents/data_


sheet/LM75B.pdf.
[15] F. Leens. „An introduction to I2C and SPI protocols“. In: Instrumentation Measure-
ment Magazine, IEEE 12.1 (Feb. 2009), S. 8–13. ISSN: 1094-6969. DOI: 10.1109/MIM.
2009.4762946.
[16] Gert van Loo. GPIO Pads Control2. Aug. 2012. URL: http://de.scribd.com/doc/
101830961/GPIO-Pads-Control2.
[17] MCP3002. E. Microchip. Nov. 2011. URL: http://ww1.microchip.com/downloads/
en/DeviceDoc/21294E.pdf.
[18] H.J. Morrison und R.H. Baer. „Microcomputer controlled game“. Pat. US4207087
A. US Patent 4,207,087. Juni 1980. URL: http : / / www . google . com / patents /
US4207087.
[19] NXP. I2C-bus specification. 6. Aufl. NXP Semiconductor. Apr. 2014. URL : http :
//www.nxp.com/documents/user_manual/UM10204.pdf.
[20] PBL. Raspberry Pi Schematics R2.1. Nov. 2013. URL: http : / / www . raspberrypi .
org/documentation/hardware/raspberrypi/schematics/Raspberry-Pi-Rev-
2.1-Model-AB-Schematics.pdf.
[21] Philips. I2S-bus specification. Philips Semiconductors. Feb. 1986. URL : https : / /
sparkfun.com/datasheets/BreakoutBoards/I2SBUS.pdf.
[22] Eben Upton. GPGPU Hacking on the Pi. Juni 2014. URL: http://www.raspberrypi.
org/gpgpu-hacking-on-the-pi/.
[23] Eben Upton. Introducing Turbo Mode: Up to 50% more Performance for free. Sep. 2012.
URL : http : / / www . raspberrypi . org / introducing - turbo - mode - up - to - 50 -
more-performance-for-free/.
[24] Liz Upton. Raspberry Pi at Buckingham Palace, 3 Million Sold. Juni 2014. URL: http:
//www.raspberrypi.org/raspberry-pi-at-buckingham-palace-3-million-
sold/.
[25] Roland Woitowitz. Digitaltechnik. 6. Aufl. Springer, Aug. 2011.

78
Abbildungsverzeichnis

3.1 SD Formatter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2 SD Formatter Optionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.3 Win32 Disk Imager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.4 noobs nach dem Entpacken auf die SD Karte . . . . . . . . . . . . . . . . 16
3.5 Installation von Raspbian unter noobs . . . . . . . . . . . . . . . . . . . . 17

4.1 raspi-config . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.2 Raspbian Desktop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

5.1 GPIO Schnittstelle Raspberry Pi Modell A / B / B+ [11] . . . . . . . . . . 31


5.2 Erweiterungsboard und Routing der Komponenten . . . . . . . . . . . . 39

6.1 Simon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
6.2 Flowchart Simon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

7.1 Festlegung des binären Wertes jeder LED . . . . . . . . . . . . . . . . . . 59


7.2 LM75B Pinout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
7.3 LM75B Adresstabelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
7.4 LM75B Register . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
7.5 LM75B Temperatur Register . . . . . . . . . . . . . . . . . . . . . . . . . . 62
7.6 MCP3002 SPI Bus Geschwindigkeit . . . . . . . . . . . . . . . . . . . . . . 63
7.7 MCP3002 SPI Kommunikation . . . . . . . . . . . . . . . . . . . . . . . . 64
7.8 MCP3002 Konfigurationsbits . . . . . . . . . . . . . . . . . . . . . . . . . 65

8.1 Umstellung der Eingabeart in Wolfram . . . . . . . . . . . . . . . . . . . 70


8.2 Berechnung mittels Wolfram Alpha . . . . . . . . . . . . . . . . . . . . . . 71
8.3 Plot des Temperatur Sensors über 400 Sekunden . . . . . . . . . . . . . . 73
8.4 Darstellung des Lichtsensor Wertes als analoges Messwerk . . . . . . . . 74

C.1 Erweiterungsboard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

79
TABELLENVERZEICHNIS

Tabellenverzeichnis

2.1 Übersicht [6] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6


2.2 I/O und Peripherie [6] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

4.1 Einstellungen für eduroam . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

5.1 Erweiterungsboard und Routing der Komponenten . . . . . . . . . . . . 39

7.1 Arithmetische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . 51


7.2 Vergleichsoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
7.3 Binäres Und . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
7.4 Binäres Oder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
7.5 Binäres XOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
7.6 Binäres 1er Komplement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
7.7 Binäre, bitweise Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . 53
7.8 Laufzeiten beider Algorithmen in Sekunden . . . . . . . . . . . . . . . . 56
7.9 LEDs auf dem Erweiterungsboard . . . . . . . . . . . . . . . . . . . . . . 57
7.10 Schalter auf dem Erweiterungsboard . . . . . . . . . . . . . . . . . . . . . 58
7.11 Vorläufiger Kommunikationsbuffer . . . . . . . . . . . . . . . . . . . . . . 64
7.12 Kommunikationsbuffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

9.1 Stakeholder dieser Thesis . . . . . . . . . . . . . . . . . . . . . . . . . . . 75


9.2 Ausblick auf mögliche Projekte . . . . . . . . . . . . . . . . . . . . . . . . 76

A.1 Raspbian Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85


A.2 Per apt-get installierte Pakete . . . . . . . . . . . . . . . . . . . . . . . . . 85
A.3 Manuell installierte Pakete . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

B.1 Raspberry Pi der HTW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

C.1 Erweiterungsboard und Routing der Komponeten . . . . . . . . . . . . . 90

80
Listings

Code/boardTest.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Code/gpio.sh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Code/demoLed.sh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Code/demoSwitch.sh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Code/simon.sh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Code/uebungAusgabe.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Code/uebungEingabe.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Code/binaryCounter.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
Code/lm75b.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
Code/uebungI2C.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
Code/mcp3002.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
Code/mcp3002lib.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Code/uebungSPI.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Code/wpi.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Code/wpi.tm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

81
Abkürzungsverzeichnis
ADC Analog Digital Converter

API Application Programming Interface

CAN Controller Area Network

CSI Camera Serial Interface

CLI Command Line Interface

DSI Display Serial Interface

GPIO General-purpose input/output

GPS Global Positioning System

I2C Inter-Integrated Circuit

I2S Inter-Integrated Sound

IDE Integrated Development Environment

LDR Light Dependent Resistor

MCU Microcontroller Unit

PRU Programmable Realtime Unit

PWM Pulse-width modulation

RPi Raspberry Pi

SoC System on a chip

SPI Serial Peripheral Interface

TWI Two Wire Interface

UART Universal asynchronous receiver/transmitter

82
Anhang

83
A Vorgefertigtes Raspbian Image

A.1 Übersicht

Tabelle A.1: Raspbian Übersicht

Raspbian

Version June 2014 (20.06.2014)


Kernel 3.12.28+ #712 PREEMPT Tue Sep 16
User / Passwort pi / rpi
root kein Passwort gesetzt / gesperrt
IP per DHCP

A.2 Zusätzlich installierte Pakete

Tabelle A.2: Per apt-get installierte Pakete

Name

python-setuptools python-dev cpufrequtils scrot epiphany-browser


uuid-dev gfortran screen minecraft-pi python-minecraftpi

Tabelle A.3: Manuell installierte Pakete

Name URL

wiringpi2 git://git.drogon.net/wiringPi
wiringpi2-python https://github.com/Gadgetoid/WiringPi2-Python
rpi-serial-console https://github.com/lurch/rpi-serial-console
MPICH 3.1.2 http://www.mpich.org/static/tarballs/3.1.2/mpich-3.1.2.tar.gz
MCPIPY Examples https://github.com/brooksc/mcpipy

85
B Raspberry Pi Hardware HTW

B.1 Übersicht

Tabelle B.1: Raspberry Pi der HTW

Nr Name Hersteller Speicher Modell MAC Netzteil SD Card SD Karte ok 1 GHz Boot?

1 rpi01 RS Samsung B Rev. 2.0 B8:27:EB:81:B9:6C RS Intenso Class 10 x -


2 rpi02 RS Samsung B Rev. 2.0 B8:27:EB:CB:3D:35 RS Intenso Class 10 x x
3 rpi03 RS Samsung B Rev. 2.0 B8:27:EB:61:B4:4C RS Intenso Class 10 x x
4 rpi04 RS Samsung B Rev. 2.0 B8:27:EB:51:29:89 RS Intenso Class 10 x x
5 rpi05 RS Samsung B Rev. 2.0 B8:27:EB:1E:D8:E7 RS Intenso Class 10 x x
6 rpi06 RS Samsung B Rev. 2.0 B8:27:EB:2D:26:DC RS Intenso Class 10 x x
7 rpi07 RS Samsung B Rev. 2.0 B8:27:EB:89:B0:4B RS Intenso Class 10 x x
8 rpi08 RS Samsung B Rev. 2.0 B8:27:EB:10:C8:9D RS Intenso Class 10 x x
9 rpi09 RS Samsung B Rev. 2.0 B8:27:EB:BD:BA:96 RS Intenso Class 10 x x
10 rpi10 RS Samsung B Rev. 2.0 B8:27:EB:48:9A:63 RS Intenso Class 10 x x

87
C Erweiterungsboard

LM75B

Nor
th

Eas
t

West

Sout
h
MCP3002

Abbildung C.1: Erweiterungsboard

89
C Erweiterungsboard

Tabelle C.1: Erweiterungsboard und Routing der Komponeten

Bauteil Bemerkung GPIO

LED North grün, PWM 18


LED East rot 23
LED West gelb 25
LED South blau 24
Switch North Pull-Down 4
Switch East Pull-Down 17
Switch West Pull-Down 22
Switch South Pull-Down 27
LM75B SDA 2
SCL 3
MCP3002 MOSI 10
MISO 9
SCLK 11
CS / SS 8

90
D Code Listings
Alle Code Listings stehen unter http://www.nico-maas.de/RPi_HTW.tar.gz zum Dow-
nload bereit. Die auf dem RPi vorinstallierten Listings enthalten nicht die Lösungen zu
den gestellten Übungen um diese nicht vorweg zu nehmen.

D.1 boardTest.c

/*
* boardTest . c :
* Programm zum halbautomatischen Test
* des Erweiterungsboards und Beispiel
* zur Nutzung der GPIOs mit wiringPi2 und C
* Testet
* - LEDs
* - PWM
* - Schalter
* - I2C LM75B
* - SPI MCP3002
*/

// Include wiringPi
# include < stdio .h >
# include < wiringPi .h >
// Include and Define I2C
# include < wiringPiI2C .h >
# include < stdlib .h >
# define lm75b_addr 0 x48
int lm75b_file ;
int n ;
int lm75_temp ;
signed char lm75b_hi ;
signed char lm75b_lo ;
float lm75b_temp ;
// Include and Define SPI
# include < stdint .h >
# include < wiringPiSPI .h >
# define ADCCHANNEL 0
// LED Pins
# define LEDNORTH 18
# define LEDEAST 23
# define LEDWEST 25
# define LEDSOUTH 24
// Switch Pins
# define SWITCHNORTH 4

91
D Code Listings

# define SWITCHEAST 17
# define SWITCHWEST 22
# define SWITCHSOUTH 27
// PWM Variable
int bright ;
int i ;

int main ( void )


{
wiringPiSetupGpio () ;
// wiringPi mit GPIO Bennungschema intialisieren
/*
* LED Test
*/
pinMode ( LEDNORTH , OUTPUT ) ;
pinMode ( LEDEAST , OUTPUT ) ;
pinMode ( LEDWEST , OUTPUT ) ;
pinMode ( LEDSOUTH , OUTPUT ) ;
// LED Pins als Ausgabe definieren

printf ( " LED Test beginnt \ n " ) ;


delay (750) ;

printf ( " NORTH : LED gruen \ n " ) ;


digitalWrite ( LEDNORTH , HIGH ) ;
// LED Pin North aktivieren
delay (750) ;

printf ( " EAST : LED rot \ n " ) ;


digitalWrite ( LEDEAST , HIGH ) ;
delay (750) ;

printf ( " WEST : LED gelb \ n " ) ;


digitalWrite ( LEDWEST , HIGH ) ;
delay (750) ;

printf ( " SOUTH : LED blau \ n " ) ;


digitalWrite ( LEDSOUTH , HIGH ) ;
delay (2000) ;

digitalWrite ( LEDNORTH , LOW ) ;


digitalWrite ( LEDEAST , LOW ) ;
digitalWrite ( LEDWEST , LOW ) ;
digitalWrite ( LEDSOUTH , LOW ) ;
// LED Pins deaktivieren

printf ( " LED Test beendet \ n " ) ;

/*
* PWM Test
*/
pinMode ( LEDNORTH , PWM_OUTPUT ) ;
// LED Pin North als PWM Ausgang definieren

92
D.1 boardTest.c

printf ( " PWM Test beginnt \ n " ) ;

for ( i =0; i < 4; i ++)


{
for ( bright = 0 ; bright < 1024 ; ++ bright )
{
pwmWrite ( LEDNORTH , bright ) ;
// LED Pin mit PWM Wert ansteuern .
delay (1) ;
}

for ( bright = 1023 ; bright >= 0 ; -- bright )


{
pwmWrite ( LEDNORTH , bright ) ;
delay (1) ;
}
}
printf ( " PWM Test beendet \ n " ) ;

/*
* Switch Test
*/
pinMode ( SWITCHNORTH , INPUT ) ;
pinMode ( SWITCHEAST , INPUT ) ;
pinMode ( SWITCHWEST , INPUT ) ;
pinMode ( SWITCHSOUTH , INPUT ) ;
// Switch Pins als Eingabe definieren
printf ( " Switch Test beginnt \ n " ) ;

printf ( " NORTH : Switch druecken \ n " ) ;


while ( digitalRead ( SWITCHNORTH ) == LOW )
// So lange der Switch North nicht gedrÃ×ckt ist , warten
delay (1) ;
printf ( " NORTH : Switch ok \ n " ) ;

printf ( " EAST : Switch druecken \n " ) ;


while ( digitalRead ( SWITCHEAST ) == LOW )
delay (1) ;
printf ( " EAST : Switch ok \ n " ) ;

printf ( " WEST : Switch druecken \n " ) ;


while ( digitalRead ( SWITCHWEST ) == LOW )
delay (1) ;
printf ( " WEST : Switch ok \ n " ) ;

printf ( " SOUTH : Switch druecken \ n " ) ;


while ( digitalRead ( SWITCHSOUTH ) == LOW )
delay (1) ;
printf ( " SOUTH : Switch ok \ n " ) ;

printf ( " Switch Test beendet \ n " ) ;

93
D Code Listings

/*
* LM75B Sensortest
* Original von http :// www . keesmoerman . nl / raspberry . html
* Fehlerkorrektur fÃ×r falschen Bus von Nico Maas
*/
printf ( " LM75B Temperatursensor Test beginnt \ n " ) ;
if (( lm75b_file = wiringPiI2CSetup ( lm75b_addr ) ) == -1)
{
printf ( " Kann den I2C Bus nicht oeffnen !\ n " ) ;
return -1;
}
// Verbindung zu LM75B oeffnen

for ( i =0; i < 10; i ++)


{
lm75_temp = wiringPiI2CReadReg16 ( lm75b_file , 0) ;
// Register 0 von LM75B in 16 Bit Tiefe auslesen
lm75b_hi = ( lm75_temp & 0 xFF ) ;
lm75b_lo = ( lm75_temp >> 8) ;
// In 2 x 8 Bit Werte ( High und Low Bit ) umwandeln
n = lm75b_hi << 3 | (( lm75b_lo >> 5) & 0 x07 ) ;
/* gemaess Datasheet des Sensors aus den ausgelesenen
2 Bytes die korreten 11 Bits fÃ×r den Temperaturwert
extrahieren und shiften */
lm75b_temp = ( float ) n / 8;
// 11 Bit Wert in Temperatur umwandeln
printf ( " LM75B : %4.2 f Grad Celsius \ n " , lm75b_temp ) ;
// Temperatur mit 2 Nachkommastellen ausgeben

delay (750) ;
}
printf ( " LM75B Temperatursensor Test beendet \ n " ) ;

/*
* MCP3002 ADC Test
* Angepasst von http :// raspberrypihobbyist . blogspot . de /2012/12/
analog - interface . html
*/
printf ( " MCP3002 ADC Test beginnt \ n" ) ;
// SPI Daten von MCP3002 Chip lesen , 2 moegliche Kanaele (0 und 1)
int readadc ( adcnum )
{
uint8_t buff [2];
if (( adcnum > 1) || ( adcnum < 0) )
{
return -1;
}
// Nur MCP Kanal 0 und 1 zulassen
buff [0] = (6+ adcnum ) < <4;
buff [1] = 0;
// korrekte Anfrage fuer MCP3002 gemaess Datenblatt erzeugen
wiringPiSPIDataRW (0 , buff , 2) ;
// Anfrage absenden und Antwort in den Puffer schreiben

94
D.2 gpio.sh

return (( buff [0]&3) << 8) + buff [1];


// Wert aus Puffer shiften
}

if ( wiringPiSPISetup (0 , 1000000) < 0)


{
return -1 ;
}
/* WiringPi SPI API initalisieren auf Slave Select / SPI Kanal 0
mit Geschwindigkeit 1 MHz */

for ( i =0; i < 10; i ++)


{
// Wert von MCP3002 , Kanal 0 ( LDR ) ausgeben
printf ( " MCP3002 - Channel 0: % d \ n " , readadc ( ADCCHANNEL ) ) ;
delay (750) ;
}
printf ( " MCP3002 ADC Test beendet \ n" ) ;

return 0 ;
}


D.2 gpio.sh

# !/ bin / bash
# LED
# GPIO als Ausgang deklarieren und Hilfsfunktionen fuer Steuerung
definieren
# LED gruen , norden
gpio export 18 out
ledNorthOn ()
{
gpio -g write 18 1
}

ledNorthOff ()
{
gpio -g write 18 0
}

# LED rot , east


gpio export 23 out
ledEastOn ()
{
gpio -g write 23 1
}

ledEastOff ()
{
gpio -g write 23 0

95
D Code Listings

# LED gelb , west


gpio export 25 out
ledWestOn ()
{
gpio -g write 25 1
}

ledWestOff ()
{
gpio -g write 25 0
}

# LED blau , south


gpio export 24 out
ledSouthOn ()
{
gpio -g write 24 1
}

ledSouthOff ()
{
gpio -g write 24 0
}

# LED , alle
ledOn ()
{
gpio -g write 18 1
gpio -g write 23 1
gpio -g write 25 1
gpio -g write 24 1
}

ledOff ()
{
gpio -g write 18 0
gpio -g write 23 0
gpio -g write 25 0
gpio -g write 24 0
}

ledBlinkFast ()
{
for i in {0..1}
do
ledOn
sleep 0.25
ledOff
sleep 0.25
done
}

96
D.3 demoLed.sh

ledBlink ()
{
for i in {0..1}
do
ledOn
sleep 0.5
ledOff
sleep 0.5
done
}

# Switch
# GPIO als Eingang deklarieren und Hilfsfunktionen fuer Steuerung
definieren

# Switch north
gpio export 4 in
switchNorth ()
{
echo ` gpio -g read 4 `
}

# Switch east
gpio export 17 in
switchEast ()
{
echo ` gpio -g read 17 `
}

# Switch west
gpio export 22 in
switchWest ()
{
echo ` gpio -g read 22 `
}

# Switch south
gpio export 27 in
switchSouth ()
{
echo ` gpio -g read 27 `
}


D.3 demoLed.sh

# !/ bin / bash
source gpio . sh
# GPIO Hilfsdatei einfuegen

echo '

97
D Code Listings

Raspberry Pi Shield Demo


Alle LEDs werden auf dem Shield aktiviert und
anschliessend deaktiviert .
Das Programm beendet sich automatisch .
';

ledNorthOn
sleep 0.25
ledEastOn
sleep 0.25
ledWestOn
sleep 0.25
ledSouthOn
# LEDs anschalten

sleep 2
# 2 Sekunden warten

ledNorthOff
ledEastOff
ledWestOff
ledSouthOff
# LEDs ausschalten


D.4 demoSwitch.sh

# !/ bin / bash
source gpio . sh
# GPIO Hilfsdatei einfuegen

echo '
Raspberry Pi Shield Demo
Druecke einen Schalter auf dem Shield um die
entsprechende LED zu aktivieren .
STRG + C um das Programm zu beenden .
';

while :
do
if [ $ ( switchNorth ) = 1 ]
# falls Schalter North gedrueckt ist
then
echo " North gedrueckt "
ledNorthOn
# North gedrueckt ausgeben und die entsprechende LED anschalten
else
ledNorthOff
# sonst die LED ausschalten
fi

if [ $ ( switchEast ) = 1 ]

98
D.5 simon.sh

then
echo " East gedrueckt "
ledEastOn
else
ledEastOff
fi

if [ $ ( switchWest ) = 1 ]
then
echo " West gedrueckt "
ledWestOn
else
ledWestOff
fi

if [ $ ( switchSouth ) = 1 ]
then
echo " South gedrueckt "
ledSouthOn
else
ledSouthOff
fi

done


D.5 simon.sh

# !/ bin / bash
source gpio . sh
# GPIO Hilfsdatei einfuegen

# Konstanten
# Verzoegerung zwischen LED leuchten
DELAY_TIME_LED =0.25
# Verzoegerung bei Switch Eingabe
DELAY_TIME_SWITCH =0.2
# Variablen
# correct =0 Eingaben in Ordnung , Spiel geht weiter
# correct = -1 Eingabe falsch , Abbruch
correct =0

MakeRandom ()
{ # Zufallszahl zwischen 0 und 3
echo $ (( RANDOM %4) )
}

LightLed ()
{ # gibt alle Werte aus dem Array wieder , zeigt
# also an welche Werte eingegeben werden
# muessen um die Runde zu schaffen .
# Alle Werte im Array abrufen

99
D Code Listings

for value in " $ { simonArray [ @ ]} "


do
# gemaess dem Array Wert die pasende LED
# an - und ausschalten
case " $value " in
0)
ledNorthOn
sleep $ { DELAY_TIME_LED }
ledNorthOff
sleep $ { DELAY_TIME_LED }
;;
1)
ledEastOn
sleep $ { DELAY_TIME_LED }
ledEastOff
sleep $ { DELAY_TIME_LED }
;;
2)
ledWestOn
sleep $ { DELAY_TIME_LED }
ledWestOff
sleep $ { DELAY_TIME_LED }
;;
3)
ledSouthOn
sleep $ { DELAY_TIME_LED }
ledSouthOff
sleep $ { DELAY_TIME_LED }
;;
esac
done
}

ReadButton ()
{ # Liest den Zustand der 4 Schalter ein
# sollte einer gedrueckt sein wird die
# Abfrage abgebrochen und der Wert
# zurueck gegeben . Ist keiner gedrueckt ,
# wird -1 zurueck gegeben .
if [ $ ( switchNorth ) = 1 ]
then
echo 0
elif [ $ ( switchEast ) = 1 ]
then
echo 1
elif [ $ ( switchWest ) = 1 ]
then
echo 2
elif [ $ ( switchSouth ) = 1 ]
then
echo 3
else
echo -1

100
D.5 simon.sh

fi
}

CheckButton ()
{ # Ueberprueft ob die eingegebene
# Kombination der physikalischen
# Schalter der vorgegebenen
# entspricht . Falls ja , geht
# das Spiel weiter , wenn nicht ,
# wird correct = -1 gesetzt .
# Alle Werte im Array abrufen
for value in " $ { simonArray [ @ ]} "
do
# Wert der Schalter auslesen
btn = $ ( ReadButton )
# Solange kein Schalter gedrueckt
# ist , weiter auslesen
while [ $btn == -1 ]
do
btn = $ ( ReadButton )
done
# Falls ein Schalter gedrueckt wurde ,
# und der Wert der Stelle im Array
# entspricht , weiter machen
if [ $btn == $value ]
then
echo " Ok ! "
# sleep hilft an dieser Stelle einem
# zu lange gedrueckten Schalter vorzubeugen .
# Alternativ koennte man in ReadButton
# einen Flankenwechsel als Schalterdruck
# identifizieren
sleep $ { DELAY_TIME_SWITCH }
# Sonst : correct = -1 setzen und
# aus der Schleife ausbrechen
else
echo " Falsch ! "
correct = -1
break
fi
done
}

# 2 x schnelles blinken aller LEDs


# als " Willkommen "
ledBlinkFast
sleep 0.5

# Solange die eingegebenen Kombinationen richtig waren ,


# geht das Spiel immer weiter .
while [ $correct == 0 ]
do
# An der Stelle " groesse des Arrays " einen neuen Zufallswert

101
D Code Listings

# zwischen 0 und 3 in das Array einfuegen . Damit sparen


# wir uns die Zahlvariable / Iterationsvariable
simonArray [ ${ # simonArray [ @ ]}]= $ ( MakeRandom )
# Alle Zufallswerte des Arrays auf den LEDs abspielen
LightLed
# Die Eingabe der Zufallswerte ueber die Schalter
# erwarten und auf Fehler auswerten . Bei Fehler
# wird correct = -1 gesetzt und das Spiel endet .
# Sonst geht es endlos weiter .
CheckButton
done

# 2 x langsames blinken aller LEDs


# bei Fehler / Ende des Spiels
sleep 0.5
ledBlink

echo $ { # simonArray [@ ]}
echo $ { simonArray [ @ ]}

# Neustart des Spiels bei Fehler


./ simon . sh


D.6 uebungAusgabe.py

# !/ usr / bin / python


import wiringpi2 as wpi
from time import sleep
wpi . wiringPiSetupGpio ()

LEDs =[18 ,23 ,24 ,25]


# LED Pins als Array fuer
# gruen , rot , blau , gelb
led_mode =1
# Variable welche den Wert
# haelt ob die LED ein oder
# ausgeschaltet werden soll

for led_pin in LEDs :


wpi . pinMode ( led_pin ,1)
wpi . digitalWrite ( led_pin ,0)
# Setup : Alle Pins mit LEDs
# als Ausgabe setzen und
# abschalten

while True :
for led_pin in LEDs :
wpi . digitalWrite ( led_pin , led_mode )
sleep (0.25)
led_mode = not ( led_mode )
# Loop : Jeweils pro Durchlauf

102
D.7 uebungEingabe.py

# alle LEDs in den jeweils gueltigen


# Mode setzen und danach den Mode
# negieren ( An / Aus )


D.7 uebungEingabe.py

# !/ usr / bin / python


import wiringpi2 as wpi
from time import sleep
wpi . wiringPiSetupGpio ()

LEDs =[24 ,25 ,18 ,23]


# LED Pins als Array fuer
# blau , gelb , gruen , rot
for led_pin in LEDs :
wpi . pinMode ( led_pin ,1)
wpi . digitalWrite ( led_pin ,0)
# Setup : Alle Pins mit LEDs
# als Ausgabe setzen und ausschalten
wpi . pinMode (27 ,0)
# Setup : Schalter South
# als Eingabe setzen

def blinkLED ( ledPin , wieoftBlinken , verzoegerung ) :


for i in range (1 ,(( wieoftBlinken *2) +1) ) :
wpi . digitalWrite ( LEDs [ ledPin ] ,( i %2) )
sleep ( verzoegerung )
# Modul blinkLED nimmt die aktuelle LED entgegen
# und laesst diese mit gegebener Verzoegerung
# eine gewisse Anzahl blinken

aktuelleLED =0
# Gibt aktuelle LED as Position im Array an
aktuelleVerzoegerung =0.50
# Gibt die aktuelle Verzoegerung zwischen
# den LED wechseln an
aktuelleRunde =1
# Gibt die aktuelle Runde an

while True :
if ( wpi . digitalRead (27) ) :
# falls der Schalter gedrueckt wurde
blinkLED ( aktuelleLED , 2 , 0.5)
# lass die mit dem Schalter gewaehelte
# LED zwei mal blinken
if ( aktuelleLED ==2) :
if ( aktuelleVerzoegerung > 0.05) :
aktuelleVerzoegerung = aktuelleVerzoegerung -0.05
# reduziere die Verzoegerung fuer die
# nacheste Runde , falls moeglich
aktuelleLED =0

103
D Code Listings

# setze LED wieder auf Anfang vom Array zurueck


print ( " Runde % d bestanden " % aktuelleRunde )
# Erfolg
aktuelleRunde = aktuelleRunde +1
# naechste Runde
else :
print ( " Leider verloren in Runde % d ! " % aktuelleRunde )
# Niederlage , weil falsch / zu spaet gedrueckt
break
# Verlasse Schleife und beende Programm
blinkLED ( aktuelleLED , 1 , aktuelleVerzoegerung )
# die jeweils aktuelle LED einmal blinken lassen
aktuelleLED = aktuelleLED +1
# und zur naechsten iterieren
if ( aktuelleLED > 3) :
print ( " Leider verloren in Runde % d ! " % aktuelleRunde )
# Niederlage , weil gar nicht gedrueckt
break
# Verlasse Schleife und beende Programm


D.8 binaryCounter.py

# !/ usr / bin / python


import wiringpi2 as wpi
wpi . wiringPiSetupGpio ()

LEDs =[18 ,23 ,24 ,25]


# LED Pins als Array fuer
# gruen , rot , blau , gelb
for led_pin in LEDs :
wpi . pinMode ( led_pin ,1)
wpi . digitalWrite ( led_pin ,0)
# Setup : Alle Pins mit LEDs
# als Ausgabe setzen und ausschalten
wpi . pinMode (27 ,0)
wpi . pinMode (22 ,0)
# Setup : Schalter South ,
# Schalter West als Eingabe setzen
southState = wpi . digitalRead (27)
westState = wpi . digitalRead (22)
# Setup : Initialer Status
# von South und West einlesen

zahl =0
# Zaehlvariable
ledMode =[0 ,0 ,0 ,0]
# Zwischenspeicher fuer die
# Ergebnisse der Umrechnung

def showLED () :
ledMode [0] = zahl & 0 b0001

104
D.9 lm75b.py

ledMode [1] = zahl & 0 b0010


ledMode [2] = zahl & 0 b0100
ledMode [3] = zahl & 0 b1000
# jeweils aus der binaeren Verundung der
# Zahl und der Wertigkeit der LED
# den Status fuer die LED errechnen
# und speichern
for i in range (0 ,4) :
wpi . digitalWrite ( LEDs [ i ] , ledMode [ i ])
# alle LEDs auf den aktuellen Status setzen
print ( " Dezimal %d , Binaer %s , Hexadezimal % s " % ( zahl , bin ( zahl ) ,
hex ( zahl ) ) )
# die aktuelle Zahl als Dezimal ,
# Binaer und Hexadezminal Notation
# ausgeben

showLED ()
while True :
southValue = wpi . digitalRead (27)
# aktueller Status des
# Schalters einlesen
if ( southValue != southState ) :
# besteht ein Unterschied
# zum gespeicherten Status
if ( southValue ) :
# Ist der +1 Schalter gedrueckt ?
zahl = zahl +1
# Zahl erhoehen
if zahl >15:
zahl =0
# Zahl ruecksetzen falls zu hoch
showLED ()
# Anzeigen
southState = southValue
# neuen Wert des Schalters speichern
westValue = wpi . digitalRead (22)
if ( westValue != westState ) :
if ( westValue ) :
# Ist der Reset Schalter gedrueckt ?
zahl =0
# Zahl ruecksetzen
showLED ()
# Anzeigen
westState = westValue


D.9 lm75b.py

# !/ usr / bin / python


import wiringpi2 as wpi

lm75b_addr =0 x48

105
D Code Listings

lm75b_file = wpi . wiringPiI2CSetup ( lm75b_addr )


# Verbindung zu LM75B oeffnen
if lm75b_file < 0:
print ( " Kann den I2C Bus nicht oeffnen ! " )
else :
lm75_temp = wpi . wiringPiI2CReadReg16 ( lm75b_file , 0)
# Register 0 von LM75B in 16 Bit Tiefe auslesen
lm75b_hi = ( lm75_temp & 0 xFF )
lm75b_lo = ( lm75_temp >> 8)
# In 2x 8 Bit Werte ( High und Low Bit ) umwandeln
n = lm75b_hi << 3 | (( lm75b_lo >> 5) & 0 x07 )
# gemaess Datasheet des Sensors aus den ausgelesenen
# 2 Bytes die korreten 11 Bits fuer den Temperaturwert
# extrahieren und shiften
lm75b_temp = n / 8.0
# 11 Bit Wert in Temperatur umwandeln
print ( " LM75B : %4.2 f Grad Celsius " % ( lm75b_temp ) )
# Temperatur mit 2 Nachkommastellen ausgeben


D.10 uebungI2C.py

# !/ usr / bin / python


import wiringpi2 as wpi
from time import sleep

lm75b_addr =0 x48
# I2C Adresse des LM75B
LEDs =[24 ,18 ,23]
# LED Pins als Array fuer
# blau , gruen , rot
modifierState =[ -1 ,0 ,+1]
# Temperatur Unterschiede fuer Ubergang
nameState =[ " Kalt " ," Normal " ," Warm " ]
# Namen der States
currentState =0
# State der Pseudo State Machine
maxStates =3
# Anzahl der States

def readTemp () :
lm75_temp = wpi . wiringPiI2CReadReg16 ( lm75b_file , 0)
# Register 0 von LM75B in 16 Bit Tiefe auslesen
lm75b_hi = ( lm75_temp & 0 xFF )
lm75b_lo = ( lm75_temp >> 8)
# In 2x 8 Bit Werte ( High und Low Bit ) umwandeln
n = lm75b_hi << 3 | (( lm75b_lo >> 5) & 0 x07 )
# gemaess Datasheet des Sensors aus den ausgelesenen
# 2 Bytes die korreten 11 Bits fuer den Temperaturwert
# extrahieren und shiften
lm75b_temp = n / 8.0

106
D.10 uebungI2C.py

# 11 Bit Wert in Temperatur umwandeln


return lm75b_temp

def transition ( up ) :
global currentState , maxMod , minMod
# globale Variablen in Funktion laden
wpi . digitalWrite ( LEDs [ currentState ] ,0)
# Led des jetzigen State abschalten
if ( up ==1) :
# Falls State erhoeht wird
currentState = currentState +1
# State erhoehen
print ( " Transition von % s -> % s " % ( nameState [ currentState -1] ,
nameState [ currentState ]) )
# Ausgabe vorheriger State nach jetziger State
else :
currentState = currentState -1
# State verringern
print ( " Transition von % s -> % s " % ( nameState [ currentState +1] ,
nameState [ currentState ]) )
# Ausgabe vorheriger State nach jetziger State
wpi . digitalWrite ( LEDs [ currentState ] ,1)
# Led des nun aktuellen State einschalten
if ( modifierState [ currentState ]==0) :
# Falls State 1 / Normal aktiv
maxMod =1
# setze maximalen Wert auf +1
minMod = -1
# setze minimalen Wert auf -1
else :
# sonst setze Max / Min gemaess Array
maxMod = modifierState [ currentState ]
minMod = modifierState [ currentState ]

lm75b_file = wpi . wiringPiI2CSetup ( lm75b_addr )


# Verbindung zu LM75B oeffnen
if lm75b_file < 0:
print ( " Kann den I2C Bus nicht oeffnen ! " )
else :
# Setup
wpi . wiringPiSetupGpio ()
# Initialisiert die Bibliothek unter Nutzung des
# BCM GPIO Namenschema
for led_pin in LEDs :
wpi . pinMode ( led_pin ,1)
wpi . digitalWrite ( led_pin ,0)
# Alle Pins mit LEDs als Ausgabe setzen und abschalten
idealTemp = readTemp ()
# Ideal Temperatur messen
transition (1)
# Initalisieren auf Normal Modus

while True :

107
D Code Listings

if (( readTemp () > ( idealTemp + maxMod ) ) and ( currentState < (


maxStates -1) ) ) :
# falls aktuelle Temperatur groesser als Ideal Temperatur +
Modifier
# und aktueller State kleiner als die maximale Anzahl an States
transition (1)
# State erhoehen
elif (( readTemp () < ( idealTemp + minMod )) and ( currentState > 0) ) :
# falls aktuelle Temperatur kleiner als Ideal Temperatur + Modifier
# und aktueller State groesser als 0
transition (0)
# State verringern
else :
# falls innerhalb der Temperatur des States
print ( " % s : %4.2 f " % ( nameState [ currentState ] , readTemp () ) )
# aktueller State und aktuelle Temperaturmessung ausgeben
sleep (0.25)


D.11 mcp3002.py

# !/ usr / bin / python


import wiringpi2 as wpi
from binascii import hexlify
from binascii import unhexlify

mcp3002_channel =0

if wpi . wiringPiSPISetup (0 ,1000000) < 0:


print ( " Kann den SPI Bus nicht oeffnen ! " )
else :
buffer =((6+ mcp3002_channel ) < <12)
buffer = ' {0: x } '. format ( int ( buffer ) )
# Wandle den dezimalen Integer in einen
# hexadezimalen String um , ohne das Praefix
# 0 x davorzustellen
buffer = unhexlify ( buffer )
# Wandle den Hex String in einen Byte String um

if ( wpi . wiringPiSPIDataRW (0 , buffer ) == -1) :


# Anforderung auf den SPI Bus auf Slave
# Select 0 schreiben und
# gleichzeitig ( bi - direktional ) mit der
# Antwort den Buffer ueberschreiben
print ( " Schreibfehler auf SPI Bus !\ n " )
else :
buffer = hexlify ( buffer )
# Wandle den Byte String nach Hex um
buffer = int ( buffer , 16)
# Wandle den Hex String in einen
# dezimalen Integer Wert um
prozent = ( buffer /1024.0) *100

108
D.12 mcp3002lib.py

# Wandle dezimalen Integer in Prozentwert


# der eingegangen Beleuchtungsstaerke um
print ( " MCP3002 - Kanal % d : %4.2 f Prozent " % ( mcp3002_channel ,
prozent ) )


D.12 mcp3002lib.py

# !/ usr / bin / python


import wiringpi2 as wpi

mcp3002_channel =0

if ( wpi . wiringPiSPISetup (0 , 1000000) < 0) :


# Verbindung zu MCP3002 oeffnen
print ( " Kann den SPI Bus nicht oeffnen ! " )
else :
wpi . mcp3002Setup (64 , mcp3002_channel )
# MCP3002 Template laden , Kanal 0 auf virtuellen Port 64 legen
buffer = wpi . analogRead (64)
# Virtuellen Port 64 auslesen
prozent = ( buffer /1024.0) *100
# Wandle dezimalen Integer in Prozentwert
# der eingegangen Beleuchtungsstaerke um
print ( " MCP3002 - Kanal % d : %4.2 f Prozent " % ( mcp3002_channel , prozent
))


D.13 uebungSPI.py

# !/ usr / bin / python


import curses
from time import sleep
import wiringpi2 as wpi

mcp3002_channel =0

if ( wpi . wiringPiSPISetup (0 , 1000000) < 0) :


# Verbindung zu MCP3002 oeffnen
print ( " Kann den SPI Bus nicht oeffnen ! " )
else :
wpi . mcp3002Setup (64 , mcp3002_channel )
# MCP3002 Template laden , Kanal 0 auf virtuellen Port 64 legen
ldr_max = float ( wpi . analogRead (64) )
# Virtuellen Port 64 auslesen , als maximal Wert
screen = curses . initscr ()
# curses in der Konsole initialisieren
dims = screen . getmaxyx ()
# y , x Groesse des Bildschirms in Array ablegen
# dims [0] entspricht y Wert

109
D Code Listings

# dims [1] entspricht x Wert


screen . nodelay (1)
# nodelay Modus aktivieren um screen . getch ()
# im non - Blocking Modus zu betreiben

while ( screen . getch () == -1) :


# fuehre die Schleife aus solange keine
# Taste gedrueckt wurde
ldr = wpi . analogRead (64)
# aktuellen Wert einlesen
wert = int (( ldr / ldr_max ) * dims [0])
# LDR Wert auf Dimensionen des Bildschirms skalieren
if wert >= dims [0]:
# Sollte der Wert die y Dimension ueberschreiten
wert = ( dims [0] -1)
# dann einfach fuer diese Messung
# y - Dimension - 1 als Wert nehmen
wert = dims [0] - wert
# Gegenwert berechnen , da bei curses die linke , obere
# Bildschirm Ecke die x , y Koordinaten 0 ,0 hat
screen . erase ()
# Bildschirm loeschen
screen . hline ( wert , 0, ' - ' , dims [1])
# horinzontale Linie aus - Zeichen malen ,
# welche so breit wie die maximale x Dimension ( dims [1])
# ist und beim x Wert 0 beginnt
# hline (y Koordinate , x Beginn , ch Zeichen , n Laenge )
screen . refresh ()
# Bildschirm neu laden
sleep (0.1)
curses . endwin ()
# Beenden


D.14 wpi.c

// wiringPi 2 MathLink

# include " mathlink . h "


# include < stdio .h >
# include < wiringPi .h >
// Include and Define I2C
# include < wiringPiI2C .h >
# include < stdlib .h >
# define lm75b_addr 0 x48
int lm75b_file ;
int n ;
int lm75_temp ;
signed char lm75b_hi ;
signed char lm75b_lo ;
float lm75b_temp ;
// Include and Define SPI

110
D.14 wpi.c

# include < stdint .h >


# include < wiringPiSPI .h >

extern void setPinMode ( int pin , int mode ) ;


extern void setDigitalWrite ( int pin , int value ) ;
extern void setPwmWrite ( int pin , int value ) ;
extern int getDigitalRead ( int pin ) ;
extern float getLM75B () ;
extern int getMCP3002 ( int channel );

void setPinMode ( int pin , int mode )


{
pinMode ( pin , mode ) ;
MLPutSymbol ( stdlink , " Null " ) ;
}

void setDigitalWrite ( int pin , int value )


{
digitalWrite ( pin , value ) ;
MLPutSymbol ( stdlink , " Null " ) ;
}

void setPwmWrite ( int pin , int value )


{
pwmWrite ( pin , value ) ;
MLPutSymbol ( stdlink , " Null " ) ;
}

int getDigitalRead ( int pin )


{
return digitalRead ( pin ) ;
}

float getLM75B ()
{
if (( lm75b_file = wiringPiI2CSetup ( lm75b_addr ) ) == -1)
{
printf ( " Kann den I2C Bus nicht oeffnen !\ n " ) ;
return -1;
}
// Verbindung zu LM75B oeffnen
lm75_temp = wiringPiI2CReadReg16 ( lm75b_file , 0) ;
// Register 0 von LM75B in 16 Bit Tiefe auslesen
lm75b_hi = ( lm75_temp & 0 xFF ) ;
lm75b_lo = ( lm75_temp >> 8) ;
// In 2 x 8 Bit Werte ( High und Low Bit ) umwandeln
n = lm75b_hi << 3 | (( lm75b_lo >> 5) & 0 x07 ) ;
/* gemaess Datasheet des Sensors aus den ausgelesenen
2 Bytes die korreten 11 Bits fÃ×r den Temperaturwert
extrahieren und shiften */
lm75b_temp = ( float ) n / 8;
// 11 Bit Wert in Temperatur umwandeln
return lm75b_temp ;

111
D Code Listings

int getMCP3002 ( int channel )


{
uint8_t buff [2];
if (( channel > 1) || ( channel < 0) )
{
// Nur MCP Kanal 0 und 1 zulassen
return -1;
}

if ( wiringPiSPISetup (0 , 1000000) < 0)


{
return -1 ;
}
/* WiringPi SPI API initalisieren auf Slave Select / SPI Kanal 0
mit Geschwindigkeit 1 MHz */
buff [0] = (6+ channel ) < <4;
buff [1] = 0;
// korrekte Anfrage fuer MCP3002 gemaess Datenblatt erzeugen
wiringPiSPIDataRW (0 , buff , 2) ;
// Anfrage absenden und Antwort in den Puffer schreiben
return (( buff [0]&3) << 8) + buff [1];
// Wert aus Puffer shiften
}

int main ( int argc , char * argv [])


{
wiringPiSetupGpio () ;
return MLMain ( argc , argv ) ;
}


D.15 wpi.tm

float getLM75B () ;

: Begin :
: Function : getLM75B
: Pattern : getLM75B []
: Arguments : { }
: ArgumentTypes : { }
: ReturnType : Float
: End :

: Evaluate : getLM75B :: usage = " getLM75B [] gives the Temperature in


degree Celsius . "

int getMCP3002 P (( int ) ) ;

112
D.15 wpi.tm

: Begin :
: Function : getMCP3002
: Pattern : getMCP3002 [ channel_Integer ]
: Arguments : { channel }
: ArgumentTypes : { Integer }
: ReturnType : Integer
: End :

: Evaluate : getMCP3002 :: usage = " getMCP3002 [ channel ] gives 10 bit


reading (0 -1023) of the choosen ADC channel 0 -1. "

void setPinMode P (( int , int ) ) ;

: Begin :
: Function : setPinMode
: Pattern : setPinMode [ pin_Integer , mode_Integer ]
: Arguments : { pin , mode }
: ArgumentTypes : { Integer , Integer }
: ReturnType : Manual
: End :

: Evaluate : setPinMode :: usage = " setPinMode [ pin , mode ] set the given pin
to 0 ( Input ) , 1 ( Output ) or 2 ( PWM Output ) . "

void setDigitalWrite P (( int , int ) ) ;

: Begin :
: Function : setDigitalWrite
: Pattern : setDigitalWrite [ pin_Integer , value_Integer ]
: Arguments : { pin , value }
: ArgumentTypes : { Integer , Integer }
: ReturnType : Manual
: End :

: Evaluate : setDigitalWrite :: usage = " setDigitalWrite [ pin , value ] writes


a digital value (0 -1) to the pin . "

void setPwmWrite P (( int , int ) ) ;

: Begin :
: Function : setPwmWrite
: Pattern : setPwmWrite [ pin_Integer , value_Integer ]
: Arguments : { pin , value }
: ArgumentTypes : { Integer , Integer }
: ReturnType : Manual
: End :

113
D Code Listings

: Evaluate : setPwmWrite :: usage = " setPwmWrite [ pin , value ] writes a pwm


value (0 -1023) to the pin . "

int getDigitalRead P (( int ) ) ;

: Begin :
: Function : getDigitalRead
: Pattern : getDigitalRead [ pin_Integer ]
: Arguments : { pin }
: ArgumentTypes : { Integer }
: ReturnType : Integer
: End :

: Evaluate : getDigitalRead :: usage = " getDigitalRead [ pin ] gives the


digital reading (0 or 1) of the pin . "


114
Kolophon
Dieses Dokument wurde mit der LATEX-Vorlage für Abschlussarbeiten an der htw saar
im Bereich Informatik/Mechatronik-Sensortechnik erstellt (Version 1.0). Die Vorlage
wurde von Yves Hary und André Miede entwickelt (mit freundlicher Unterstützung
von Thomas Kretschmer und Helmut G. Folz).