Anwendung des Raspberry Pi in Forschung und Lehre · Steuerung realer Hardware mittels modernen Hochsprachen wie C, Python oder Ja-va. Die nachfolgende Arbeit soll an konkreten Beispielen

Anwendung des Raspberry Pi in Forschung und Lehre

Bachelor-Thesis

Nico Maas

Erstgutachter: Prof. Dr. Helmut G. FolzEinreichung: 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 alsdie angegebenen Quellen und Hilfsmittel benutzt habe.

Ich erkläre hiermit weiterhin, dass die vorgelegte Arbeit zuvor weder von mir, nochvon 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 Ausschlussvon 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 immerpräsenter in der IT und ermöglichen die schnelle und unkomplizierte Verbindung undSteuerung realer Hardware mittels modernen Hochsprachen wie C, Python oder Ja-va. Die nachfolgende Arbeit soll an konkreten Beispielen versuchen, die Möglichkeitendes damit eröffneten „Physical Computing“, zur leichteren Darstellung komplexererLehrinhalte zu verwenden und damit den Lernerfolg nachhaltig zu steigern.

v

Any sufficiently advanced technologyis 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 32.1 Raspberry Pi und BeagleBone Black . . . . . . . . . . . . . . . . . . . . . 3

2.1.1 Raspberry Pi Modell B+ . . . . . . . . . . . . . . . . . . . . . . . . 32.1.2 BeagleBone Black Revision C . . . . . . . . . . . . . . . . . . . . . 42.1.3 Vergleich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.2 Raspberry Pi Modelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.2.1 Unterschiede Modell A und B . . . . . . . . . . . . . . . . . . . . . 72.2.2 Modell B pre 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.2.3 Modell A/B 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.2.4 Compute Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.2.5 Modell A+/B+ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3 Grundlagen und Installation 93.1 Peripherie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

3.1.1 SD Karte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93.1.2 Netzteil mit Micro USB Anschluss . . . . . . . . . . . . . . . . . . 103.1.3 Netzwerkkabel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103.1.4 HDMI auf DVI Adapterkabel / Display mit DVI Eingang . . . . 103.1.5 Weitere Komponenten . . . . . . . . . . . . . . . . . . . . . . . . . 11

3.2 Anschluss des Raspberry Pi . . . . . . . . . . . . . . . . . . . . . . . . . . 113.3 Raspbian . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113.4 Installation mittels Image . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

3.4.1 Image downloaden . . . . . . . . . . . . . . . . . . . . . . . . . . . 123.4.2 Formatieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123.4.3 Image kopieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143.4.4 Backup und Wiederherstellung . . . . . . . . . . . . . . . . . . . . 14

3.5 Installation mittels noobs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153.5.1 noobs downloaden . . . . . . . . . . . . . . . . . . . . . . . . . . . 153.5.2 Formatieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153.5.3 noobs kopieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163.5.4 Raspbian mit noobs installieren . . . . . . . . . . . . . . . . . . . . 163.5.5 Vorteile von noobs . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

ix

4 Konfiguration von Raspbian 194.1 Erster Boot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

4.1.1 raspi-config . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194.2 WLAN Zugriff / eduroam . . . . . . . . . . . . . . . . . . . . . . . . . . . 224.3 Updates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

4.3.1 rpi-update . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234.3.2 apt-get . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

4.4 Einrichtung Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.4.1 Vorbereitung des I²C / SPI Bus . . . . . . . . . . . . . . . . . . . . 254.4.2 Vorbereitung der seriellen Schnittstelle . . . . . . . . . . . . . . . 26

4.5 Einrichtung Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274.5.1 Installation von wiringpi2 . . . . . . . . . . . . . . . . . . . . . . . 274.5.2 Installation von wiringpi2-python . . . . . . . . . . . . . . . . . . 284.5.3 Test des SPI Bus (Optional) . . . . . . . . . . . . . . . . . . . . . . 29

5 GPIO Schnittstelle 315.1 Aufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315.2 Sicherheitshinweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

5.2.1 Logik Level . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325.2.2 Sicherungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325.2.3 Belastbarkeit der Pins / 3,3 Volt Schiene . . . . . . . . . . . . . . . 325.2.4 Belastbarkeit der 5 Volt Schiene . . . . . . . . . . . . . . . . . . . . 325.2.5 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

5.3 GPIO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335.3.1 GPIO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335.3.2 PWM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345.3.3 I2C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355.3.4 I2S . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365.3.5 SPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365.3.6 Serial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

5.4 Das Erweiterungsboard . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385.4.1 Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385.4.2 Routing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385.4.3 Testprogramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

6 Bash Programmierung 436.1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

6.1.1 Simon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436.1.2 Ablaufdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

6.2 Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446.2.1 Erweiterungsboard und Hilfsfunktionen . . . . . . . . . . . . . . 456.2.2 LED Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 466.2.3 Switch Eingabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

6.3 Abschluss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

x

7 Python Programmierung 497.1 Arbeiten auf dem Raspberry Pi . . . . . . . . . . . . . . . . . . . . . . . . 49

7.1.1 Python 2 / Python 3 . . . . . . . . . . . . . . . . . . . . . . . . . . 497.1.2 Programmierung mittels IDLE . . . . . . . . . . . . . . . . . . . . 497.1.3 Programmierung mittels CLI . . . . . . . . . . . . . . . . . . . . . 50

7.2 Grundlagen der Python Programmierung . . . . . . . . . . . . . . . . . . 507.2.1 Ausführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507.2.2 Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507.2.3 Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507.2.4 Vergleiche und Schleifen . . . . . . . . . . . . . . . . . . . . . . . . 537.2.5 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547.2.6 Bibliotheken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

7.3 Verwendung der GPIO mittels Python . . . . . . . . . . . . . . . . . . . . 577.3.1 Digitale Ausgabe: LEDs . . . . . . . . . . . . . . . . . . . . . . . . 577.3.2 Übungsaufgabe zur digitalen Ausgabe . . . . . . . . . . . . . . . 587.3.3 Digitale Eingabe: Schalter . . . . . . . . . . . . . . . . . . . . . . . 587.3.4 Übungsaufgabe zur digitalen Eingabe . . . . . . . . . . . . . . . . 587.3.5 Abschlussprojekt GPIO: Binärzähler . . . . . . . . . . . . . . . . . 59

7.4 Verwendung des I2C Bus mittels Python . . . . . . . . . . . . . . . . . . . 607.4.1 Adressierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607.4.2 Register des Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . 617.4.3 Interpretation des Temperaturwertes . . . . . . . . . . . . . . . . 627.4.4 Übungsaufgabe zur Verwendung des I2C Bus . . . . . . . . . . . 62

7.5 Verwendung des SPI Bus mittels Python . . . . . . . . . . . . . . . . . . . 637.5.1 Adressierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 637.5.2 Kommunikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 647.5.3 Übungsaufgabe zur Verwendung des SPI Bus . . . . . . . . . . . 66

8 Mathematica 698.1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 698.2 Benutzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

8.2.1 Beispiele Free-form input . . . . . . . . . . . . . . . . . . . . . . . 708.2.2 Beispiele Wolfram Alpha query . . . . . . . . . . . . . . . . . . . . 70

8.3 Verwendung mittels Erweiterungsboard . . . . . . . . . . . . . . . . . . . 72

9 Fazit 759.1 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 759.2 Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

Literatur 77

Abbildungsverzeichnis 79

Tabellenverzeichnis 80

xi

Listings 81

Abkürzungsverzeichnis 82

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

B Raspberry Pi Hardware HTW 87B.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

C Erweiterungsboard 89

D Code Listings 91D.1 boardTest.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91D.2 gpio.sh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95D.3 demoLed.sh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97D.4 demoSwitch.sh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98D.5 simon.sh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99D.6 uebungAusgabe.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102D.7 uebungEingabe.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103D.8 binaryCounter.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104D.9 lm75b.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105D.10 uebungI2C.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106D.11 mcp3002.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108D.12 mcp3002lib.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109D.13 uebungSPI.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109D.14 wpi.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110D.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 imHobby und Freizeit Bereich. Andere Firmen entdeckten die potenziellen Möglichkeitendes 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, dasssie 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 einerLichtschranke für die Eingabe, und einer LED, einem Display oder eines Motors fürdie Ausgabe sein. Da durch verschiedene Frameworks und Libraries diese Schnittstel-len nicht nur mittels spezieller Kommandos bedient werden können, sondern auch inStandardsprachen wie z.B. Bash, C, Java oder Python verfügbar sind, ergibt sich damitdie 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, umStudenten konkrete Lerninhalte leichter zu vermitteln. Dies beinhaltet die Evaluationdes geeigneten Produktes aus der Vielzahl der konkurrierenden Systeme, die korrekteInstallation und Konfiguration sowie die konkrete Nutzung in verschiedenen Projektenmit 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, wodurchauch die Lehre im Bereich Hardware naher Anwendungen, wie z.B. dem Inter-IntegratedCircuit (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), „Mathematik1-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 dasvon Texas Instruments vorgestellte BeagleBone Black. Nachfolgend werden die beidenPlattformen mit ihren Vor- und Nachteilen verglichen und auf die besondere Eignungim 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 einen700 MHz starken ARM1176JZFS (ARM11/ARMv6) Prozessor beinhaltet sowie die 24GFlops 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 Audiound Cinch Video Ausgang (über ein Adapterkabel). Insgesamt stehen 40 GPIO Pins zurVerfü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 Filternversehen werden. Weiterhin kann die GPU auch in begrenztem Umfang zur Beschleu-nigung von eigenem Programmcode verwendet werden. Eine Micro SD Karte dient alsMassenspeicher und die Stromversorgung erfolgt mittels Micro USB Netzteil.

Als Betriebssystem kommt hauptsächlich Raspbian, eine für den ARMv6 optimierteVersion von Debian zum Einsatz. Weiterhin sind Versionen von Arch Linux (Arch), Fe-dora (Pidora), XBMC (XBian, OpenElec, Raspbmc), RiscOS, Android und zahlreichenanderen Betriebssystemen zum Download verfügbar. Die Verwendung des Echtzeitbe-triebssystems QNX ist allerdings wegen des fehlenden Board Support Packages nichtmöglich.

Die Entwicklung des Einplatinen Computers wurde von Eben Upton geleitet. DieIdee zu diesem Projekt kam ihm während seiner Zeit als Director of Studies in Compu-

3


ter Science am St John’s College (Universität Cambridge). Er stellte mit seinen Kollegenfest, dass die Anzahl der Studienbewerber im Bereich der Informatik seit dem Beginndes 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 desBBC 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ährendseiner Zeit an der Universität Cambridge entworfen, das Projekt aber schnell einge-stellt.

