Seminararbeit Raspberry Pi 2

Fachhochschule der Wirtschaft
FHDW
Mettmann
Seminararbeit
Industrie 4.0 – Sortierung eingehender Postpakete
am Beispiel einer technikbasierten LEGO-Konstruktion
Prüfer:
Peter Tutt
Verfasser:
Steffen Schwarz
Stettiner Straße 1
D-42489 Wülfrath
Matrikelnummer: 9215767
Studiengang: Wirtschaftsinformatik
Spezialisierungsbereich: IT-Consulting
Abgabetermin:
11.05.2015
Danksagung
I
Danksagung
Jede wissenschaftliche Arbeit trägt die Handschrift des Verfassers, doch ist sie niemals
die Arbeit eines Einzelnen. An dieser Stelle möchte ich allen danken, die diese Seminararbeit durch ihre fachliche und persönliche Unterstützung begleitet und zu ihrem
Gelingen beigetragen haben.
Ganz besonders danke ich meinem Dozenten Peter Tutt für die interessanten und inspirierenden Gespräche im Verlauf des FHDW-Prüfungsmoduls sowie für die Betreuung und wissenschaftliche Unterstützung vor und während der Bearbeitungsphase.
Gerne möchte ich meinem technikbegeisterten Bekannten Tobias van Ark danken, der
sich insbesondere in der Programmierungsphase des Projekts mit seinem Fachwissen
eingebracht und mich somit enorm unterstützt hat.
Des Weiteren danke ich meiner Lebensgefährtin Joana Jantke und meinem Bekannten
David Haase, die gemeinsam bei der Optimierung der LEGO-Konstruktion mitgewirkt
haben.
Weiterhin danke ich Janine van Ark, Tim Dierich und Denise Waligorski für ihre Unterstützung hinsichtlich der Bereitstellung von Räumlichkeiten, Verpflegung und Unterhaltung während der Projektarbeiten.
Schließlich gebührt ganz besonderer Dank meiner Mutter Annette Schwarz, die mich
während meines gesamten, beruflichen Werdegangs bis heute immer unterstützt und
stets an mich geglaubt hat.
Abschließend gilt mein Dank Wladimir Kremer. Als ich Anfang 2008 im Rahmen meines Fachoberschulreifeerwerbs ein Praktikum zum Fahrzeuglackierer bei der Firma
Cron & Mainka e.K. absolvierte, empfahl der mir zugeteilte Betreuer, sich aus diversen
Gründen anderweitig zu orientieren. Er nannte mir die IT-Branche und legte damit den
Grundbaustein für meinen beruflichen Werdegang.
Inhaltsverzeichnis
II
Inhaltsverzeichnis
Danksagung ................................................................................................................. I
Inhaltsverzeichnis....................................................................................................... II
Abbildungsverzeichnis.............................................................................................. III
1
Einleitung .............................................................................................................. 1
1.1
1.2
2
Grundlagen und Technology Stack ..................................................................... 3
2.1
2.2
2.3
2.4
2.5
3
Erläuterung und Funktionsweise der LEGO-Konstruktion ...................... 8
Installation des Raspberry Pis ................................................................ 8
Programmierung des Steuerungsarms ................................................. 10
Kameramodul-Konfiguration und SimpleCV-Integration ....................... 12
Zusammenspiel zwischen Steuerungsarm und Kameramodul ............. 14
Modulbezogene Netzwerkinstallation................................................................ 15
4.1
4.2
5
Konstruktion aus LEGO-Bausteinen....................................................... 3
Kleincomputer „Raspberry Pi 2 Model B“ ............................................... 3
Programmiersprache Python.................................................................. 4
LEGO-Steuerungsarm und Servomotor „Tower Pro SG90“ .................... 5
Kameramodul „Raspberry Pi Camera Rev 1.3“ und Computer Vision mit
SimpleCV ............................................................................................... 6
Praktische Umsetzung.......................................................................................... 8
3.1
3.2
3.3
3.4
3.5
4
Problemstellung und Vorgehensweise ................................................... 1
Industrie 4.0 und Projekt ........................................................................ 2
Installation des Apache-Webservers .................................................... 15
Auswertung der Glasmurmeldurchläufe ............................................... 15
Schlussbetrachtung ........................................................................................... 16
5.1
5.2
5.3
5.4
Persönliches Fazit ................................................................................ 16
Zusammenfassender Projektaufwand .................................................. 16
Probleme des Projekts ......................................................................... 17
Material-Einkaufsliste ........................................................................... 17
Quellenverzeichnis ................................................................................................... 19
Internetquellen ................................................................................................... 19
Eidesstattliche Erklärung ......................................................................................... 21
Abbildungsverzeichnis
III
Abbildungsverzeichnis
Abbildung 1: Erfassungsbereich der Kamera ................................................................ 3
Abbildung 2: LEGO-Steuerungsarm.............................................................................. 5
Abbildung 3: Steuernder Servomotor ............................................................................ 6
Abbildung 4: Kameramodul Rev 1.3 ............................................................................. 6
Abbildung 5: Erkennung der Glasmurmeln mit SimpleCV ............................................. 7
Abbildung 6: Aufbewahrungskiste für Glasmurmeln ...................................................... 8
Abbildung 7: Interface des Installationsmanagers Noobs .............................................. 9
Abbildung 8: Steckplatine ........................................................................................... 10
Abbildung 9: Verwendung der GPIO-Pins ................................................................... 11
1
Einleitung
1
Einleitung
1.1
Problemstellung und Vorgehensweise
1
Der Verfasser der vorliegenden Seminararbeit absolviert das 5. Semester des Bachelor-Studiums der Wirtschaftsinformatik (mit Spezialisierung auf IT-Consulting) an
der Fachhochschule der Wirtschaft (kurz: FHDW) und bearbeitet mit dieser Ausarbeitung das Prüfungsmodul „Netzwerke“.
Hierzu stellt der Modulverantwortliche und FHDW-Dozent Peter Tutt in seinen Vorlesungen den Raspberry Pi vor und im Zuge dessen eine Reihe von Tutorials, um den
besagten Kleincomputer kennenzulernen. Während die angehenden Hochschulabsolventen in Gruppen arbeiten und den Raspberry Pi „studieren“, erarbeiten sie mögliche
Problemstellungen, die es zu bewältigen und in einer Seminararbeit schriftlich auszuarbeiten gilt.
Durch Eigeninitiative und Recherchearbeit inspiriert schließlich ein YouTube-Video mit
Namen „C# Lego ball sorter using a Raspberry Pi & OpenCV“. Es zeigt, wie ein Vater
mit seinem Sohn ein Murmelsortiersystem aus LEGO-Steinen und dem Raspberry Pi
baut. In Anlehnung an diverse Gespräche mit dem Modulverantwortlichen über das
Thema „Industrie 4.0“ entsteht ein Seminararbeitsthema: Der genannte Verfasser bearbeitet das Thema „Industrie 4.0 – Sortierung eingehender Postpakete am Beispiel
einer technikbasierten LEGO-Konstruktion“.
Hierbei wird, einfacher ausgedrückt, die DHL-Zustellbasis nachgestellt, die im nachfolgenden anhand der Thematik Industrie 4.0 (Kapitel 1.2) ausführlicher erläutert wird. Zu
berücksichtigen ist, dass ein Netzwerkbezug hergestellt wird, um dem Titel des Moduls
gerecht zu werden (Kapitel 4).
Der Dozent stellt den Großteil der Hardware. Der Student ist für die Beschaffung weiterer Bauteile selbst verantwortlich. Die Seminararbeit wird nach Rücksprache (wie vereinbart) am 11. Mai 2015 im FHDW-Studierendensekretariat eingereicht.
Für die vorliegende Seminararbeit bzw. dessen Bestandteile werden Grundkenntnisse
im Bereich Betriebssysteme (vorzugsweise UNIX/Linux-Systeme) vorausgesetzt. Sich
logisch aus dem Kontext ableitende Befehle werden nicht gesondert genannt.
1
Einleitung
1.2
Industrie 4.0 und Projekt
2
Die in Kapitel 1.1 geschilderte Problematik lässt sich mit dem Begriff „Industrie 4.0“ in
Verbindung bringen.
Die Wirtschaft steht kurz vor der vierten industriellen Revolution. Durch das Internet
getrieben, wachsen die reale und die virtuelle Welt immer mehr zusammen. Mit dem
Zukunftsprojekt Industrie 4.0 soll dieser Prozess unterstützt werden. Das Projekt zielt
darauf ab, die deutsche Industrie in die Lage zu versetzen, für die Zukunft der Produktion gerüstet zu sein (aus der Perspektive des Jahres 2025, mit Blick zurück auf die
„Vergangenheit“ des Jahres 2012) und die für Industrie 4.0 notwendige Automatisierungstechnik intelligenter zu machen, um somit die Menschen bei ihren Tätigkeiten
besser zu unterstützen.1
So zeigt das vorliegende Hochschulprojekt „Sortierung eingehender Postpakete“, wie
Glasmurmeln (Darstellung der Postpakete) durch einen Parcours (Darstellung verschiedener Fließbänder) laufen, dabei von einer Kamera (Darstellung des Paketscanners) erfasst und gelesen werden, um die Objekte schließlich durch einen Steuerungsarm nach Farbe (Darstellung der Postleitzahlen) zu sortieren.
Zu vergleichen ist dieser Prozess mit der DHL-Zustellbasis.2
1
Vgl. Bundesministerium für Bildung und Forschung (o. J.), Online im Internet.
2
Vgl. optel Media Services GmbH (o. J.), Online im Internet.
2
Grundlagen und Technology Stack
3
2
Grundlagen und Technology Stack
2.1
Konstruktion aus LEGO-Bausteinen
Als Grundgerüst der Anlage gilt das zum größten Teil aus LEGO-Bausteinen bestehende Konstrukt. Es besitzt mehrere weiße und schwarze Steine, die die Bahn darstellen – eine exakte Anzahl von Steinen ist nicht zu definieren, da das Konstrukt zum einen ohne Bauanleitung erstellt wurde, aber zum anderen auch ständig (als fortlaufendes Projekt) erweitert wird.
Besonders interessant ist der Erfassungsbereich der Kamera (Abbildung 1: Erfassungsbereich der Kamera).
Die Konstruktion hätte auch in komplett bunten Steinen gebaut werden können, wie es
anfangs im Rahmen der letzten Vorlesung an
der Fachhochschule der Wirtschaft auch der
Fall gewesen ist. Jedoch fiel dann im ersten
Abbildung 1: Erfassungsbereich der
Kamera
Projektmeeting auf, dass das Kameramodul
zum
Einsehen der Glasmurmeln dessen
Farbcodes benötigt. Bei beispielsweise roten
Bausteinen im Erfassungsbereich und einer roten durchrollenden Murmel, käme es zu
Komplikationen.
Abschließende Empfehlung: Es wird eine feste Unterlage (hier: Sperrholzplatte) benötigt, auf der die Konstruktion ihren Platz findet, um dessen Stabilität sowie einen reibungslosen Transport zu gewährleisten.
2.2
Kleincomputer „Raspberry Pi 2 Model B“
Um die im Einleitungsteil erwähnte Problematik lösen und die LEGO-Konstruktion zum
Leben erwecken zu können, kann der Kleincomputer Raspberry Pi Abhilfe schaffen.
Der Raspberry Pi ist ein winziger Computer, dessen Grundfläche etwas größer als die
einer Kreditkarte ist. Der trotz seiner Größe vollwertige und Linux-basierte Computer
2
Grundlagen und Technology Stack
4
dient u. a. der Steuerung elektrischer Geräte, wie es die vorliegende Ausarbeitung näher beschreibt.
Im Hochschulprojekt wird die aktuellste Version des Raspberry Pis verwendet: der
Raspberry Pi 2 Model B. Die größte Neuerung gegenüber dem im Juli 2014 vorgestellten Raspberry Pi Model B+, findet sich im Inneren: Statt eines einzelnen ARM-11Kernes mit maximal 700 Megahertz besitzt der Computer nun insgesamt vier CortexA7-Kerne mit bis zu 900 Megahertz. Für ein weiteres Leistungsplus sorgt der vergrößerte Arbeitsspeicher: Hier kommen statt 512 nun 1.024 Megabyte zum Einsatz. Die
Grafikeinheit bleibt mit dem bis zu 250 Megahertz schnellen VideoCore-IV-Chip von
Broadcom hingegen unangetastet.3
Der Kleincomputer eignet sich somit bestens, um das vorgestellte Projekt zu realisieren. Ein Punkt ist unbedingt zu beachten: Die Platine kommt ohne eigenes Betriebssystem – daher muss dieses vor der Verwendung des Geräts manuell nachgepflegt
werden. Weitere Informationen zur Installation des Raspberry Pis sind dem Kapitel 3.2
zu entnehmen.
Um den Raspberry Pi ordnungsgemäß und ohne Komplikationen nutzen zu können,
empfiehlt es sich, das folgende Zubehör zu verwenden: Netzteil und Gehäuse für den
Raspberry Pi, Kühlkörper für den Raspberry Pi, SD-Karte für den Raspberry Pi, HDMIKabel für den Monitoranschluss sowie Monitor, Maus, Tastatur und Netzwerkkabel.
Funktionsweise und Nutzen der einzelnen Objekte sind bei Bedarf nachzulesen und
werden im Rahmen dieser Ausarbeitung nicht weiter erläutert.
2.3
Programmiersprache Python
Die in diesem Projekt verwendete Programmiersprache ist die Sprache Python und
nicht C#, wie im erwähnten Tutorial gezeigt. Der Grund hierfür, ist die Komplexität der
Heran- und Vorgehensweise, da nicht ausreichende Anleitinformationen vorliegen.
Die Python-Skripte sind das eigentliche Herzstück des Projekts. Diese Skripte steuern
die Kamera beziehungsweise kontrollieren das erfasste Bild. Entsprechend wird der
Servomotor in Bewegung gesetzt – auch hierfür eignet sich Python bestens.
3
Vgl. Schmidt, Florian (2015), Online im Internet.
2
Grundlagen und Technology Stack
5
Python ist eine dynamische, also interpretierende Script-Programmiersprache, die einst
vom Niederländer Guido van Rossum entwickelt wurde. Python unterstützt die wichtigsten Programmierparadigmen heutiger Software-Entwicklungsmethoden: strukturierte Programmierung, objektorientierte Programmierung (OOP) und aspektorientierte
Programmierung (AOP).
Die Stärke der Programmiersprache Python ist die schnelle Umsetzbarkeit von Ideen,
die das sogenannte Rapid Prototyping (rasante Entwicklung) von Software möglich
macht, wie es im Rahmen dieses Projekts realisiert wurde. Weitere Informationen hierzu sind den Kapiteln 3.3 und 3.4 zu entnehmen.4
2.4
LEGO-Steuerungsarm und Servomotor „Tower Pro SG90“
Zwei weitere wichtige Bestandteile des Projekts sind neben dem bereits genannten
Raspberry
Pi,
Bauelementen
auch
der
bestehende
aus
LEGO-
Steuerungsarm
sowie ein programmierbarer Servomotor.
Der Steuerungsarm (Abbildung 2: LEGOSteuerungsarm) besteht aus diversen kleinen
Bausteinen, die gemeinsam eine HebelfunktiAbbildung 2: LEGO-Steuerungsarm
on darstellen – es liegt auch hier keine Bauanleitung vor. Es ist sicherzustellen, dass der
Hebelarm nicht zu kurz und nicht zu lang ist, da er sonst die später definierten Drehungen nicht erfolgreich durchführen kann.
Zusammengehalten werden die einzelnen Komponenten von einer typischen LEGOStange, die sich mit dem Servomotor verbinden beziehungsweise daran befestigen
lässt. Hierzu muss selbstverständlich ein Loch im Bahnboden berücksichtigt werden.
Richtet man nun seinen Blick nicht auf die Bahn, sondern unter die Bahn, ist die erwähnte LEGO-Stange zu sehen (Abbildung 3: Steuernder Servomotor). An dieser ist
der Servomotor zu befestigen, damit eine erfolgreiche Verbindung zwischen den einzelnen Elementen gewährleitet werden kann.
4
Vgl. Python Software Verband e.V. (o. J.), Online im Internet.
2
Grundlagen und Technology Stack
6
In diesem Projekt wird der Servomotor „Tower Pro
SG90“ verwendet. Er besitzt eine Operationsgeschwindigkeit von 0,12 Sekunden pro 60 Grad, eine Drehkraft
von 2 Kilogramm pro Zentimeter, eine Arbeitstemperatur
von -30 bis +60 Grad Celsius und eine Arbeitsspannung
von 3,5 bis 8,4 Volt.
Vergleichbare Modelle (wie beispielsweise der Servomotor „Hextronik HXT900“) können ebenfalls verwendet
werden.
Der Servomotor kommt selbstverständlich nicht LEGOAbbildung 3: Steuernder
Servomotor
kompatibel vom Hersteller. Daher empfiehlt es sich, ein
LEGO-Rädchen mit Sekundenkleber an einem der kleinen Hebelarme zu befestigen. Die Praxis zeigt, wenn
auch selbstverständlich, dass der Sekundenkleber unter keinen Umständen in den
Innenraum gelangen darf – das führt automatisch zur Neubeschaffung.
2.5
Kameramodul „Raspberry Pi Camera Rev 1.3“ und
Computer Vision mit SimpleCV
Ein weiteres Herzstück des Projekts ist das
Kameramodul „Raspberry Pi Camera Rev 1.3“
(Abbildung 4: Kameramodul Rev 1.3).
Die Kamera wurde speziell für den Raspberry
Pi entwickelt. Die hier verwendete Kamera ist
das neueste Modell mit der aktuellen Version
„Revision 1.3“. Sie ist mit 24 × 25 mm annähernd quadratisch, knapp 9 mm hoch und
Abbildung 4: Kameramodul Rev 1.3
wiegt nur etwa 3 Gramm. Die inneren Werte
entsprechen dem, was gängige Mobiltelefone
bieten. Der Fokus ist fest und der Sensor liefert 5 Megapixel. Videos nimmt die Kamera
in 1080p, 720p oder 640 × 480 Pixel mit maximal 30 Bildern pro Sekunde auf. Ton er-
2
Grundlagen und Technology Stack
7
fasst das Gerät nicht und Fotos haben eine maximale Auflösung von 2592 × 1944 Pixeln.5
Um das Kameramodul per Python-Code ansprechen zu können, wird die Technologie
„Computer Vision“ benötigt, das sogenannte „Computer-Sehvermögen“: das Forschungsgebiet, das Computern und Robotern versucht, Sehvermögen beizubringen.
Zur Umsetzung der bekannten Problematik, wird in
diesem Projekt SimpleCV genutzt (Abbildung 5: Erkennung der Glasmurmeln mit SimpleCV), bei der es
sich um eine umfangreiche Open-Source-Bibliothek
zur Comuter Vision handelt. Mit SimpleCV ist es relativ einfach, Bilder von der Kamera auszulesen und auf
dem Bildschirm anzuzeigen. Aber was SimpleCV wirkAbbildung 5: Erkennung der
Glasmurmeln mit SimpleCV
lich auszeichnet, sind seine Algorithmen zur Computer
Vision. Neben grundlegenden Bildtransformationen
können vor allem Objekte in Bild oder Video gefunden,
erkannt und verfolgt werden.6
So wird in Kapitel 3.4 erläutert, wie die besagten Glasmurmeln während Echtzeitübertragung des Kamerabilds verarbeitet werden.
5
Vgl. Schmidt, Maik (2013), Online im Internet.
6
Vgl. Demmig, Thomas (2013), Online im Internet.
3
Praktische Umsetzung
8
3
Praktische Umsetzung
3.1
Erläuterung und Funktionsweise der LEGO-Konstruktion
Nachdem nun alle Vorbereitungen auf Basis der erläuterten Grundlagen getroffen wurden und das Technology Stack bereitsteht, geht es an die praktische Umsetzung. Zu
Beginn ist die LEGO-Konstruktion anzufertigen. Die Anlage muss im fallenden Modus
erstellt werden, damit die Kugeln ins Rollen kommen.
Die erste Phase der Konstruktion ist die Einwurfsphase. Hier wird die Glasmurmel in
die Bahn geführt. Nach Möglichkeit ist im Anschluss eine Bahn anzufertigen, die, bevor
die Kugel ihren Lauf nimmt, das Geschehen verlangsamt, damit das Kameramodul
keine Geschwindigkeitsprobleme bekommt und die Glasmurmeln einfangen kann.
Es folgt die zweite entscheidende Phase: die
Rollphase. Hier sollen die Kugeln in guter Geschwindigkeit ihren Weg Richtung Ziel finden,
bevor sie auf den bekannten Steuerungsarm
stoßen.
Dies ist die dritte und letzte Phase. Der Steuerungsarm entscheidet, in welcher Bahn die
Kugeln ins Körbchen rollen. Das bedeutet
Abbildung 6: Aufbewahrungskiste für
Glasmurmeln
folglich, dass es sich anbietet, die letzte Ebene aufzuteilen, damit die Kugeln nicht versehentlich ins falsche Körbchen fallen.
Letztlich kann eine Aufbewahrungskiste für die Glasmurmeln gebaut werden (Abbildung 6: Aufbewahrungskiste für Glasmurmeln). Diese Umsetzung ist nicht „verpflichtend“, gibt der Konstruktion aber den letzten Schliff.
3.2
Installation des Raspberry Pis
Das nachfolgende Kapitel behandelt die Installation des Raspberry Pis. Im Endeffekt
hat der Raspberry Pi keine bestimmte Installation – er ist nach Anschluss direkt einsatzbereit. Jedoch gibt es zwei wesentliche Punkte, die zur bequemen Verwendung
des Kleincomputers beitragen: das Betriebssystem und die statische IP-Adresse.
3
Praktische Umsetzung
9
Das verwendete Betriebssystem ist die offizielle Linux-Distribution für den Raspberry
Pi, das sogenannte Raspbian. Es bietet eine grafische Benutzeroberfläche, einen vorinstallierten Webbrowser sowie passende Treiber für USB- und HDMI-Geräte. Über
die Paketverwaltung lässt sich problemlos weitere Software für den Raspberry Pi nachinstallieren.7
Bei Problemen der Betriebssysteminstallation
empfiehlt sich die Verwendung von Noobs (Abbildung 7: Interface des Installationsmanagers
Noobs). Noobs ist ein Installationsmanager, der die
einfache Installation eines
Betriebssystems auf dem
Raspberry Pi erlaubt. Der
Prozess ist denkbar einAbbildung 7: Interface des Installationsmanagers Noobs
fach: Noobs wird aus dem
Internet
heruntergeladen
und auf eine formatierte SD-Karte kopiert. Die SD-Karte wird dann in den Raspberry Pi
eingelegt, Maus und Tastatur sowie Monitor werden angeschlossen und zu guter Letzt
sorgt der einzusteckende Netzstecker für den Startvorgang des Kleincomputers.8
Des Weiteren ist die Verwendung einer statischen IP-Adresse zu empfehlen: Der
Raspberry Pi bekommt im Normalfall im internen Netzwerk mittels des DHCP-Servers
des Routers automatisch eine IP-Adresse zugewiesen. Es gibt jedoch den Fall, dass
der Router immer wieder eine andere IP-Adresse an den Raspberry Pi vergibt, sodass
man nach jedem Neustart nachsehen muss, welche IP-Adresse der Raspberry Pi nun
hat. Um genau das zu verhindern, muss der Editor Nano mit Admin-Rechten gestartet
und die Daten „Interfaces“ im Ordner Networks editiert werden. Dort lässt sich dann die
IP-Adresse von dynamisch (dhcp) in statisch (static) ändern.
7
Vgl. Humpa, Michael (2015), Online im Internet.
8
Vgl. Humpa, Michael (2015), Online im Internet.
3
Praktische Umsetzung
10
Network = Anwender-IP-Adresse nur mit einer 0 am Ende; Broadcast = Anwender-IPAdresse nur mit 255 am Ende; Gateway = Anwender-IP-Adresse mit einer 1 am Ende.
Der erste Teil der Konfiguration ist damit erledigt. Die IP-Adresse über das Netzwerkkabel ist nun statisch.9
3.3
Programmierung des Steuerungsarms
Ist der Kleincomputer korrekt installiert beziehungsweise konfiguriert und einsatzbereit,
geht es an den nächsten Schritt: die Programmierung des Steuerungsarms.
Als allererstes ist der Servomotor an eine Steckplatine
(das sogenannte Breadboard) mittels Datenleitungen
anzuschließen. Der verwendete Servomotor besitzt drei
zusammengeführte Steckerleitungen: eine gelbe, eine
rote und eine schwarze. Hier sind jeweils (der Einfachheit halber farblich passende) Datenleitungen anzuschließen. Die anderen Enden der Datenleitungen sind
an die Steckplatine anzuschließen (Abbildung 8: Steckplatine). Nun wird ein weiterer Satz Datenleitungen auf
die Platine gegengeschaltet.
Abbildung 8: Steckplatine
Im Falle eines Produktionsfehlers im Servomotor, kann
es zu Überspannungen auf der Datenleitung kommen.
Um den Raspberry Pi vor Schäden zu schützen, wird
deshalb ein elektrischer Widerstand von 1kΩ zwischen die Datenleitung geschaltet.
Die entsprechenden Gegenstücke der Leitungen werden nun an die GPIO-Pins des
Raspberry Pis angeschlossen. Das rote Kabel ist an den Pin 2 zu stecken, das
schwarze an Pin 6 und das gelbe an Pin 12 (GPIO 18, später im Quelltext weitere Informationen):
9
Vgl. Gevert, Jan (2014), Online im Internet.
3
Praktische Umsetzung
11
Abbildung 9: Verwendung der GPIO-Pins
Nun wird nachfolgender Quelltext in eine Datei mit Namen Servo-0.py geschrieben,
die den Servomotor auf seine Ausgangsposition stellt. Besonders interessant ist die
letzte Codezeile, die das Tastverhältnis auf 2,5 ändert (englische Schreibweise beachten). Dieser Wert basiert auf logischen geometrischen Berechnungen.
Servo-0.py
from Tkinter import *
import RPi.GPIO as GPIO
from time import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)
pwm = GPIO.PWM(18, 100)
pwm.start(0)
t = time()
while time() < t + 1:
pwm.ChangeDutyCycle(2.5)
3
Praktische Umsetzung
12
Das entsprechende Gegenstück mit Namen Servo-90.py dreht den Servomotor-Kopf
schließlich um 90 Grad. Hier ändert sich lediglich das Tastverhältnis auf 11.5.
Servo-90.py
from Tkinter import *
import RPi.GPIO as GPIO
from time import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)
pwm = GPIO.PWM(18, 100)
pwm.start(0)
t = time()
while time() < t + 1:
pwm.ChangeDutyCycle(11.5)
In beiden Fällen gilt es, das Augenmerk besonders auf GPIO.setup(18, GPIO.OUT)
zu richten. Diese Zeile zeigt die Zahl 18 als ersten Parameter der Methode. Diese Zahl
steht für den verkabelten GPIO-Pin, wie in obiger Abbildung gezeigt.
3.4
Kameramodul-Konfiguration und SimpleCV-Integration
Um das Kameramodul verwenden zu können, muss es zuerst korrekt an den Raspberry Pi angeschlossen werden. Die CSI-Schnittstelle befindet sich zwischen der HDMIund der Ethernet-Buchse. Um das 15-polige Flachbandkabel vom Kameramodul mit
der Platine zu verbinden, zieht man den oberen Teil des CSI-Steckverbinders etwas
nach oben, steckt dann das Flachbandkabel mit der blauen Markierung zum EthernetAnschluss hin ein und drückt den Verschluss wieder nach unten.
Nun muss noch der Kamera-Support in Raspbian aktiviert werden, was sich am Einfachsten über das Konfigurationstools raspi-config erledigen lässt. Dort wird die
Kamera dann auf „Enable“ gesetzt. Zum Abschluss muss der Raspberry Pi noch neugestartet werden, damit die Kamera einsatzbereit ist.
Um nun im Anschluss daran die neueste Version von SimpleCV zu installieren, müssen folgende Befehle abgesetzt werden:
sudo apt-get install git
git clone git://github.com/sightmachine/SimpleCV.git
cd SimpleCV python
3
Praktische Umsetzung
13
setup.py install
Zum Testen könnte nun eine SimpleCV-Shell aufgerufen werden. Dazu wird simplecv
in die Kommandozeile eingetragen. Jedoch wird ein einfacher Versuch zu einer Fehlermeldung führen. Das hat den Hintergrund, dass der UV4L-Treiber nachgerüstet
werden muss.
Ist das entsprechende Paket nachinstalliert, führt es zu einer weiteren Fehlermeldung:
SimpleCV:1> camera = Camera()
/bin/sh: 1: lsof: not found
/dev/video0 does not support memory mapping
munmap: Invalid argument
munmap: Invalid argument
munmap: Invalid argument
munmap: Invalid argument
Unable to stop the stream.: Bad file descriptor
munmap: Invalid argument
munmap: Invalid argument
munmap: Invalid argument
munmap: Invalid argument
Doch hier haben die SimpleCV-Entwickler „gepatzt“. Die Praxis zeigt, dass ein einfacher Befehl, wie beispielsweise camera.getImage(), reibungslos funktioniert. Die angezeigte Fehlermeldung ist also zu ignorieren – denn strenggenommen ist es keine.
Folglich kann nun die Programmierung mit Python angegangen werden. Als erstes wird
das Kamerabild eingefangen und verarbeitet. Das Bild wird mehrfach editiert und umgekehrt, um schließlich alle nicht gewünschten Werte herauszufiltern. In dem nachfolgenden Beispiel wird alles, was sich im erfassten Bereich befindet, das nicht grün ist,
verworfen. Der dann grüne Bereich wird mit einem gelben Kreis verdeutlicht.
balls-green.py
from SimpleCV import *
cam = Camera()
display = Display()
while display.isNotDone():
image = cam.getImage()
invert = image.invert()
distance = invert.colorDistance(Color.GREEN)
segmented = distance.stretch(230, 255).invert()
3
Praktische Umsetzung
14
binar = segmented.binarize(50)
blobs = binar.findBlobs()
if blobs:
circles = blobs.filter([b.isCircle(1.0) for b in blobs])
if circles:
image.drawCircle((circles[-1].x, circles[-1].y), 20, SimpleCV.Color.YELLOW, 3)
image.show()
Die Zeile distance = invert.colorDistance(Color.GREEN) beschreibt die oben
genannte Thematik. Hier kann nun für GREEN die Eigenschaft RED eingetragen werden, um das gleiche Ergebnis für rote Elemente zu erhalten.
Eine denkbare Erweiterung ist dann, bei gefundenen Kugeln entsprechende Folgeaktivitäten einzuleiten, wie beispielsweise das Speichern der Häufigkeiten. Hierzu wird im
nachfolgenden Kapitel 3.5 weiter eingegangen.
3.5
Zusammenspiel
zwischen
Steuerungsarm
und
Kameramodul
Um nun eine Verbindung zwischen dem Steuerungsarm und dem Kameramodul herzustellen, kann der in Kapitel 3.4 erläuterte Quelltext erweitert werden. Hierzu ist das
Abfragestatement anzupassen.
Immer dann, wenn eine rote Murmel durch das Kamerabild läuft, wird das PythonSkript Servo-0.py ausgeführt, dass den Servomotor dann in Bewegung bringt. Das
gleiche Prinzip ist auch für grüne Erfassungen durchzuführen. Hierbei wird das Gegenstück, das Python-Skript Servo-90.py, ausgeführt.
Parallel dazu werden Zählervariablen definiert und hochgezählt. Diese Werte können
dann per PHP ausgewertet und auf einer Webseite dargestellt werden (Kapitel 4.2).
4
Modulbezogene Netzwerkinstallation
4
Modulbezogene Netzwerkinstallation
4.1
Installation des Apache-Webservers
15
Im nachfolgenden Kapitel wird allgemein der benötigte Webserver installiert.
Damit der Apache-Webserver installiert werden kann, werden Nutzergruppen benötigen – ansonsten schlägt die Installation fehl. Mit den folgenden Befehlen können die
Standardnutzergruppen für den Apachen angelegt werden:
sudo groupadd www-data
sudo usermod -a -G www-data www-data
Mit dem folgenden Befehl wird der Apache installiert:
sudo apt-get install apache2 apache2-doc apache2-utils
Nachdem der Installationsvorgang erfolgreich beendet ist, kann zum Testen bzw. Anzeigen der Webseite der Webbrowser geöffnet und dort die IP-Adresse des Raspberry
Pis eingegeben werden.
Jetzt kann auf PHP, MySQL und phpMyAdmin zurückgegriffen werden. Es empfiehlt
sich, WordPress zu installieren und mittels FTP-Zugang die Verwaltung des Webservers anzugehen. Das nachfolgende Kapitel beschreibt nun die Bereitstellung einer
Webseite auf dem Apachen, die die Durchläufe der Glasmurmeln (Kapitel 4.2) aufzeigt.
4.2
Auswertung der Glasmurmeldurchläufe
Um die Glasmurmeldurchläufe auswerten zu können, muss auf das Python-Skript zurückgegriffen werden, dass die Findung, Erkennung und Verfolgung der Kugeln abdeckt. Hier ist in entsprechende Abfragestatements eine Quelltextzeile zu ergänzen.
Immer dann, wenn eine rote Murmel durch das Kamerabild läuft, muss ein Zähler iRED
hochgezählt werden. Bei einer grünen Murmel wird iGREEN hochgezählt.
Die Inputwerte werden gespeichert und mittels PHP auf die Webseite übertragen. Eine
einfache Abfrage nach Häufigkeit zeigt nun auf, welche Kugelfarbe öfters vertreten
war. Dazu sind die beiden Werte lediglich gegenüberzustellen.
5
Schlussbetrachtung
5
Schlussbetrachtung
5.1
Persönliches Fazit
16
Abschließend möchte ich meine persönliche Meinung zum Projekt(verlauf) beifügen.
Das Prüfungsmodul „Netzwerke“ ist ein sehr interessantes Projekt gewesen. Von vornerein war klar, dass es durchaus möglich ist, mit einem einfachen Thema zu bestehen. Als motivierter Student hat mich dies jedoch weder zufriedengestellt, noch großartig gereizt. Mein persönliches Ziel war, da es sich bei der zu erbringenden Leistung
schließlich um die letzte Prüfungsleistung in meinem Bachelor-Studium handelt, mich
einer besonders kniffeligen Herausforderung anzunehmen. Für die vorgegebene Zeitspanne habe ich mir jedoch zu viel zugemutet. Trotz Unterstützung durch den Modulverantwortlichen und Freunde, kam es schließlich zu zeitlichem und wissenskomplexem Engpass. Das Projekt wurde zwar zum größten Teil abgeschlossen, jedoch
schließlich nicht zu 100 Prozent beendet. Da das Projekt bei den FHDW-Dozenten
Peter Tutt und Alexander Brändle für Interesse gesorgt hat, wird es als fortlaufendes
Projekt weitergeführt und in Zusammenarbeit fertiggestellt.
Kurz gesagt: Das Prüfungsmodul hat sehr viel Spaß gemacht. Es ist erstaunlich, wie
viel Leistungspotenzial ein solcher Kleincomputer mit sich bringt. Einfache Problemstellungen, wie beispielweise die Fernsteuerung von Funksteckdosen oder die webbasierte Steuerung von LED-Lichtern, lassen sich deutlich einfacher umsetzen, als ein großes Projekt in Anlehnung an das Thema „Industrie 4.0“. Das zeigt uns, dass die
Menschheit trotz technologischem Fortschritt noch viel lernen muss…
5.2
Zusammenfassender Projektaufwand
Der gesamte Projektaufwand beläuft sich auf rund 44 Stunden. Diese setzen sich wie
folgt zusammen:
Aufwand Projektmeeting 1: 13:00 Uhr bis 23:30 Uhr (10 Stunden, 30 Minuten)
Aufwand Projektmeeting 2: 14:00 Uhr bis 01:30 Uhr (11 Stunden, 30 Minuten)
Aufwand Projektmeeting 3: 12:00 Uhr bis 24:00 Uhr (12 Stunden)
Installation von OpenCV (Alternative zu SimpleCV) über Nacht: 10 Stunden
Gesamtaufwand in Stunden: 44 Stunden
5
Schlussbetrachtung
5.3
Probleme des Projekts
17
Das Projekt brachte einige Komplikationen mit sich. Insbesondere die fehlenden
Kenntnisse und eine zu komplexe Denkweise in Bezug auf die Verwendung eines
PWM-Controllers (wie im Video gezeigt und schließlich doch nicht verwendet) sowie
die Installation von OpenCV mit einem zeitlichen Aufwand von rund 10 Stunden, verursachten zeitliche und strapaziöse Probleme.
Weitere (kleinere) Probleme werden nicht im Detail aufgezeigt. Die Erfahrung zeigt,
dass ein fremdes Themengebiet und eine daraus resultierende neue Herausforderung
im Informationstechnologiebereich durchaus Komplikationen mit sich bringen können.
5.4
Material-Einkaufsliste
Die nachfolgende Einkaufsliste der Materialien gewährleistet eine erfolgreiche Nachstellung des genannten Projekts. Die Verfügbarkeit von Maus, Tastatur und Monitor
wird hierbei vorausgesetzt. Es ist stets zu berücksichtigen, dass es insbesondere bei
den LEGO-Bauelementen, aber auch bei allen anderen Komponenten, je nach Menge
und Hersteller zu preislichen Abweichungen kommen kann.
LEGO-Konstruktion beziehungsweise LEGO-Bauelemente ........................... 50,00 EUR
Platine „Raspberry Pi 2 Model B“ sowie Netzteil und Gehäuse ...................... 61,99 EUR
Kühlkörper für den Raspberry Pi ...................................................................... 4,29 EUR
SD-Karte für den Raspberry Pi ........................................................................ 4,87 EUR
Kameramodul „Raspberry Pi Camera Rev 1.3“ .............................................. 19,99 EUR
Servomotor „Tower Pro SG90“ ........................................................................ 2,58 EUR
Steckplatine ..................................................................................................... 5,90 EUR
Satz Datenkabel .............................................................................................. 1,95 EUR
Satz Widerstände ............................................................................................ 2,50 EUR
HDMI-Kabel für Monitoranschluss ................................................................... 4,64 EUR
Netzwerkkabel ................................................................................................. 3,95 EUR
Satz Glasmurmeln ........................................................................................... 4,39 EUR
Sperrholzplatte .............................................................................................. 11,49 EUR
5
Schlussbetrachtung
18
Zwischensumme ........................................................................................ 178,54 EUR
Fehlinvestition 1: „PWM-Controller PCA9685“ zur Drehzahlregelung............. 23,95 EUR
Fehlinvestition 2: Ersatzteil Servomotor „Hextronik HXT900“ ........................... 5,98 EUR
Gesamtsumme ........................................................................................... 208,47 EUR
Quellenverzeichnis
19
Quellenverzeichnis
Internetquellen
1
Bundesministerium für Bildung und Forschung (o. J.)
Zukunftsprojekt
Industrie
4.0,
Online
im
Internet:
im
Internet:
http://www.bmbf.de/de/9072.php, Stand: 04.05.2015.
2
optel Media Services GmbH (o. J.)
Bildergalerie:
DHL
Zustellbasis,
Online
http://www.posttip.de/artikel/20018/bildergalerie-dhl-zustellbasis.html,
Stand:
04.05.2015.
3
Schmidt, Florian (2015)
Raspberry Pi 2: Himbeeriger Mini-Rechner im Check, Online im Internet:
http://www.computerbild.de/artikel/cb-Tests-PC-Hardware-Raspberry-Pi-211384246.html, Stand: 08.05.2015.
4
Python Software Verband e.V. (o. J.)
Was
ist
Python?,
Online
im
Internet:
http://www.plone.de/dokumentation/faq/programmiersprache,
Stand:
08.05.2015.
5
Schmidt, Maik (2013)
Erste
Experimente
mit
der
Pi
Camera,
Online
im
http://www.heise.de/make/artikel/Angetestet-Pi-Camera-1874976.html,
Internet:
Stand:
09.05.2015.
6
Demmig, Thomas (2013)
Raspberry Pi für Einsteiger – Installation und Test von SimpleCV, Online im Internet: https://goo.gl/3tM8I7, Stand: 09.05.2015.
7
Humpa, Michael (2015)
Raspbian
"wheezy"
für
Raspberry
Pi,
Online
http://www.chip.de/downloads/Raspbian-wheezy-fuer-RaspberryPi_56691903.html, Stand: 09.05.2015.
im
Internet:
Quellenverzeichnis
8
20
Humpa, Michael (2015)
Noobs (New Out Of The Box Software) für Raspberry Pi, Online im Internet:
http://www.chip.de/downloads/Noobs-New-Out-Of-The-Box-Software-fuerRaspberry-Pi_69333184.html, Stand: 09.05.2015.
9
Gevert, Jan (2014)
Statische IP beim Raspberry Pi einrichten, Online im Internet: http://news.umtsonlinetarife.de/2014/08/statische-ip-beim-raspberry-pi-einrichten/,
10.05.2015.
Stand:
Eidesstattliche Erklärung
21
Eidesstattliche Erklärung
Hiermit erkläre ich, dass ich die vorliegende Seminararbeit selbständig angefertigt habe. Es wurden nur die in dieser schriftlichen Ausarbeitung ausdrücklich benannten
Quellen und Hilfsmittel benutzt. Wörtlich oder sinngemäß übernommenes Gedankengut habe ich als solches kenntlich gemacht. Diese Arbeit hat in gleicher oder ähnlicher
Form noch keiner Prüfungsbehörde vorgelegen.
Ort, Datum
Unterschrift

Download Report