Im gleichen Jahr wechselte Eben Upton zum Chiphersteller Broadcom und arbeiteteam 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 bewogUpton die Arbeit am Raspberry Pi wiederaufzunehmen. Er befürchtete dass der BBCMicro Klone bei der heutigen, mit Facebook und anderen grafischen Anwendungenvertrauten Jugend keinen Anklang finden könnte - ein Computer mit dem BCM2835hingegen 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 Fortbildungvon Kindern und Jugendlichen in den sogenannten MINT Fächern erstellte. Damit gingder erste Raspberry Pi im Februar 2012 in den Verkauf und wurde seither mehr als 3Millionen 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 Dollarteuren, 600 MHz schnellen Cortex-A8 Linux Boards begannen. Alle diese Entwick-lungsboards haben die Gemeinsamkeit, dass sie von Texas Instruments Entwicklernentwickelt wurden und jeweils als SoC den aktuellen Kern aus dem Portfolio der ge-nanten Firma beinhalteten. Der aktuelle BeagleBone Black (53 e) verwendet ein TexasInstruments 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 HDMIPort. 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 demOnboard 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 GBeMMC Flashspeicher oder eine Micro SD Karte. Die Stromversorgung erfolgt über denUSB 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 mit200 MHz getaktet sind und unabhängig von der ARM CPU funktionieren. Diese 32bit Microcontroller sind mit hoher Bandbreite, sowohl an den eigenen, als auch an denArbeitsspeicher 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 BeagleBoneBlack 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 zurVerwendung im Bereich der Lehre geeignet zu sein, jedoch gibt es bei genauerer Be-trachtung einige wesentliche Unterschiede. Der größte und wesentliche, welcher sichsowohl im Design der Hardware, Software und verfügbaren Materialien widerspie-gelt, ist die angepeilte Zielgruppe. Während der Raspberry Pi von Anfang an daraufausgelegt war im Bereich der Lehre verwendet zu werden und erst später aufgrunddes günstigen Preises von Hobbyisten und der Industrie aufgegriffen wurde, war dasBeagleBone Black als ein Entwicklungs- und Demoboard für das entsprechende, freizu erwerbenden SoC gedacht: Beide Hersteller haben die Baupläne ihres Produktesoffengelegt, 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 BeagleBoneBlack 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 undAudioanschlü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 wenigum 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 Bereichder Hardware, sondern auch der Software: Während der Raspberry Pi mit einer Füllevon Entwicklungswerkzeugen und Software (Python, Mathematica, Scratch, Verweisauf Unterrichtsmaterialien uvm.) vorinstalliert kommt, verfügt der BeagleBone Blackneben verschiedenen Systemprogrammen ausschließlich über einen Texteditor, Termi-nal, File Browser, Chrome sowie ein IRC Chat Tool. Zusammengefasst lässt sich alsofesthalten, dass der BeagleBone Black sicherlich ein gutes Werkzeug für die industrielleEntwicklung 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 bedingtgeeignet ist. Nicht zuletzt auch wegen des mehr als anderthalbfach so hohen Preisesund der bestehenden Lieferengpässe (Juli 2014), wurde der Raspberry Pi als Basis fürdie folgende Arbeit gewählt.

5


Tabelle 2.1: Übersicht [6]

Raspberry Pi Modell B+ BeagleBone Black Rev. C

SoC Broadcom BCM2835 Texas Instruments AM3358CPU ARM1176 / ARMv6 ARM Cortex-A8 / ARMv7

700 MHz, Hardware FPU 1 GHz, Hardware FPURAM 512 MB 512 MBGPU Broadcom VideoCore IV PowerVR SGX530

24 GFlops 1,6 GFlopsInt. Speicher - 4 GBExt. Speicher Micro SD Micro SD

Netzwerk 10/100 Mbit 10/100 MbitStromversorgung 5 V @ 2 A USB Micro 5 V @ 1 A USB Mini

5V @ 2.1mm SteckerAbmessungen 85.6 mm x 56 mm 86.4 mm x 53,3 mm

Gewicht 45 g 40 gPreis 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,3VAnaloge Eingänge - 7 @ 12-bit ADC (0-1,8V)

PWM Ausgänge 2 8Serial 1 4

SPI 2 2I2C 1 2

USB Host 4 USB A Anschlüsse 1 USB A AnschlussUSB Client - 1 Mini B Anschluss

Video Eingang CSI -Video Ausgang HDMI, Cinch, DSI Micro HDMIAudio Ausgang HDMI, Analog Micro HDMI

Stromversorgung 3,3V @ 50 mA, 5V @ 1,2 A 3,3V @ 250 mA, 5V @ 1 ABesonderheiten - 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 derHardware Anteil dieser Bachelor Thesis mit diesem Raspberry Pi durchgeführt wurde.Das neuste Modell, welches zukünftig als Standard dienen soll, ist der Raspberry PiModell 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 derPlatinen. Das Modell A verfügt mit 256 MB nur über die Hälfte des Arbeitsspeichersdes 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 Preisauf 25 e reduziert. Besonders für mobile Anwendungen ist dieses Modell daher sehrgeeignet.

2.2.2 Modell B pre 2.0

Das Modell B in der Version pre 2.0 war der erste erschiene Raspberry Pi im Februar2012 und verfügte über 256 MB Arbeitsspeicher, da für das Modell A ursprünglich 128MB 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. wenigePins inklusive des I2C Bus auf der GPIO Leiste um rangiert. Zum ersten Mal gab esauch 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. DasCompute Module wurde daher im Format eines DDR2 SODIMM Riegels entworfen,und lässt sich damit leicht und platzsparend integrieren. Zusätzlich zu dem ComputeModule 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, konntedie 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 undDSI Systeme, was das Modul zur Anbindung von zwei speziellen Displays, sowie dem

7


Einsatz im Bereich von stereoskopischen Kameraanwendungen befähigte. Das Compu-te Module verwendet, ähnlich wie der BeagleBone Black (Rev. C), einen 4 GB großeneMMC Flashspeicher.

2.2.5 Modell A+/B+

Das Modell B+ wurde im Juli 2014 vorgestellt und beinhaltete einige Verbesserungenim Vergleich zur Revision 2.0. So verfügt der Raspberry Pi über eine neue, energie-sparendere Stromversorgung, einen rauschärmeren analogen Audioausgang, vier stattzwei USB Ports sowie anstatt der bisherigen 26, 40 GPIO Pins. Von diesen 40 Pins sind28 (vorher 17) für eigene Projekte nutzbar, beim Rest handelt es sich um verschiedeneSpannungsschienen (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 Aherauszubringen, 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 Pigelegt. Dies umfasst das benötigte Zubehör zum Betrieb, sowie die Vorbereitung derSD Karte mittels der noobs Software beziehungsweise eines Images. Am Ende diesesKapitels 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 einenhandelsüblichen Personal Computer anzuschließen. Neben dem Raspberry Pi ist dazufolgende 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. kanndiese 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 wenigPlatz 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ßeProbleme bei der Verwendung von SD Karten unbekannterer Hersteller. Diese Proble-me sind zum jetzigen Zeitpunkt fast ausgeschlossen, jedoch empfiehlt es sich dennochweiterhin aus Gründen der Datensicherheit in das Produkt eines Markenherstellers zuinvestieren. Die Class beschreibt die Geschwindigkeitseinstufung einer SD Karte. Eine

9


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 entsprechendemAdapter 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,2Ampere 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 zudieser maximalen Grenzen an angeschlossene Verbraucher weitergeben. Da besondersgü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 oderhöher. Zu niedrige Versorgungsleistung kann sich in Schreib- / Lesefehlern bei der SDKarte, 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 vierUSB Ports empfiehlt sich allerdings die Verwendung eines Netzteils mit mindestens 2Ampere Leistung, da die 1,1 Ampere Polyfuse durch eine 2 Ampere Polyfuse ersetztwurde.

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 Routernwie z.B. einer Fritz!Box Standard. Bei Firmen- oder Universitätsnetzwerken könnenweitere 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, empfiehltes 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 auchdirekt 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ürMultimedia Anwendungen macht. Bei der Verwendung des DVI Eingangs muss dasAudiosignal zusätzlich vom Raspberry Pi mittels 3,5 mm Klinkekabels abgegriffen undz.B. zu einem Paar Aktivboxen weitergeleitet werden. Sollten weder DVI noch HDMIkompatible Displays verfügbar sein, könnte man im letzten Schritt über die ChinchBuchse 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) miteiner 1,1 Ampere Polyfuse abgesichert ist [20] (S.1, oben, F1), welches den gesamtenRaspberry Pi versorgt wird schnell klar, dass die beiden USB Ports nicht wie sonst 500mA 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 zumeinen die Anzahl der verfügbaren USB Anschlüsse zu erhöhen und zum anderen auchGerä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, dieProblematik 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 WindowsRechner mit SD Karten Lesegerät und Internetzugriff vorausgesetzt um die SD Kartevorzubereiten.

3.2 Anschluss des Raspberry Pi

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

3.3 Raspbian

Das bereits erwähnte Raspbian ist die Standard Distribution für den Raspberry Pi. Eshandelt sich dabei um ein Debian Derivat, welches den Anforderungen und der Archi-tektur des ARMv6 Prozessors des Einplatinen Computers angepasst wurde. Zusätzlichzu 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 derEinführung des noobs Systems weiterhin beliebt. Dies ist darin begründet, dass dieseArt der Installation relativ schnell funktioniert. Weiterhin lassen sich auf gleichem WegBackups von vorhandenen Installationen erstellen und wiederherstellen. Zu guter Letztist es auch für weniger bekannte Distributionen ohne Integration in noobs die einzigeMöglichkeit diese für die Nutzung auf dem Raspberry Pi vorzubereiten.

11


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 perdirektem 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 wirddas 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 GBgroß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 inden 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 undleeren SD Karte nicht notwendig, da die Karte im nächsten Schritt bitweise überschrie-ben wird. Beim Überschreiben werden normalerweise zwei Partitionen angelegt: EineFAT32 Partition wie man sie auch bei USB Sticks kennt, sowie eine EXT Partition un-terschiedlicher Version. Das EXT Dateisystem entstammt dem Linux Bereich und istunter 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, FAT32formatierter USB Stick im Dateisystem. Durch die Formatierung kann das ursprüngli-che Format wiederhergestellt und anschließend mit der vollen Größe auch ein Imagewieder 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 kanndieses Tool kostenlos unter https://www.sdcard.org/downloads/formatter_4/ per Klickauf „Download SD Formatter for Windows“ herunterladen. Nachdem man die EULAangenommen hat, startet der Download der wenigen MB großen ZIP Datei. Sobaldman die enthaltene Setup Datei entpackt und das Tool installiert hat, startet man dieseseinfach.

Das Tool selbst ist relativ einfach gehalten: Unter „Drive“ wählt man das korrekteLaufwerk 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, undnicht versehentlich einen USB Stick mit wichtigen Daten. Bevor man allerdings denVorgang startet, sollte man unter „Option“ noch eine Anpassung vornehmen.

In jedem Fall, besonders bei der Vorbereitung einer SD Karte für die Verwendung vonnoobs, sollte man hier das „Format Size Adjustment“ auf „On“ stellen und den Dialogper Klick auf „OK“ verlassen, sowie die Formatierung per Klick auf „Format“ starten.

12

http://www.raspberrypi.org/downloads/


http://www.7-zip.org/

https://www.sdcard.org/downloads/formatter_4/

3.4 Installation mittels Image

Abbildung 3.1: SD Formatter

Abbildung 3.2: SD Formatter Optionen

13


Nachdem zwei weitere Sicherheitsabfragen bestätigt wurden, beginnt der Vorgang undendet mit einer Übersicht über die tatsächliche Größe der SD Karte. Der Vorgang istdamit 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 Werkzeugkann man unter der URL http://sourceforge.net/projects/win32diskimager/ perKlick 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 achtendie SD Karte und nicht einen anderen Wechseldatenträger, wie z.B. einen USB Stickauszuwä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 aufden 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 Sicherheitsabfrageder Schreibvorgang. Nach Abschluss des selbigen kann die SD Karte ausgeworfen, ausdem Lesegerät entfernt und in den Raspberry Pi eingesetzt werden. Dies schließt dasKopieren des Raspbian Image auf die SD Karte ab. Der Raspberry Pi kann nun an dieStromversorgung 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 verwendetwerden, Backups einer bestehenden Raspbian Installation anzufertigen, bzw diese Wie-derherzustellen.

14

http://sourceforge.net/projects/win32diskimager/

3.5 Installation mittels noobs

Wollen wir ein Backup erstellen, so setzen wir die SD Karte in das Lesegerät ein undstarten 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 Klickauf 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 wiederhergestelltwerden.

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 SDKarte wie unter 3.4.3 beschrieben.


Um den Einstieg in die Welt des Raspberry Pi zu vereinfachen erfand die Raspberry PiFoundation die sogenannte noobs oder New Out Of Box Software. Es handelt sich dabeium einen Installationsassistenten welcher, nachdem er auf der SD Karte installiert wur-de, den Boot des Raspberry Pi und dort die Auswahl des gewünschten Betriebssystemserlaubt. 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 demRaspberry Pi zu einer echten „Plug and Play“ Lösung zu machen. Sollte der Installerjedoch 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 Einrichtungund 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 vonder Raspberry Pi Website heruntergeladen werden. Dazu navigieren wir zu http://

www.raspberrypi.org/downloads/ und wechseln zum Eintrag „noobs“. Die New OutOf 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 OfflineInstallation 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 umdie 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




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 derDatei- und Ordnerstruktur. Auch hierbei wird empfohlen einen bewährten Entpackerwie 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 RaspberryPi 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 dieMöglichkeit gibt, zum einen die Sprachoptionen und Tastatureinstellungen zu ändern,sowie zum anderen ein Betriebssystem zur Installation auszuwählen und den Prozesszu 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 Installationdie 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

http://www.7-zip.org/


Abbildung 3.5: Installation von Raspbian unter noobs

übernommen werden, zum anderen aber auch darin, dass man jederzeit beim Bootendes 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 denEinsatz eines PCs andere Betriebssysteme zu installieren. Weiterhin ermöglicht noobsdie gleichzeitige Installation mehrerer Betriebssysteme auf einer SD Karte und dientals Bootmanager.

17

4 Konfiguration von Raspbian

Nachdem der Raspberry Pi im letzten Kapitel zum ersten Mal in Betrieb genommenwurde, muss nun die Grundkonfiguration erfolgen. Dies bedeutet zum Beispiel dasTastaturlayout, 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 werdenalle notwendigen Vorbereitung zur Nutzung der GPIO Schnittstelle in verschiedenenProgrammiersprachen 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 Nutzereingerichtet 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 kannman 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 aufder 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 headlessInstallation 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 indiesem Werkzeug z.B. die Verteilung des gemeinsam von CPU und GPU genutztenRAMs ä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

http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html

http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html



Abbildung 4.1: raspi-config

fehlerhaft konfigurierten Übertaktungseinstellungen möglich. Im Normalfall empfiehltsich 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 PunktA3 Memory Split den Anteil der Grafikkarte am Gesamtarbeitsspeicher des RPi festle-gen. Im Normalfall reicht die Standardeinstellung von 64 MB. Bei sogennaten HeadlessKonfigurationen, 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 RPiim Netzwerk kann unter A2 Hostname festgelegt werden. Es empfiehlt sich dort einensprechenden 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 eineLeistungssteigerung zu erhalten. Die einzigen beiden sinnvollen Parameter sind dabeiNone 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 CPUGeschwindigkeit von 700 MHz auf 1 GHz. Dennoch bleibt bei der Nutzung der TurboEinstellung die Garantie erhalten, da die CPU automatisch diese Übertaktung zurück-regelt, sobald die Temperatur der CPU 85 Grad Celsius erreicht [23]. Diese Einstellungist 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 aktiviertwerden. 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 undunsere Sprache um. Wir beginnen mit I1 Change Locale und wählen im erscheinendenMenü den Punkt [*] de_DE.UTF-8 UTF-8 aus, bestätigen die Wahl und beantworten dieFrage nach dem Default locale mit de_DE.UTF-8. Nun werden die Standortparametererstellt, was einen kurzen Moment dauern kann.

Als nächstes ändern wir die Zeitzone unter dem Punkt I2 Change Timezone in dem wirzuerst als Geographic area Europe und dann als Timezone Berlin angeben. Der RaspberryPi bezieht sich seine Zeitinformationen per NTP über das Netzwerk und stellt die Uhrdirekt korrekt ein.

Abschließend muss die Einstellung der Tastatur auf das deutsche Schema angepasstwerden. 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 desStandardnutzers 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 vonFinish im Hauptmenü beenden wir raspi-config und beantworten die Frage nach demgewünschten Reboot mit Yes. Mit dem Neustart wird das Dateisystem angepasst undder Raspberry Pi bootet schließlich zur grafischen Benutzeroberfläche, dem Desktop.

21


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_Adaptersgefunden werden. Anschließend kann unter Nutzung des Wifi Config Tools des RPiunter dem Punkt „Manage Networks“ und „Add“ das WLAN eduroam hinzugefügtwerden:

Tabelle 4.1: Einstellungen für eduroam

Einstellung Wert

SSID eduroamAuthentication WPA2-Enterprise (EAP)

Encryption CCMPEAP method PEAP

Identity [email protected] Passwort

CA certificate /etc/wpa_supplicant/deutsche-telekom-root-ca-2.crtInner auth EAP-MSCHAPV2

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

22

http://elinux.org/RPi_USB_Wi-Fi_Adapters

4.3 Updates

4.3 Updates

Nachdem wir nun die Grundkonfiguration des Raspberry Pi durchgeführt haben, ist eszwingend erforderlich, zum einen die neuste Firmware wie auch Software Updates zuinstallieren 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 sowieden benötigten Modulen für den Kernel. Sobald der Raspberry Pi mit Strom versorgtwird sucht die GPU automatisch auf der FAT32 Partition der SD Karte nach einempassenden 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 profitierenkann. Die aktuelle Kernelversion kann man sich mit dem Kommando uname -a anzei-gen lassen. Dazu verwenden wir das Tool LXTerminal welches in der oberen, linkenEcke 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 inwichtige Bereiche des Linux Betriebssystems eingreift, zu welchen unser Standardnut-zer pi keinen Zugriff hätte, müssen wir das Kommando sudo vorstellen. Durch diesesKommando wird der nachfolgende Befehl (hier: rpi-update) mit den Rechten des LinuxAdministrators, 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


*** 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 AbmeldenSchaltfläche, den Shutdown Icon auf dem Desktop oder mittels Kommandozeile überdie Befehle sudo shutdown -h now zum herunterfahren oder sudo shutdown -r now zumneustarten. 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 undanderen Abhängigkeiten enthalten. Der Paket Manager selbst verwaltet die Installati-on sowie die benötigten Grundlagen / Abhängigkeiten um die gewünschte Softwareauf dem Rechner zu betreiben. Weiterhin können über den Paket Manager nicht nurSoftware 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 sichder Paket Manager die aktuellen Paketlisten herunter um zu wissen, welche Softwarein 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 berechnetdie 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 derRaspberry 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 Aufgabenzu erfüllen. Einige dieser Pins verfügen noch über spezielle Alternativfunktionen, wiez.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 dieseSchnittstellen und Funktionen also für eigene Projekte verwenden möchte, muss mansie 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 einUpdate 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 Blacklistentfernen. Die Blacklist verhindert dass diese Module beim Start geladen und damit

25


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 undkommentieren die beiden blacklist Befehle für die Module spi-bcm2708 und i2c-bcm2708mittels 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 letztenEintrag 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 entsprechendenLinux Gruppen hinzufügen, damit er die Berechtigung zur Nutzung dieser Diensteerhält. Standardmäßig sind die Berechtigungen für die SPI und GPIO Gruppe schonerteilt ( groups pi zeigt die zugeteilten Gruppen an). Daher müssen wir nur noch mitdem 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 genutztwird, 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 Konsolevon 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 nacheinem Neustart des RPi aktiv.


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 Hardwareund weiteren, spezialisierten Libraries für unterschiedliche Programmiersprachen wiePython 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 installiertwird. Dies kann einige Minuten dauern. Nach dem Abschluss des Vorgangs kann manals ersten Test mit dem Kommando gpio -v Informationen über die Software, sowieden 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

https://github.com/lurch/rpi-serial-console

https://github.com/lurch/rpi-serial-console

http://wiringpi.com/


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

https://github.com/Gadgetoid/WiringPi2-Python


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 lassenuns die Revision des Boards ausgeben wiringpi2.piBoardRev(). Als Ausgabe erhaltenwir 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, kompiliertund 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 Testerfolgreich:

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 Nutzungdes 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 Sicherheitshinweiseim 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 entwickeltwurde, 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 RaspberryPi von einem normalen PC unterscheidet. Durch diese Anschlüsse kann der RPi mitzahlreichen Sensoren, Aktoren und Schaltern verbunden werden, um eine Vielzahl vonEinsatzzwecken 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 einigerPins erwähnt und diese auch für die spätere Nutzung aktiviert. Bevor wir uns aller-

31


dings näher mit den Pins und deren Funktion beschäftigten, müssen wir uns zuerst mitden 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 dieinterne 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 Verwendungvon Spannungen im Bereich von 1,8 Volt, 3,3 Volt und 5 Volt üblich. Im Unterschiedzu z.B. dem Arduino ist der Raspberry Pi allerdings keines Falls 5 Volt tolerant, wasbedeutet, dass niemals mehr als 3,3 Volt direkt an einen der GPIO Pins angelegt werdendü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 gegenVerpolung, Kurzschluss oder Überspannung. Daher sollten Änderungen an den GPIOPins 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 jederder 17 Pins mit 3 mA belastet werden konnte, was eine Gesamtbelastbarkeit von 51mA ergibt. Allerdings bezieht sich diese Bewertung nur darauf, wenn alle Pins genutztwerden. Prinzipiell ist jeder Pin in der Lage bis zu 16 mA belastet zu werden - solangedie feste Gesamtlast 51 mA nicht überschreitet, weil sonst Schäden an der Hardwareauftreten können [16].

Diese Zahlen beziehen sich ausschließlich auf die Raspberry Pi Modelle A und B, dasneue Modell B+ erhielt eine neue Spannungsversorgung und stellt weitere GPIO Pinszur 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 dieBelastbarkeit durch die Differenz aus der Beschränkung der Polyfuse und dem Eigen-bedarf des Raspberry Pi, sowie weiterer angeschlossener Geräte zu errechnen. BeimRaspberry 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 - mehrals 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 derentsprechende GPIO Pin exportiert, also für die Nutzung im Linux Userspace vorbe-reitet werden. Anschließend muss die Art der Verwendung angegeben werden, alsoob der Pin zur Ein- oder Ausgabe dienen soll. Abschließend kann der Status des Pinsausgelesen, 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


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


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

Die Verwendung mit dem Tool gpio geht noch etwas einfacher und benötigt keineroot 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


gpio unexport 24

# Pin 27 exportieren und als Eingabe festlegen

gpio export 27 in

# Pin 27 auslesen

gpio -g read 27


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 derBegriff „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ührtder 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% aufbis 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 istbei dem Raspberry Pi auf dem GPIO 18 verfügbar. Aufgrund der besonderen Technik(prinzipiell dem schnellen, kontrollierten Ein- / Ausschalten des Pins) ist eine sinnvolleNutzung mittels echo Befehls nicht gegeben. Allerdings kann auch in diesem Fall dasProgramm 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


gpio -g pwm 18 256


gpio -g pwm 18 102


gpio -g pwm 18 10


gpio -g pwm 18 0


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 nebender Versorgungsspannung und Masse nur zwei Leitungen (SDA für Daten, SCL fürTakt) benötigt wird es auch als Two Wire Interface (TWI) bezeichnet. SDA wie SCL müs-sen durch einen hochohmigen Widerstand an die Versorgungsspannung angeschlossenwerden, 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 denSCL Port und fragt die einzelnen Slaves, meist simple Sensoren oder Signalwandler,unter Verwendung des SDA Ports ab. Es ist allerdings auch möglich Master-MasterNetzwerke 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 derBus 0 auf dem GPIO Header ausgeführt. Mit dem Wechsel zur Revision 2.0 wanderteder Bus 0 auf ein zusätzliches Verbindungsfeld (P5) und auf dem GPIO Header lagnun der Bus 1 an. Beim Modell B+ änderte sich dieser Zustand dahingehend, dass derHeader P5 wieder entfiel, der Bus 1 weiterhin auf seiner Stelle auf dem GPIO Headerverblieb und der Bus 0 fortan als ID_I2C geführt wurde und für die Nutzung durch denAnwender nicht mehr verfügbar war.

Der I2CBus auf dem Raspberry Pi arbeitet in der Standard Geschwindigkeit (100kHz) und im Fast-Mode (400 kHz). Theoretisch kann ein I2C Bus bis zu 127 Teilneh-

35


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 dezimalSystem einer Temperatur von 35 Grad Celsius entspricht.

5.3.4 I2S

Nach dem Erfolg von I2C folgte 1986 Philips Erweiterung I2S. Dabei handelt es sichum ein Bussystem, welches ausschließlich zur Verwendung innerhalb von Audiogerä-ten vorgesehen war. Es wurden hierbei wieder ein Takt Signal (SCK) und ein DatenSignal (SD) verwendet, zusätzlich wurden diese beiden Leitungen allerdings noch umeine sogenannte Word Select (WS) Leitung ergänzt. Je nachdem ob sich Word Selectim 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 SignalProzessoren und Digital/Analog Wandlern geeignet.

Beim Raspberry Pi ist der I2S Bus bei der Revision pre 2.0 nicht vorhanden, bei derRevision 2.0 auf dem Header P5 zu finden und bei dem Modell B+ auf dem GPIOHeader. [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 Gegensatzzum I2C Bus von Philips wurde er nicht getrennt formal beschrieben, sondern ist nurvage in den Unterlagen des Controllers als Teil dessen definiert [15]. Das SPI Systemverwendet 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ätzlichmuss 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 Empfangsbereitschaftzu 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 derSternverbindung. Sollte man kompatible Slave Geräte gleicher Bauart verwenden, sokö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 dieGPIO Leiste ausgeführt. Der Controller kann auf 0.5 MHz, 1 MHz, 2 MHz, 4 MHz, 8MHz, 16 MHz und 32 MHz Taktrate eingestellt werden [13]. Die maximal verwendbareTaktrate 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, wasden 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 nimmtdieses 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ängerhergestellt und die beiden Datenadern überkreuzt angeschlossen werden, also RX desSenders 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ängernund 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 einensogenannten TTL Pegel (Transistor-Transistor Logic) ein, welcher zwischen 0 Volt und3,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 Nutzungeines TTL-Serial Konverters ist diese Verbindung gefahrlos möglich.

37


Auf dem Raspberry Pi kann die serielle Schnittstelle auf verschiedene Arten genutztwerden. Zum einen um einen GPS Empfänger anzuschließen, einen Mikrocontrollermit 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 wiemöglich zu machen, wurde im Rahmen dieser Thesis ein Erweiterungsboard entworfenund zur Verwendung im Rahmen der Lehre der HTW Saar in zehnfacher Stückzahlaufgebaut.

5.4.1 Design

Das Design sollte so ausgelegt sein, dass es möglichst klein, kostengünstig und dennochvielseitig verwendbar sein sollte. Durch die Entwicklung des Boards sollten besondersFehler 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 zumZeitpunkt des Beginns dieser Thesis der Raspberry Pi Modell B+ noch nicht verfügbarwar, wurde die Platine auf Basis des Modell A/B Rev. 2.0 entwickelt und ist auf beidenVersionen ohne Einschränkungen verwendbar. Ebenfalls ist die Nutzung mit dem neu-en Modell B+ möglich, wobei allerdings keine korrekte mechanische Entlastung wie beiden 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 LightDependent Resistor (LDR)

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

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


North

South

East

West

MCP3002

LM75B

Bauteil Bemerkung GPIO

LED North grün, PWM 18LED East rot 23

LED West gelb 25LED South blau 24

Switch North Pull-Down 4Switch East Pull-Down 17

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

LM75B SDA 2SCL 3

MCP3002 MOSI 10MISO 9SCLK 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 zudemonstrieren.

Die LEDs selbst werden nicht direkt von den GPIO Pins versorgt, sondern schalteneinen Transistor, welche wiederum die Schaltlast übernimmt und die LEDs mit 5 VoltSpannung 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 einenstets 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 i2cgeterhä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 eineAuflö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. Dazukommen wir in einem späteren Kapitel.

Der erwähnte Lichtsensor (LDR) verhält sich wie ein Widerstand und erreicht je nacheinfallendem Licht Werte zwischen 40,5 k und 1 M Ohm. Da der Raspberry Pi allerdings

39


über keinen Analog/Digital Wandler verfügt um z.B. eine Spannungsmessung durch-zuführen, wird der an einem MCP3002 angeschlossen, einem externen Analog DigitalConverter (ADC) welcher über SPI angesprochen wird.

Insgesamt bleiben damit ausschließlich die GPIO Pins 14 und 15 (TX/RX der SerialVerbindung) 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 bereitvorher installierte wiringpi2 Library, um die unterschiedlichen Funktionen des Erwei-terungsboards auf Funktionalität zu überprüfen. Dazu gehören die LEDs, die PWMFunktionalität, die Schalter wie auch der I2C Bus mit dem angeschlossenen LM75BTemperatursensor und dem SPI Bus mit dem MCP3002 ADC Wandler. Letzterer gibtauf Kanal 0 den Helligkeitswert des angeschlossenen LDR wieder. Um es zu nutzenmuss es zuerst kompiliert werden, was der Aufruf von make erledigt. Anschließendkann 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





40







LM75B Temperatursensor Test beendet

MCP3002 ADC Test beginnt

MCP3002 - Channel 0: 232










MCP3002 ADC Test beendet

Die boardTest.c ist im Anhang D.1 verzeichnet. Sollte ein eigenes Programm ohne diemake 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 derBash anhand eines Beispielprojektes aufgezeigt werden: Ziel wird es sein, einen Klondes 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 desTexas Instruments TMS1000 Mikrocontrollers [18]. Simon verfügt über vier LEDs (grün,rot, blau, gelb) und entsprechend, den Farben zugewiesene Taster. Das Spiel beginnt indem 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ächstenRunde die Farbe des ersten Zyklus plus eine weitere Farbe vorgegeben, welcher derSpieler wieder in der richtigen Reihenfolge eingeben muss. Das Spiel endet falls derSpieler eine falsche Kombination eingibt.

Abbildung 6.1: Simon

43


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 beimEnde 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 denbenötigten Schaltern. Um die Entwicklung zu vereinfachen steht die gpio.sh im AnhangD.2 zur Verfügung, welche die benötigten Funktionen zur Nutzung der an die GPIOPins angeschlossenen LEDs und Schalter bereitstellt. Für jede LED existiert jeweils ei-ne Funktion, um diese ein-, beziehungsweise auszuschalten. Für die Schalter gibt esjeweils 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. Dieletzteren beiden lassen jeweils alle LEDs einmal mit einem Abstand von 0,5, respekti-ve 0,25 Sekunden aufblinken. In den nachfolgenden beiden Unterkapiteln werden wirdiese Funktionen nutzen.

45


6.2.2 LED Ausgabe

Um eine LED per Bash anzusteuern, können wir unter Verwendung der gpio.sh folgen-des Skript erstellen:

#!/bin/bashsource 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 Pausevon zwei Sekunden, damit der sonst zu schnelle Schaltvorgang für das menschlicheAuge 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 desBefehls chmod +x dateiname ausführbar gemacht, und anschließend mittels ./dateinamegestartet.

6.2.3 Switch Eingabe

Die Eingabe ist wie die LED Ausgabe ebenfalls sehr einfach zu bewerkstelligen:


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 Schleifewird ständig geprüft, ob der Schalter North gedrückt wurde. Ist dies der Fall, wird eineentsprechende Nachricht ausgegeben, und die dazu passende LED angeschaltet. Solltedem nicht so sein, wird die LED ausgeschaltet. Es gibt auch die Möglichkeit Pins nichtper polling, also dauerndem Abfragen auf einen Wechsel des Zustandes zu überprüfen,sondern per Interrupt. Dies setzt aber eine höhere Programmiersprache voraus undist daher leider in Bash nicht möglich (siehe dazu: http://wiringpi.com/reference/priority-interrupts-and-threads/).

46

http://wiringpi.com/reference/priority-interrupts-and-threads/

http://wiringpi.com/reference/priority-interrupts-and-threads/

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 Simonmittels 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 gelernthaben, 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ürdie Vorlesung „Systemmanagement und Sicherheit“ liefern, wie auch die praktischeNutzung von Bus Systemen, wie sie in „Rechnerarchitektur“ und „Mikroprozessor-technik“ gelehrt werden verdeutlichen. Am Ende dieses Kapitels werden sowohl dieGrundlagen zur Nutzung von Python gelegt, als auch der I2C, wie auch der SPI Bus, indie 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 Interpreterbenö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 Skriptenbrechen kann. Da die Version 2 bereits länger existiert, viele Bibliotheken nur in dieserVersion funktionieren, und dieser Branch immer noch mit aktuellen Updates versorgtwird, ist Python 2 auch auf dem Raspberry Pi die empfohlene und verwendete Stan-dardversion. Sollten durch den vorzeitigen Abbruch eines Programms LEDs im aktivenZustand 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 desPython Integrated Development Environment (IDE) IDLE. IDLE liegt auf dem RPi inzwei 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 dasnormale IDLE nutzen. Da die Nutzung der GPIO Pins root Rechte erfordert, sollte manIDLE 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 Nutzerszu starten. Die Nutzung selbst ist sehr einfach: Über das Menü File, New Window kannman 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 Klickauf Run Module.

49


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 direktauf Ebene des Command Line Interface (CLI) / der Shell. Dazu sollte man seinen Pro-grammcode mit einem Editor seiner Wahl schreiben, speichern und schließlich direktunter 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 demCLI. 2.) Der direkte Aufruf einer geschriebenen Skriptdatei mittels python dateiname

.py im CLI. 3.) Die Verwendung der Shebang Zeile (#!/usr/bin/python) als erste Zeilein einer Skriptdatei, gefolgt vom setzen des X / Ausführungbarkeits-Bits (./chmod +x

dateiname.py) und dem anschließenden Aufruf im CLI (./dateiname.py). Um Pythonkennen zu lernen empfiehlt sich besonders am Anfang die Arbeit in einer interaktivenShell, 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/pythonmeinInteger =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 0b101 Hex 0x5 �7.2.3 Operatoren

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

50


Tabelle 7.1: Arithmetische Operatoren

Operation Ergebnis Bezeichnung

5 + 5 10 Summe5 - 1 4 Differenz5 * 1 5 Produkt5 / 2 2 Quotient (Integer)

5.0 / 2 2.5 Quotient (Float)5 % 2 1 Modulo2 ** 3 8 Power

Ergebnis ebenfalls ein Integer. Wenn im Rahmen dieser Rechenoperation eine rationaleZahl entsteht, so wird diese abgerundet und als ganze Zahl dargestellt.

Die Vergleichsoperatoren sind ebenfalls bekannt sofern man Vorkenntnisse in Javabesitzt:

Tabelle 7.2: Vergleichsoperatoren

Operation Bezeichnung

x == y Gleichheitx != y Ungleichheitx > y Größerx < y Kleiner

x >= y Größer-gleichx<= y Kleiner-gleich

Da in diesem Dokument mit hardwarenahen Anwendungen gearbeitet wird, ist esauch von Bedeutung die binären, bitweisen Operatoren zu kennen. Dies ist besonderswichtig 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 Biteines 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 beziehungsweiseausgelesen werden. Um einen Wert in binärer Schreibweise eingeben zu können, mussihm der Präfix 0B vorgestellt werden. So würde zum Beispiel die Zahl 0B11110000 vonPython als 240 verstanden werden. Alternativ können die binären, bitweisen Operatio-nen auch mit den Werten in beliebiger anderer, zum Beispiel dezimaler Schreibweiseangewandt werden.

Die vier wichtigsten Operationen, welche auch schon in den Vorlesungen „Digital-

51


technik 1“ und „Mikroprozessortechnik“ gelehrt wurden, sollen an dieser Stelle nocheinmal 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 00 1 01 0 01 1 1

2.) Binäres Oder:Das binäre „Oder“ entspricht der gleichen Wirkungsweise wie „Und“, allerdings wirddie Ausgabe „Wahr“ solange entweder eine oder beide Werte „Wahr“ sind.

Tabelle 7.4: Binäres Oder

x y x | y

0 0 00 1 11 0 11 1 1

3.) Binäres XOR:XOR, welches auch zur Verschlüsselung genutzt wird, erwartet als Voraussetzung füreine „Wahre“ Ausgabe zwei unterschiedliche Eingaben.

Tabelle 7.5: Binäres XOR

x y x ˆ y

0 0 00 1 11 0 11 1 0

52


4.) Binäres 1er Komplement:Das 1er Komplement wird zur Berechnung im Bereich der Mikrocontroller verwendetund negiert alle Eingaben.

Tabelle 7.6: Binäres 1er Komplement

x ˜x

0 11 0

Tabelle 7.7: Binäre, bitweise Operatoren

Operation Ergebnis Bezeichnung

x & y 0000 0001 / 1 Binäres Undx | y 1111 1111 / 255 Binäres Oderx ˆ 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 vonSchleifen oder Befehlsfolgen. Stattdessen verwendet Python Einrückungen wie die Ta-bulator Taste, um den Programmcode zu formatieren und strukturieren. Dies erzeugtsauberen und lesbaren Code, welcher ohne diese Einrückungen nicht lauffähig ist. Imnä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 siekein Teil davon und wird nach der Abarbeitung der Vergleiche aufgerufen.

#!/usr/bin/pythonmeinInteger =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


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) ausgebenfor i in range (0,5):

print(i)

# Äquivalent zur for each# jedes Element einer Liste verwendensprachen = ["Python", "Java", "C", "Haskell"]

for i in sprachen:

print("%s ist eine Programmiersprache" % i)

# jeden Buchstaben eines Strings ausgebenmeinString="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 dieserStelle zwei Algorithmen aus der Vorlesung „Programmierung 1“ [9] verwenden, in die-sem Fall die Berechnung des größten gemeinsamen Teilers.

54


#!/usr/bin/pythonimport timeit

# Importiere die Python Bibliothek timeit zur Laufzeitmessung vonFunktionen

def ggTintuitiv(m, n):

# Definiere die erste Funktion ggTintuitiv , welche die Teiler einzelnprobiertm = 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 nachEuklid verwendetm = 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 einbindenzeit_intuitiv = t_intuitiv.timeit (1)

# Führe die Messung einmal durch und schreibe die vergangene Zeit indie Variable

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

import ggTeuklid")

zeit_euklid = t_euklid.timeit (1)

print("Inuitiv : " + str('{:.2f}'.format(zeit_intuitiv)) + "

Sekunden")

print("Euklid : " + str('{:.10f}'.format(zeit_euklid)) + " Sekunden

")

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

)) + "x schneller")

55


# Berechne wie vielfach Euklid schneller ist , wandle den Float in einenString 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 starkbeanspruchen und wie massiv der Unterschied zwischen beiden Implementationen inder Laufzeit aussieht:

Inuitiv : 28.54 Sekunden

Euklid : 0.0000569820 Sekunden

Euklid ist : 500789.60x 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.6und GNU C++) gegenüberstellt:

Tabelle 7.8: Laufzeiten beider Algorithmen in Sekunden

RPi Python i7 Java i7 C++

ggTintuitiv 28,54 0,163 0,043ggTeuklid 0.0000569820 0,00000011 0,00000016

Wie man erkennen kann bleibt die effiziente Implementierung nach Euklid auch aufdem 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 istund unabhängig von der verwendeten Programmiersprache zum guten Stil gehörensollte.

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 auchin anderen Sprachen dazu genutzt werden, den Funktionsumfang zu erweitern. InPython werden Bibliotheken normal durch die Verwendung von import, gefolgt vomBibliotheksname 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 wirdnur das Modul sleep aus der Bibliothek time eingebunden. Um einer doppelten Nutzungdes gleichen Namespaces vorzubeugen, kann man Module und Bibliotheken auch beimImport mittels as umbenennen: So kann nach dem Import mit import time as zeit dasModul sleep unter Verwendung von zeit.sleep() aufgerufen werden.

56

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. WiringPiReferenz (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




#!/usr/bin/pythonimport wiringpi2 as wpi

# Importiere die Python Bibliothek wiringpi2 unter# dem Namen wpi zur Nutzung der GPIOfrom time import sleep

# Importiere das Modul sleep aus der# Python Bibliothek timewpi.wiringPiSetupGpio ()

# Initialisiert die Bibliothek unter Nutzung des# BCM GPIO Namenschemawpi.pinMode (18,1)

# Definiert den Port der gruenen LED als Ausgabewpi.digitalWrite (18,1)

# Setzt den Port der gruenen LED auf HIGHsleep (0.5)

# Wartet eine halbe Sekundewpi.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

https://projects.drogon.net/raspberry-pi/wiringpi/functions/

http://wiringpi.com/reference/


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 umalle LEDs, beginnend mit der Grünen, im Uhrzeigersinn einzuschalten. Anschließendsollen, 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 digitalenEingabe zu. Wir beginnen mit der Auflistung der Schalter auf dem Erweiterungsboard:

Tabelle 7.10: Schalter auf dem Erweiterungsboard





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 einerendlos 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


Weiterhin sollen die LEDs nicht dauerhaft an- oder ausgeschaltet werden, sondern injedem Zyklus einmal kurz aufblinken. Zwischen jeder LED soll eine Pause von einerhalben 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 solldie LED zweimal kurz aufblinken, die Pause zwischen dem aufleuchten der einzelnenLEDs um den Wert 0.05 reduziert, die aktuelle Rundenanzahl ausgegeben werden unddas 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, fallsman 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ßerteSchalter (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ählerauf 0 zurücksetzen soll. Das Programm soll bis zu 15 zählen und danach wieder zu 0umbrechen und von vorne zu zählen beginnen. Die LEDs sollen bei diesem Projekt dieAusgabe der Zahl in binärer Notation ermöglichen. Dabei ist jede LED als eine Stelleeiner vierstelligen, binären Notation zu verstehen:

2³

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 denWert über die Konsole in den Formen Dezimal, Binär und Hexadezimal ausgeben.


59


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 demRaspberry 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 Anwendungszweckemehrere Geräte einer Art erfordern könnten (zum Beispiel mehrere LM75B in einemBus, um die Temperatur an verschiedenen Punkten eines Raumes zu überwachen), ha-ben viele Hersteller die Möglichkeit mitgegeben, die Adresse ihres I2C Gerätes durchAdressanschlü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 jenach unterschiedlichen Verbindungen mit „HIGH“ (3,3V) und „LOW“ (Ground) bis zu23, also acht unterschiedliche Adressen erzeugt werden. Dies bedeutet, dass bis zu achtGeräte im gleichen Bus ohne Adresskonflikt angeschlossen werden können. Wie sichdiese 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 Wertigkeitder 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 alleAdresspins mit Ground verbunden, entsprechen also Null. Dadurch entsteht die fertigeGerä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 (0x48)

# Verbindung zu LM75B oeffnenif 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 oder16 Bit tiefe Register erledigt. Der LM75B hat, wie unter 7.4, Table 5 zu sehen ist vierdavon:

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 Overtemperatureshutdown (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.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’tCare“ gekennzeichnet und sollten ignoriert werden. Am einfachsten erhält man denTemperaturwert, in dem man den ausgelesenen Wert wie im Datenblatt beschrieben inden MSB und den LSB Bereich aufteilt. Der LSB Bereich muss anschließend um fünfStellen 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 umdrei Stellen nach links geshiftet und mit dem vorbereiten LSB Bereich logisch durch einOrder verbunden werden. Damit werden die beiden Bestandteile sauber zusammen-gesetzt. Zum Schluss muss nur noch der erhaltene Wert mit 0.125 multipliziert, oderdurch acht geteilt werden, um die Temperatur in Grad Celsius zu erhalten.

lm75b_hi = (lm75_temp & 0xFF)

lm75b_lo = (lm75_temp >> 8)

# In 2x 8 Bit Werte (High und Low Bit) umwandelnn = lm75b_hi << 3 | (( lm75b_lo >> 5) & 0x07)

# gemaess Datasheet des Sensors aus den ausgelesenen# 2 Bytes die korreten 11 Bits fuer den Temperaturwert# extrahieren und shiftenlm75b_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 dieUmgebungstemperatur messen und diese als Standardtemperatur verwenden. Solltedie 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. DieIdealtemperatur 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 Zustandesund die aktuelle Temperatur ausgegeben werden.


62

7.5 Verwendung des SPI Bus mittels Python


Nachdem nun die Kommunikation über den I2C Bus erfolgreich funktioniert, wendenwir uns dem letzten Bauteil auf dem Erweiterungsboard zu, dem MCP3002 2 Kanal 10Bit 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 denWert eines angeschlossenen Lichtsensors / LDR auszulesen. Da es sich um einen 10Bit Wandler handelt, kann dieser die angelegte analoge Spannung von 0 bis 3,3 V ineinem digitalen Wertebereich von 0 bis 1024 (210) darstellen. Das bedeutet, dass jedeanaloge Spannungssteigerung von 3,3 mV sich in einer Erhöhung des digitalen Wertesum 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 demRaspberry 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) inden Kommunikationsmodus geschaltet. In dem Fall des Erweiterungsboards wurdeder MCP3002 auf den Slave Select 0 gelegt, den ersten der beiden Slave Selects. Diesesind in keinem Fall mit den internen beiden ADC Kanälen des MCP3002 zu verwech-seln, welche nicht zur Kommunikation dienen, sondern zur Messung von analogenSpannungen - 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 TimingParameters, 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 Controllerdes RPi allerdings ganze vielfache bevorzugt, werden wir eine Geschwindigkeit von 1MHz verwenden - sowie den Slave Select 0.


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


else: �7.5.2 Kommunikation

Die Kommunikation beim SPI Bus verläuft bidirektional, in dem eine gewisse Anzahlan Bytes in Form eines Bytebuffers über den Bus versendet, und gleichzeitig wiedervon der Gegenstelle mit Daten gefüllt wird. Das heißt, dass nach erfolgter Kommu-nikation der Sendebuffer mit den Zieldaten überschrieben wurde. Der Ablauf dieserKommunikation 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 DINmit 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 Bytebesteht völlig aus „Don’t Care“ Bestandteilen, die wir beliebig mit Eins und Null füllenkönnten. Für die bessere Lesbarkeit werden wir allerdings alle „Don’t Care“ Bits mitNull 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


Abbildung 7.8: MCP3002 Konfigurationsbits

Es handelt sich dabei um Konfigurationsbit mit welchem man die Funktionsart desMCP3002 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 erden Unterschied zwischen beiden Kanälen feststellen soll (Einstellung 0). Da wir dieSpannung am Kanal 0, an dem auch der LDR angeschlossen ist messen wollen, müssenwir 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 dieKommunikation im MSB Format abläuft, wenn es gesetzt ist. Ansonsten arbeitet derWandler 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 Formatbringen 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# 0x davorzustellenbuffer = 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


# 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 umbuffer = 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, manuellenKommunikation bietet wiringpi2 bereits eine Bibliothek, welche die Kommunikationmit dem MCP3002 vereinfacht. Das entsprechende Listing befindet sich im AnhangD.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 erzeugtwerden, 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 unddaher der Aufruf direkt aus LXTerminal wie in Abschnitt 7.2.1 als 2) und 3) beschriebenerfolgen muss. Wegen dem Aufruf von curses wird das Programm in diesem Fall durchdas Drücken einer beliebigen Taste beendet und sollte nicht per Strg + C abgebrochenwerden.

#!/usr/bin/pythonimport curses

from time import sleep

screen = curses.initscr ()

# curses in der Konsole initialisierendims = screen.getmaxyx ()

# y,x Groesse des Bildschirms in Array ablegen# dims [0] entspricht y Wert# dims [1] entspricht x Wertscreen.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


# Taste gedrueckt wurdescreen.erase()

# Bildschirm loeschenscreen.hline(20, 0, '-', 40)

# horinzontale Linie aus - Zeichen malen# hline(y Koordinate , x Beginn , ch Zeichen , n Laenge)

screen.refresh ()

# Bildschirm neu ladensleep (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 angeschlossenenLDR anzeigt. Wichtig wird dabei sein, jeweils zum Start des Skriptes den aktuellenMesswert 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 SoftwareMathematica und deren Verwendung mit den GPIO Pins im Vordergrund stehen. Dabeisoll gegen Ende des Kapitels sowohl die grundlegende Nutzung der Software selbst,wie auch die Verwendung in Kombination mit dem Erweiterungsboard verständlichgeworden 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 sowieDatenanalyse. 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 zahlreichenSonderfunktionen wie Cloud- und Grindcomputing, wissensbasiertem Programmie-ren, Integration neuer Technologien wie Internet of Things und webbasierten Sensorenauch eine leistungsfähige API, sowie die Möglichkeit eigene Programme mittels desMathLink Protokolls als Datenquelle und -senke in Wolfram zu integrieren.

Aufgrund des großen Funktionsumfangs und der Leistungsfähigkeit dieser Softwareist diese im Normalfall für Studenten nur eingeschränkt oder gar nicht zugänglich.Durch die kostenlose Integration der aktuellen Version von Wolfram Mathematica inRaspbian, dem Betriebssystem des Raspberry Pi, wird dieses Werkzeug also für einengrößeren Nutzerkreis verfügbar.

Weiterhin können durch die Nutzung des Raspberry Pi als Schnittstelle auch I2C, SPIund GPIO Sensoren und Aktoren mittels MathLink Protokolls von anderen RaspberryPis oder vollwertigen Mathematica Arbeitsplätzen verwendet werden.

8.2 Benutzung

Mathematica ist auf dem RPi in zwei Varianten installiert: wolfram, die CLI basierteForm von Mathematica, welche ausschließlich zur Verwendung im reinen Textmodusund in Verbindung mit Skripten gedacht ist, sowie mathematica, welche alle Featuresin der grafischen Benutzeroberfläche bietet - inklusive der Ausgabe von Grafiken undPlots. 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)^2oder 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 vonWolfram 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. Wiein 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 Internetanbindungmö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

http://reference.wolfram.com/language/

8.2 Benutzung

hinterlegten Daten, sind dadurch interessante Auswertungen mit sehr geringem Auf-wand möglich. So zum Beispiel die wissenschaftlich nicht relevante Berechnung derAnzahl 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

http://www.wolframalpha.com/examples/

8 Mathematica

8.3 Verwendung mittels Erweiterungsboard

Wie bereits erwähnt können die Sensoren und Aktoren des Erweiterungsboards auchmittels Mathematica genutzt werden, um z.B. Temperatur- oder Helligkeitsdaten zusammeln und grafisch auszuwerten. Es wäre auch möglich die Schalter des Boards zurZä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 Peripheriein Mathematica verfügbar wird, muss zuerst die entsprechende Library eingebundenwerden. Da es für Mathematica noch keine Erweiterung zur Nutzung der I2C und SPIBus Systeme gibt, wurde im Rahmen dieser Arbeit unter Nutzung von C, wiringpi2 unddem MathLink Protokoll eine eigene geschrieben. Der Quellcode für diese wpi genannteLibrary kann auf dem Raspberry Pi im Unterverzeichnis RPi_HTW/Mathematica/ desHauptnutzers 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 werdenmü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 Befehllink = Install["wpi"] die Library wpi laden.

Solange die Sitzung von Mathematica beziehungsweise Wolfram aktiv ist, sind abnun 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 ausgegebenwerden. Die ersten vier angegebenen Befehle sind die bekannten Kommandos der wi-ringpi2 Bibliothek, die anderen beiden basieren auf dem bereits in Abschnitt 7.4 undAbschnitt 7.5 entwickelten Python Code zur Nutzung des LM75B Temperatur Sensorsund des MCP3002 ADC.

Dementsprechend einfach ist die Verwendung der GPIOs in Mathematica, um zumBeispiel 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 bisentweder 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 analogenMesswerkes darstellen. Dazu verwenden wir wieder die Methode RunScheduledTask

73

8 Mathematica

um die Messwerte zu erfassen. Das Auswertung wird diesmal jedoch nicht über einenListLinePlot, 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öglichstwenige 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 Lehreanhand 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 PiElektrotechnik Labor Erstellung eines Grundlagen Handbuches zum RPiSystemtechnik Labor Erstellung Standard Image zur Verwendung im STL

Betriebssystem Einführung Praktisches Bash Projekt zur Vorbereitung der KlausurSystemmanagement & Sicherheit Einführung in die Sprache Python

Programmierung 1 Darstellung Nachteile ineffizienter ProgrammierungDigitaltechnik 1 Binäre Logik / Binärer Zähler

Rechnerarchitektur Grundlagen I2C / SPI Bussysteme & VerwendungTheoretische 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, dasin diesem Dokument besprochene Erweiterungsboard entwickelt und in zehnfacherStückzahl hergestellt, um anschließend mit den gleichzeitig vorbereiten Raspberry Pisaktiv in der Lehre der HTW Saar eingesetzt zu werden.

Zum Abschluss lässt sich sagen, dass die gesteckten Ziele dieser Arbeit im Rahmender 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 erwiesenhat.

75

9 Fazit

9.2 Ausblick

Aufgrund der gegebenen, zeitlichen Begrenzung dieser Thesis, war es leider nicht mehrmöglich die Assembler Programmierung des verbauten ARMv6 SoC zu erläutern, odereine Einführung in die objektorientierte Programmierung unter Python zu geben, wasden 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 zulassen:

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 dieRobotik“, als Plattform für ein „Gamification“ Projekt, bei interdisziplinäre Arbeiten imBereich 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. ElectronicIndustries 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 DirkScharf. 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

http://www.stevebate.net/chibios-rpi/GettingStarted.html

http://www.stevebate.net/chibios-rpi/GettingStarted.html

http://www2.technologyreview.com/tr35/profile.aspx?TRID=1307

http://www2.technologyreview.com/tr35/profile.aspx?TRID=1307

http://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/

http://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/

http://books.google.de/books?id=fVp0PwAACAAJ

http://books.google.de/books?id=fVp0PwAACAAJ

http://dx.doi.org/10.1007/s10586-013-0282-7

http://dx.doi.org/10.1007/s10586-013-0282-7

http://dx.doi.org/10.1007/s10586-013-0282-7

https://learn.adafruit.com/embedded-linux-board-comparison/overview

https://learn.adafruit.com/embedded-linux-board-comparison/overview

http://books.google.de/books?id=Tp08AAAAIAAJ

http://books.google.de/books?id=Tp08AAAAIAAJ

http://elinux.org/RPiconfig

http://www.htwsaar.de/ingwi/fakultaet/personen/profile/helmut-folz/prog1/folien2013/folien2013-00-08.zip/view

http://www.htwsaar.de/ingwi/fakultaet/personen/profile/helmut-folz/prog1/folien2013/folien2013-00-08.zip/view

http://elinux.org/RPi_Serial_Connection

http://elinux.org/RPi_Serial_Connection

http://www.raspberrypi-spy.co.uk/2014/07/raspberry-pi-b-gpio-header-details-and-pinout/

http://www.raspberrypi-spy.co.uk/2014/07/raspberry-pi-b-gpio-header-details-and-pinout/

http://amazon.de/o/ASIN/3142250425/

http://amazon.de/o/ASIN/3142250425/

https://projects.drogon.net/understanding-spi-on-the-raspberry-pi/

https://projects.drogon.net/understanding-spi-on-the-raspberry-pi/

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. US4207087A. 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

http://www.nxp.com/documents/data_sheet/LM75B.pdf

http://www.nxp.com/documents/data_sheet/LM75B.pdf

http://dx.doi.org/10.1109/MIM.2009.4762946

http://dx.doi.org/10.1109/MIM.2009.4762946

http://de.scribd.com/doc/101830961/GPIO-Pads-Control2

http://de.scribd.com/doc/101830961/GPIO-Pads-Control2

http://ww1.microchip.com/downloads/en/DeviceDoc/21294E.pdf

http://ww1.microchip.com/downloads/en/DeviceDoc/21294E.pdf

http://www.google.com/patents/US4207087

http://www.google.com/patents/US4207087

http://www.nxp.com/documents/user_manual/UM10204.pdf

http://www.nxp.com/documents/user_manual/UM10204.pdf

http://www.raspberrypi.org/documentation/hardware/raspberrypi/schematics/Raspberry-Pi-Rev-2.1-Model-AB-Schematics.pdf



https://sparkfun.com/datasheets/BreakoutBoards/I2SBUS.pdf

https://sparkfun.com/datasheets/BreakoutBoards/I2SBUS.pdf

http://www.raspberrypi.org/gpgpu-hacking-on-the-pi/

http://www.raspberrypi.org/gpgpu-hacking-on-the-pi/

http://www.raspberrypi.org/introducing-turbo-mode-up-to-50-more-performance-for-free/

http://www.raspberrypi.org/introducing-turbo-mode-up-to-50-more-performance-for-free/

http://www.raspberrypi.org/raspberry-pi-at-buckingham-palace-3-million-sold/



Abbildungsverzeichnis

3.1 SD Formatter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133.2 SD Formatter Optionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133.3 Win32 Disk Imager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143.4 noobs nach dem Entpacken auf die SD Karte . . . . . . . . . . . . . . . . 163.5 Installation von Raspbian unter noobs . . . . . . . . . . . . . . . . . . . . 17

4.1 raspi-config . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204.2 Raspbian Desktop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

5.1 GPIO Schnittstelle Raspberry Pi Modell A / B / B+ [11] . . . . . . . . . . 315.2 Erweiterungsboard und Routing der Komponenten . . . . . . . . . . . . 39

6.1 Simon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436.2 Flowchart Simon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

7.1 Festlegung des binären Wertes jeder LED . . . . . . . . . . . . . . . . . . 597.2 LM75B Pinout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607.3 LM75B Adresstabelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607.4 LM75B Register . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 617.5 LM75B Temperatur Register . . . . . . . . . . . . . . . . . . . . . . . . . . 627.6 MCP3002 SPI Bus Geschwindigkeit . . . . . . . . . . . . . . . . . . . . . . 637.7 MCP3002 SPI Kommunikation . . . . . . . . . . . . . . . . . . . . . . . . 647.8 MCP3002 Konfigurationsbits . . . . . . . . . . . . . . . . . . . . . . . . . 65

8.1 Umstellung der Eingabeart in Wolfram . . . . . . . . . . . . . . . . . . . 708.2 Berechnung mittels Wolfram Alpha . . . . . . . . . . . . . . . . . . . . . . 718.3 Plot des Temperatur Sensors über 400 Sekunden . . . . . . . . . . . . . . 738.4 Darstellung des Lichtsensor Wertes als analoges Messwerk . . . . . . . . 74

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

79

TABELLENVERZEICHNIS

Tabellenverzeichnis

2.1 Übersicht [6] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.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 . . . . . . . . . . . . . . . . . . . . . . . . . . . 517.2 Vergleichsoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517.3 Binäres Und . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527.4 Binäres Oder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527.5 Binäres XOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527.6 Binäres 1er Komplement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537.7 Binäre, bitweise Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . 537.8 Laufzeiten beider Algorithmen in Sekunden . . . . . . . . . . . . . . . . 567.9 LEDs auf dem Erweiterungsboard . . . . . . . . . . . . . . . . . . . . . . 577.10 Schalter auf dem Erweiterungsboard . . . . . . . . . . . . . . . . . . . . . 587.11 Vorläufiger Kommunikationsbuffer . . . . . . . . . . . . . . . . . . . . . . 647.12 Kommunikationsbuffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

9.1 Stakeholder dieser Thesis . . . . . . . . . . . . . . . . . . . . . . . . . . . 759.2 Ausblick auf mögliche Projekte . . . . . . . . . . . . . . . . . . . . . . . . 76

A.1 Raspbian Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85A.2 Per apt-get installierte Pakete . . . . . . . . . . . . . . . . . . . . . . . . . 85A.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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91Code/gpio.sh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95Code/demoLed.sh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97Code/demoSwitch.sh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98Code/simon.sh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99Code/uebungAusgabe.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102Code/uebungEingabe.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103Code/binaryCounter.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104Code/lm75b.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105Code/uebungI2C.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106Code/mcp3002.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108Code/mcp3002lib.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109Code/uebungSPI.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109Code/wpi.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110Code/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 / rpiroot 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-browseruuid-dev gfortran screen minecraft-pi python-minecraftpi

Tabelle A.3: Manuell installierte Pakete

Name URL

wiringpi2 git://git.drogon.net/wiringPiwiringpi2-python https://github.com/Gadgetoid/WiringPi2-Pythonrpi-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.gzMCPIPY Examples https://github.com/brooksc/mcpipy

85

BR

aspb

erry

PiH

ardw

are

HT

W

B.1

Übe

rsic

ht

Tabe

lleB.

1:R

aspb

erry

Pide

rH

TW

Nr

Nam

eH

erst

elle

rSp

eich

erM

odel

lM

AC

Net

ztei

lSD

Car

dSD

Kar

teok

1G

Hz

Boo

t?

1rp

i01

RS

Sam

sung

BR

ev.2

.0B8

:27:

EB:8

1:B9

:6C

RS

Inte

nso

Cla

ss10

x-

2rp

i02

RS

Sam

sung

BR

ev.2

.0B8

:27:

EB:C

B:3D

:35

RS

Inte

nso

Cla

ss10

xx

3rp

i03

RS

Sam

sung

BR

ev.2

.0B8

:27:

EB:6

1:B4

:4C

RS

Inte

nso

Cla

ss10

xx

4rp

i04

RS

Sam

sung

BR

ev.2

.0B8

:27:

EB:5

1:29

:89

RS

Inte

nso

Cla

ss10

xx

5rp

i05

RS

Sam

sung

BR

ev.2

.0B8

:27:

EB:1

E:D

8:E7

RS

Inte

nso

Cla

ss10

xx

6rp

i06

RS

Sam

sung

BR

ev.2

.0B8

:27:

EB:2

D:2

6:D

CR

SIn

tens

oC

lass

10x

x7

rpi0

7R

SSa

msu

ngB

Rev

.2.0

B8:2

7:EB

:89:

B0:4

BR

SIn

tens

oC

lass

10x

x8

rpi0

8R

SSa

msu

ngB

Rev

.2.0

B8:2

7:EB

:10:

C8:

9DR

SIn

tens

oC

lass

10x

x9

rpi0

9R

SSa

msu

ngB

Rev

.2.0

B8:2

7:EB

:BD

:BA

:96

RS

Inte

nso

Cla

ss10

xx

10rp

i10

RS

Sam

sung

BR

ev.2

.0B8

:27:

EB:4

8:9A

:63

RS

Inte

nso

Cla

ss10

xx

87

C Erweiterungsboard

North

South

East

West

MCP3002

LM75B

Abbildung C.1: Erweiterungsboard

89

C Erweiterungsboard

Tabelle C.1: Erweiterungsboard und Routing der Komponeten






LM75B SDA 2SCL 3

MCP3002 MOSI 10MISO 9SCLK 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 zuden 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 0x48

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

http://www.nico-maas.de/RPi_HTW.tar.gz

D Code Listings

#define SWITCHEAST 17

#define SWITCHWEST 22

#define SWITCHSOUTH 27

// PWM Variableint 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 aktivierendelay (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 definierenprintf ("Switch Test beginnt\n") ;

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

while (digitalRead(SWITCHNORTH) == LOW)

// So lange der Switch North nicht gedrÃ×ckt ist , wartendelay (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 auslesenlm75b_hi = (lm75_temp & 0xFF);

lm75b_lo = (lm75_temp >> 8);

// In 2x 8 Bit Werte (High und Low Bit) umwandelnn = lm75b_hi << 3 | (( lm75b_lo >> 5) & 0x07);

/* gemaess Datasheet des Sensors aus den ausgelesenen2 Bytes die korreten 11 Bits fÃ×r den Temperaturwertextrahieren und shiften */lm75b_temp = (float)n / 8;

// 11 Bit Wert in Temperatur umwandelnprintf(" LM75B: %4.2f 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 zulassenbuff [0] = (6+ adcnum) <<4;

buff [1] = 0;

// korrekte Anfrage fuer MCP3002 gemaess Datenblatt erzeugenwiringPiSPIDataRW (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 0mit Geschwindigkeit 1 MHz */

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

{

// Wert von MCP3002 , Kanal 0 (LDR) ausgebenprintf(" 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 , nordengpio export 18 out

ledNorthOn ()

{

gpio -g write 18 1

}

ledNorthOff ()

{

gpio -g write 18 0

}

# LED rot , eastgpio export 23 out

ledEastOn ()

{

gpio -g write 23 1

}

ledEastOff ()

{

gpio -g write 23 0

95

D Code Listings

}

# LED gelb , westgpio export 25 out

ledWestOn ()

{

gpio -g write 25 1

}

ledWestOff ()

{

gpio -g write 25 0

}

# LED blau , southgpio export 24 out

ledSouthOn ()

{

gpio -g write 24 1

}

ledSouthOff ()

{

gpio -g write 24 0

}

# LED , alleledOn()

{

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 northgpio export 4 in

switchNorth ()

{

echo `gpio -g read 4`

}

# Switch eastgpio export 17 in

switchEast ()

{


}

# Switch westgpio export 22 in

switchWest ()

{


}

# Switch southgpio export 27 in

switchSouth ()

{


} �D.3 demoLed.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



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 istthen

echo "North gedrueckt"

ledNorthOn

# North gedrueckt ausgeben und die entsprechende LED anschaltenelse

ledNorthOff

# sonst die LED ausschaltenfi

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



# Konstanten# Verzoegerung zwischen LED leuchtenDELAY_TIME_LED =0.25

# Verzoegerung bei Switch EingabeDELAY_TIME_SWITCH =0.2

# Variablen# correct =0 Eingaben in Ordnung , Spiel geht weiter# correct=-1 Eingabe falsch , Abbruchcorrect =0

MakeRandom ()

{ # Zufallszahl zwischen 0 und 3echo $(( 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 ausschaltencase "$value" in

0)

ledNorthOn

sleep ${DELAY_TIME_LED}

ledNorthOff


;;

1)

ledEastOn


ledEastOff


;;

2)

ledWestOn


ledWestOff


;;

3)

ledSouthOn


ledSouthOff


;;

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 abrufenfor value in "${simonArray[@]}"

do

# Wert der Schalter auslesenbtn=$(ReadButton)

# Solange kein Schalter gedrueckt# ist , weiter auslesenwhile [ $btn == -1 ]

do

btn=$(ReadButton)

done

# Falls ein Schalter gedrueckt wurde ,# und der Wert der Stelle im Array# entspricht , weiter machenif [ $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# identifizierensleep ${DELAY_TIME_SWITCH}

# Sonst: correct=-1 setzen und# aus der Schleife ausbrechenelse

echo "Falsch!"

correct=-1

break

fi

done

}

# 2x 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 / IterationsvariablesimonArray[${#simonArray[@]}]=$(MakeRandom)# Alle Zufallswerte des Arrays auf den LEDs abspielenLightLed

# 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

# 2x langsames blinken aller LEDs# bei Fehler / Ende des Spielssleep 0.5

ledBlink

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

# Neustart des Spiels bei Fehler./simon.sh �

D.6 uebungAusgabe.py




LEDs =[18 ,23 ,24 ,25]

# LED Pins als Array fuer# gruen , rot , blau , gelbled_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




LEDs =[24 ,25 ,18 ,23]

# LED Pins als Array fuer# blau , gelb , gruen , rotfor led_pin in LEDs:



# Setup: Alle Pins mit LEDs# als Ausgabe setzen und ausschaltenwpi.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 anaktuelleVerzoegerung =0.50

# Gibt die aktuelle Verzoegerung zwischen# den LED wechseln anaktuelleRunde =1

# Gibt die aktuelle Runde an

while True:

if (wpi.digitalRead (27)):

# falls der Schalter gedrueckt wurdeblinkLED(aktuelleLED , 2, 0.5)

# lass die mit dem Schalter gewaehelte# LED zwei mal blinkenif (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 zurueckprint("Runde %d bestanden" % aktuelleRunde)

# ErfolgaktuelleRunde=aktuelleRunde +1

# naechste Rundeelse:

print("Leider verloren in Runde %d!" % aktuelleRunde)

# Niederlage , weil falsch/zu spaet gedruecktbreak

# Verlasse Schleife und beende ProgrammblinkLED(aktuelleLED , 1, aktuelleVerzoegerung)

# die jeweils aktuelle LED einmal blinken lassenaktuelleLED=aktuelleLED +1

# und zur naechsten iterierenif (aktuelleLED > 3):

print("Leider verloren in Runde %d!" % aktuelleRunde)

# Niederlage , weil gar nicht gedruecktbreak

# Verlasse Schleife und beende Programm �D.8 binaryCounter.py



LEDs =[18 ,23 ,24 ,25]

# LED Pins als Array fuer# gruen , rot , blau , gelbfor led_pin in LEDs:



# Setup: Alle Pins mit LEDs# als Ausgabe setzen und ausschaltenwpi.pinMode (27,0)

wpi.pinMode (22,0)

# Setup: Schalter South ,# Schalter West als Eingabe setzensouthState=wpi.digitalRead (27)

westState=wpi.digitalRead (22)

# Setup: Initialer Status# von South und West einlesen

zahl=0

# ZaehlvariableledMode =[0,0,0,0]

# Zwischenspeicher fuer die# Ergebnisse der Umrechnung

def showLED ():

ledMode [0] = zahl & 0b0001

104

D.9 lm75b.py




# jeweils aus der binaeren Verundung der# Zahl und der Wertigkeit der LED# den Status fuer die LED errechnen# und speichernfor i in range (0,4):

wpi.digitalWrite(LEDs[i],ledMode[i])

# alle LEDs auf den aktuellen Status setzenprint("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 einlesenif (southValue != southState):

# besteht ein Unterschied# zum gespeicherten Status

if (southValue):

# Ist der +1 Schalter gedrueckt?zahl=zahl+1

# Zahl erhoehenif zahl >15:

zahl=0

# Zahl ruecksetzen falls zu hochshowLED ()

# AnzeigensouthState=southValue

# neuen Wert des Schalters speichernwestValue=wpi.digitalRead (22)

if (westValue != westState):

if (westValue):

# Ist der Reset Schalter gedrueckt?zahl=0

# Zahl ruecksetzenshowLED ()

# AnzeigenwestState=westValue �

D.9 lm75b.py


lm75b_addr =0x48

105

D Code Listings

lm75b_file = wpi.wiringPiI2CSetup(lm75b_addr)



else:


# Register 0 von LM75B in 16 Bit Tiefe auslesenlm75b_hi = (lm75_temp & 0xFF)




# 11 Bit Wert in Temperatur umwandelnprint("LM75B: %4.2f Grad Celsius" % (lm75b_temp))

# Temperatur mit 2 Nachkommastellen ausgeben �D.10 uebungI2C.py



lm75b_addr =0x48

# I2C Adresse des LM75BLEDs =[24 ,18 ,23]

# LED Pins als Array fuer# blau , gruen , rotmodifierState =[-1,0,+1]

# Temperatur Unterschiede fuer UbergangnameState =["Kalt","Normal","Warm"]

# Namen der StatescurrentState =0

# State der Pseudo State MachinemaxStates =3

# Anzahl der States

def readTemp ():


# Register 0 von LM75B in 16 Bit Tiefe auslesenlm75b_hi = (lm75_temp & 0xFF)




106

D.10 uebungI2C.py

# 11 Bit Wert in Temperatur umwandelnreturn lm75b_temp

def transition(up):

global currentState , maxMod , minMod

# globale Variablen in Funktion ladenwpi.digitalWrite(LEDs[currentState ],0)

# Led des jetzigen State abschaltenif (up==1):

# Falls State erhoeht wirdcurrentState=currentState +1

# State erhoehenprint("Transition von %s -> %s" % (nameState[currentState -1],

nameState[currentState ]))

# Ausgabe vorheriger State nach jetziger Stateelse:

currentState=currentState -1

# State verringernprint("Transition von %s -> %s" % (nameState[currentState +1],

nameState[currentState ]))

# Ausgabe vorheriger State nach jetziger Statewpi.digitalWrite(LEDs[currentState ],1)

# Led des nun aktuellen State einschaltenif (modifierState[currentState ]==0):

# Falls State 1 / Normal aktivmaxMod =1

# setze maximalen Wert auf +1minMod=-1

# setze minimalen Wert auf -1else:

# sonst setze Max/Min gemaess ArraymaxMod=modifierState[currentState]

minMod=modifierState[currentState]

lm75b_file = wpi.wiringPiI2CSetup(lm75b_addr)



else:

# Setupwpi.wiringPiSetupGpio ()

# Initialisiert die Bibliothek unter Nutzung des# BCM GPIO Namenschemafor led_pin in LEDs:



# Alle Pins mit LEDs als Ausgabe setzen und abschaltenidealTemp = readTemp ()

# Ideal Temperatur messentransition (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 Statestransition (1)

# State erhoehenelif (( readTemp () < (idealTemp+minMod)) and (currentState > 0)):

# falls aktuelle Temperatur kleiner als Ideal Temperatur + Modifier# und aktueller State groesser als 0

transition (0)

# State verringernelse:

# falls innerhalb der Temperatur des Statesprint("%s: %4.2f" % (nameState[currentState], readTemp ()))

# aktueller State und aktuelle Temperaturmessung ausgebensleep (0.25) �

D.11 mcp3002.py


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# 0x davorzustellenbuffer = 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 umbuffer = int(buffer , 16)

# Wandle den Hex String in einen# dezimalen Integer Wert umprozent = (buffer /1024.0) *100

108

D.12 mcp3002lib.py

# Wandle dezimalen Integer in Prozentwert# der eingegangen Beleuchtungsstaerke umprint("MCP3002 - Kanal %d: %4.2f Prozent" % (mcp3002_channel ,

prozent)) �D.12 mcp3002lib.py


mcp3002_channel =0

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

# Verbindung zu MCP3002 oeffnenprint("Kann den SPI Bus nicht oeffnen!")

else:

wpi.mcp3002Setup (64, mcp3002_channel)

# MCP3002 Template laden , Kanal 0 auf virtuellen Port 64 legenbuffer=wpi.analogRead (64)

# Virtuellen Port 64 auslesenprozent = (buffer /1024.0) *100

# Wandle dezimalen Integer in Prozentwert# der eingegangen Beleuchtungsstaerke umprint("MCP3002 - Kanal %d: %4.2f Prozent" % (mcp3002_channel , prozent

)) �D.13 uebungSPI.py

#!/usr/bin/pythonimport curses


import wiringpi2 as wpi

mcp3002_channel =0

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

# Verbindung zu MCP3002 oeffnenprint("Kann den SPI Bus nicht oeffnen!")

else:

wpi.mcp3002Setup (64, mcp3002_channel)

# MCP3002 Template laden , Kanal 0 auf virtuellen Port 64 legenldr_max=float(wpi.analogRead (64))

# Virtuellen Port 64 auslesen , als maximal Wertscreen = curses.initscr ()

# curses in der Konsole initialisierendims = screen.getmaxyx ()

# y,x Groesse des Bildschirms in Array ablegen# dims [0] entspricht y Wert

109

D Code Listings

# dims [1] entspricht x Wertscreen.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 einlesenwert = int((ldr/ldr_max)*dims [0])

# LDR Wert auf Dimensionen des Bildschirms skalierenif wert >= dims [0]:

# Sollte der Wert die y Dimension ueberschreitenwert = (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 hatscreen.erase()

# Bildschirm loeschenscreen.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 ladensleep (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 0x48

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);


}

void setPwmWrite(int pin , int value)

{

pwmWrite(pin , value);


}

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 oeffnenlm75_temp = wiringPiI2CReadReg16(lm75b_file , 0);

// Register 0 von LM75B in 16 Bit Tiefe auslesenlm75b_hi = (lm75_temp & 0xFF);

lm75b_lo = (lm75_temp >> 8);

// In 2x 8 Bit Werte (High und Low Bit) umwandelnn = lm75b_hi << 3 | (( lm75b_lo >> 5) & 0x07);

/* gemaess Datasheet des Sensors aus den ausgelesenen2 Bytes die korreten 11 Bits fÃ×r den Temperaturwertextrahieren und shiften */lm75b_temp = (float)n / 8;

// 11 Bit Wert in Temperatur umwandelnreturn 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 zulassenreturn -1;

}

if (wiringPiSPISetup (0, 1000000) < 0)

{

return -1 ;

}

/* WiringPi SPI API initalisieren auf Slave Select / SPI Kanal 0mit Geschwindigkeit 1 MHz */buff [0] = (6+ channel) <<4;

buff [1] = 0;

// korrekte Anfrage fuer MCP3002 gemaess Datenblatt erzeugenwiringPiSPIDataRW (0, buff , 2);

// Anfrage absenden und Antwort in den Puffer schreibenreturn ((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 }


: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 }


: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 saarim Bereich Informatik/Mechatronik-Sensortechnik erstellt (Version 1.0). Die Vorlagewurde von Yves Hary und André Miede entwickelt (mit freundlicher Unterstützungvon Thomas Kretschmer und Helmut G. Folz).

Documents

Anwendung des Raspberry Pi in Forschung und Lehre · Steuerung realer Hardware mittels modernen Hochsprachen wie C, Python oder Ja-va. Die nachfolgende Arbeit soll an konkreten Beispielen