auto mit dem raspberry pi - custom-build-robots.com · ingmar stapel bauanleitung für ein...
TRANSCRIPT
Ingmar Stapel
Bauanleitung für ein ferngesteuertes
Auto
mit dem Raspberry Pi
• Einstieg in die Robotik mit dem Raspberry Pi
• Erklärung der Hardware und Elektronik
• Einführung in die Programmierung mit Scratch und Python zur
Entwicklung der Roboter Software
• Schritt für Schritt Anleitung zum vollständigen Aufbau eines Roboter
Autos mit live Video Streaming
2. vollständig überarbeitete und erweiterte Auflage
Ingmar Stapel studierte technische Informatik und ist aktuell im internationalen Bankenumfeld als IT-
Projektleiter tätig.
Auf seinen privaten Blogs beschäftigt er sich mit den aktuellen Technik Trends und berichtet von seinen
Reisen. Seit 2013 hat er sich Know How im Umfeld der Single Board Computer und der Robotik
erarbeitet. Dieses Wissen teilt er gerne auf Vorträgen zum Thema Robotik mit Interessierten aus der
Do-it-Yourself Szene.
So ist aus seinem neuesten Projekt, ein ferngesteuertes Modellauto auf Basis des Raspberry Pi, dieses
Buch entstanden.
Ich danke meiner Frau Kathrin Stapel, dass Sie mich bei all meinen Projekten unterstützt.
Danke das Du es tolerierst das unser Wohnzimmer von Zeit zu Zeit aussieht wie eine kleine Werkstatt
Autor: Ingmar Stapel
Webseite: http://custom-build-robots.com
E-Mail: [email protected]
Umschlaggestaltung, Illustration: Ingmar Stapel
Lektorat, Korrektorat: Joachim Stapel
2. vollständig überarbeitete und erweiterte Auflage, August 2016.
Das Werk, einschließlich seiner Teile, ist urheberrechtlich geschützt. Alle Rechte vorbehalten. Die Verwendung der Texte und Abbildungen, auch auszugsweise, ist ohne die direkte schriftliche Zustimmung von Ingmar Stapel urheberrechtswidrig und daher strafbar. Dies gilt insbesondere für die Vervielfältigung, Übersetzung oder die Verwendung in elektronischen Systemen. Es wird ausdrücklich darauf hingewiesen, dass die im Buch verwendeten Software- und Hardware-Bezeichnungen sowie Markennamen und Produktbezeichnungen der jeweiligen Firmen im Allgemeinen warenzeichen-, marken- oder patentrechtlichen Schutz unterliegen. Die in diesem Buch verwendeten Software, Hardware und Angaben wurden mit größter Sorgfalt getestet und auf Kompatibilität kontrolliert. Der Autor kann nicht für Schäden haftbar gemacht werden, die im Zusammenhang mit der Verwendung dieses Buches entstehen.
Inhaltsverzeichnis
I
Inhaltsverzeichnis
Inhaltsverzeichnis ..................................................................................................................................... I
Abkürzungsverzeichnis ........................................................................................................................... IV
1 Einleitung ......................................................................................................................................... 1
2 Einführung elektronische Komponenten .......................................................................................... 3
2.1 Raspberry Pi Single Board Computer .......................................................................................4
2.2 Raspberry Pi Kamera Modul .....................................................................................................5
2.3 W-LAN USB Modul ...................................................................................................................6
2.4 Getriebemotoren .......................................................................................................................6
2.5 Motortreiber ...............................................................................................................................7
2.6 Batterie ......................................................................................................................................8
2.7 Step-Down Converter ................................................................................................................9
2.8 Kabel ...................................................................................................................................... 10
3 Übersicht Werkzeuge .................................................................................................................... 11
4 Roboter Auto Chassis .................................................................................................................... 12
4.1 Chassis aus LEGO® Bausteinen ............................................................................................ 12
4.1.1 Aufbau der Getriebemotorhalterung ................................................................................ 13
4.1.2 Fahrgestell montieren ...................................................................................................... 14
4.1.3 Zusammenfassung Chassis aus LEGO® Bausteinen ...................................................... 15
4.2 Chassis aus Acrylglas Bausatz .............................................................................................. 16
4.2.1 Übersicht der Einzelteile .................................................................................................. 16
4.2.2 Zusammenfassung Chassis aus Acrylglas Bausatz ........................................................ 17
4.3 Chassis aus Pappe ................................................................................................................ 18
4.3.1 Cardboard Chassis Modellzeichnung .............................................................................. 19
4.3.2 Einbau der Getriebemotoren und der Elektronik ............................................................. 21
4.3.3 Zusammenfassung Chassis aus Pappe .......................................................................... 23
5 Grundlage der Elektrizitätslehre .................................................................................................... 24
5.1 Elektrische Grundgesetze und Formeln ................................................................................. 24
5.2 Beispielrechnung zu den Grundlagen der Elektrizitätslehre .................................................. 25
5.3 Zusammenfassung – Elektrizitätslehre .................................................................................. 26
6 Verkabelung der elektronischen Komponenten ............................................................................. 27
6.1 Elektronische Komponenten anschließen .............................................................................. 28
6.2 Motortreiber mit Raspberry Pi logisch verbinden ................................................................... 29
6.3 Verkabelung der Getriebemotoren ......................................................................................... 33
6.4 Getriebemotoren mit dem Motortreiber verbinden ................................................................. 34
6.5 Zusammenfassung – Verkabelung ........................................................................................ 34
7 Software Installation und Konfiguration ......................................................................................... 35
7.1 Betriebssystem auf SD Karte vorbereiten .............................................................................. 35
Inhaltsverzeichnis
II
7.2 Raspberry Pi booten .............................................................................................................. 36
7.3 Raspberry Pi aktualisieren ..................................................................................................... 38
7.4 Passwort ändern .................................................................................................................... 39
7.5 Midnight Commander installieren .......................................................................................... 40
7.6 TightVNC Server und Viewer installieren ............................................................................... 42
7.6.1 TightVNC Server installieren ............................................................................................ 42
7.6.2 TightVNC Viewer installieren ........................................................................................... 43
7.7 Samba Server installieren ...................................................................................................... 44
7.8 PuTTY installieren .................................................................................................................. 46
7.9 Python installieren .................................................................................................................. 46
7.10 W-LAN einrichten ................................................................................................................... 47
7.11 Notepad++ installieren ........................................................................................................... 48
7.12 Subversion installieren ........................................................................................................... 48
7.13 Video Streaming Server installieren ....................................................................................... 48
7.14 Zusammenfassung – Software Installation ............................................................................ 50
8 Programmieren mit Scratch ........................................................................................................... 51
8.1 Scratch Programmbeispiel ..................................................................................................... 51
8.2 Roboter Auto Steuerungsprogramm in Scratch ..................................................................... 53
8.3 Zusammenfassung – Programmieren mit Scratch................................................................. 54
9 Programmieren mit Python ............................................................................................................ 55
9.1 Steuerungsprogramm in Python ............................................................................................ 55
9.1.1 Python Programm – RobotControl.py .............................................................................. 56
9.1.2 Python Programm - L298NHBridge.py ............................................................................ 60
9.2 Steuerung starten ................................................................................................................... 66
9.3 Zusammenfassung – Programmierung mit Python ............................................................... 66
10 Raspberry Pi Kamera installieren .................................................................................................. 67
10.1 Kameramodul aktivieren ........................................................................................................ 67
10.2 Kamerafunktion testen ........................................................................................................... 67
10.3 Zusammenfassung – Raspberry Pi Kameramodul ................................................................ 68
11 Live Video Stream ......................................................................................................................... 69
11.1 Kernelmodul bcm2835-v412 laden ........................................................................................ 69
11.2 Mjpg-streamer konfigurieren .................................................................................................. 69
11.3 Modul bcm2835-v4l2 automatisch laden ............................................................................... 71
11.4 Zusammenfassung – Live Video Stream ............................................................................... 72
12 Web-Interface Steuerung über W-LAN .......................................................................................... 73
12.1 WebIOPi Framework installieren ........................................................................................... 73
12.2 Web Interface Steuerung programmieren .............................................................................. 75
12.3 Web-Interface starten ............................................................................................................. 83
12.4 Zusammenfassung – WebIOPi .............................................................................................. 84
13 Autostart der Programme konfigurieren ........................................................................................ 85
Inhaltsverzeichnis
III
13.1 Mjpg-streamer Start Skript anlegen ....................................................................................... 85
13.2 Mjpg-streamer Dienst einrichten ............................................................................................ 87
13.3 RobotControlWeb Dienst einrichten ....................................................................................... 88
13.4 Zusammenfassung – Dienste automatisch Starten ............................................................... 91
14 Kühlung mit passiven Kühlkörper .................................................................................................. 92
15 Ausblick .......................................................................................................................................... 93
Abkürzungsverzeichnis
IV
Abkürzungsverzeichnis
CSI Camera Serial Interface
GPIO General Purpose Input/Output
MAC Media-Access-Control
PWM Pulsweitenmodulation
SID Security Identifier
SSH Secure Shell (Netzwerkprotokoll)
SVN Subversion
VNC Virtual Network Computing
1 Einleitung
1
1 Einleitung
Single Board Computer, wie beispielsweise der Raspberry Pi1, werden immer populärer und haben eine
große Anhängerschaft, die vielfältige Projekte mit den kleinen Rechnern verwirklichen. In Büchern,
Webseiten und Foren werden allgemeine Informationen rund um die Single Board Computer detailliert
erläutert, jedoch fehlt es oft an einer Anleitung zur konkreten Umsetzung eines Projektes. Diese Lücke
wird durch das vorliegende Buch geschlossen, indem der Leser schrittweise durch die einzelnen
Projektphasen geführt wird, mit dem Ergebnis ein individuelles Roboter Auto selbst gebaut zu haben.
Für die Wahl des Raspberry Pi als Steuereinheit für das Roboter Auto, war im Wesentlichen die große
und weltweit aktive Community im Internet ausschlaggebend. Diese unterstützt tatkräftig bei Fragen und
ist ein Nährboden für neue Ideen. Die Computer der Raspberry Pi Foundation werden an Schulen und
in der Forschung verwendet und sind ideal für Do-it-Yourself Projekte wie das hier vorgestellte Roboter
Auto.
Das Buch führt Schritt für Schritt durch das gesamte Projekt bis zum fertigen Roboter Auto. Es wird das
Zusammenspiel aus Hardware, Elektrizität und Software prinzipiell erklärt und anhand konkreter
Beispiele verdeutlicht. So erschließen sich auf spielerische Weise die komplexen Zusammenhänge.
• Dieses Buch beginnt mit einer Vorstellung der elektronischen Komponenten, wie beispielsweise
dem Raspberry Pi und den Motortreiber, die für den Bau des Roboter Autos notwendig sind.
• Anhand von drei Beispielen wird erläutert, wie das Roboter Auto Chassis aus LEGO®2
Bausteinen, aus Pappe oder anhand eines fertigen Bausatzes aufgebaut werden kann.
• Für ein besseres Verständnis der Stromversorgung im Roboter Auto werden die Grundlagen
der Elektrizitätslehre erläutert.
• Anhand zahlreicher Bilder wird die Verkabelung der elektronischen Komponenten
veranschaulicht.
• Die notwendige Software, deren Installation und Konfiguration wird ausführlich erklärt.
• Für Einsteiger in die Programmierung wird in Scratch und in Python jeweils ein Steuerprogramm
für das Roboter Auto beschrieben und zum Download bereitgestellt.
• Die Raspberry Pi Kamera und die Übertragung des live Videos über W-LAN aus dem Roboter
Auto heraus wird ausführlich erläutert.
• Die Steuerung des Roboter Autos über ein Web-Interface sowie das Einrichten von Diensten
wird detailliert beschrieben.
1 Raspberry Pi ist ein eingetragenes Markenzeichen der Raspberry Pi Foundation http://www.raspberry-pi.org. 2 LEGO® ist eine Marke der LEGO® Gruppe, durch die das vorliegende Buch jedoch weder gesponsert noch
autorisiert oder unterstützt wird.
1 Einleitung
2
An wen sich dieses Buch richtet
Die Zielgruppe sind Jugendliche ab einem Alter von 13 Jahren und Erwachsene, die ein Interesse an
Elektronik und Computerhardware haben und selber ein Projekt umsetzen möchten. Grundkenntnisse
in der Programmierung sind nicht zwingend erforderlich.
Zeitaufwand
Das Roboter Auto Projekt ist darauf ausgelegt, dass es an einem Wochenende umgesetzt werden kann.
2 Einführung elektronische Komponenten
3
2 Einführung elektronische Komponenten
Die für den Bau des Roboter Autos notwendigen elektronischen Komponenten werden in diesem Kapitel
vorgestellt. Die wichtigen Basiskomponenten wie beispielsweise der Raspberry Pi, die Getriebemotoren
und die Kamera werden in den nachfolgenden Kapiteln ausführlich erklärt.
Die folgende Übersicht zeigt alle für das Roboter Auto benötigten elektronischen Komponenten.
Komponente Beschreibung
Raspberry Pi 2 Modell B Single Board Computer als zentrale Recheneinheit
Raspberry Pi Kamera Ermöglicht das live Video Streaming
SD-Karte (mind. 8 GB) Speicher für Betriebssystem und Programme
W-LAN USB Modul Ermöglicht die Steuerung über WIFI / W-LAN
Getriebemotor Für den Antrieb des Roboter Autos
Motortreiber Regelt die Geschwindigkeit und Drehrichtung der Motoren
6x Mignon Akkus Stromversorgung für das Roboter Auto
Optional: Ladegerät Externe Stromversorgung für den stationären Betrieb
Step-Down Converter Erzeugt eine 5V Gleichspannung
Kabel Female to Female Jumper, 2-adriges Kupferkabel und Micro-USB
Kabel für die Verkabelung der Komponenten im Roboter Auto
Tabelle 1 Übersicht der elektronischen Komponenten
Auf der nachfolgenden Webseite sind die möglichen Bezugsquellen der einzelnen Komponenten für
das Roboter Auto aufgeführt.
Webseite: http://custom-build-robots.com/roboter-auto-komponenten
Abbildung 1 Roboter Auto Komponentenübersicht
2 Einführung elektronische Komponenten
4
2.1 Raspberry Pi Single Board Computer
Ein Single Board Computer ist ein kleiner mit Elektronik vollgepackter Computer, der meist ein auf Linux
basierendes Betriebssystem nutzt. Diese Scheckkarten großen Computer verfügen in der Regel über
sehr viele Ein- und Ausgänge, die über ein entsprechendes Programm geschaltet werden können. Ein
großer Vorteil dieser kleinen Computer ist, dass sie aus energiesparenden Komponenten aufgebaut
sind und mit einer kleinen Batterie oder Akku betrieben werden können. Der Raspberry Pi wurde von
der britischen Raspberry Pi Foundation entwickelt. Die Idee dabei ist, einen kostengünstigen Rechner
z. B. für Schulen und Jugendliche anzubieten.
Für den Bau des Roboter Autos sind prinzipiell alle aktuell erhältlichen Modelle des Raspberry Pi
geeignet. Auch Modelle von anderen Herstellern wie der Odroid C1+ von Hardkernel oder ein Modell
aus der Arduino Familie eigenen sich generell für den Bau von Roboter Autos.
Für das in diesem Buch beschriebene Roboter Auto Projekt wird der Raspberry Pi 2 Modell B verwendet,
da er mit seiner hohen Rechenleistung den live Video Stream des Roboter Autos hervorragend
verarbeiten kann. Zusätzlich steht für den Raspberry Pi das Wissen einer sehr großen Community in
Foren und Webseiten zur Verfügung. Der Einfachheit halber, wird im weiteren Verlauf des Buches
anstelle von Raspberry Pi 2 Modell B der Begriff Raspberry Pi verwendet.
Abbildung 2 Raspberry Pi 2 Modell B
Auf der Webseite der Raspberry Pi Foundation stehen weitere Informationen über die Raspberry Pi
Familie zur Verfügung:
Webseite: http://www.raspberrypi.org/
2 Einführung elektronische Komponenten
7
werden müssen und die Räder durch einfaches Aufstecken auf der Motorachse befestigt werden. Bei
dem späteren Aufbau des Roboter Autos und der Programmierung der Steuerung ist man sehr flexibel
mit diesem Getriebemotor. Der 4x4 Antrieb des Roboter Autos ermöglicht ein sicheres Vorwärtskommen
über z. B. Teppichkanten und kleine Stufen sowie ein Drehen auf der Stelle.
Das folgende Bild zeigt einen der Getriebemotoren mit aufgestecktem Rad.
Abbildung 7 Getriebemotor mit Rad
2.5 Motortreiber
Damit die Getriebemotoren mit Strom versorgt und angesteuert werden können, ist ein Motortreiber
erforderlich. Mit den typischen Single Board Computer ist es nicht möglich, direkt einen Elektromotor zu
betreiben. Die Ausgänge der kleinen Computer sind zu schwach ausgelegt und können nicht die
benötigte Leistung liefern. Aus diesem Grund wird für das Roboter Auto eine kostengünstige und
zugleich flexible Lösung als Motortreiber gewählt, die genügend Leistung für die Motoren liefert. Als
idealer Motortreiber hat sich die L298N Dual H-Brücke erwiesen. Mit ihr können zwei Motoren getrennt
voneinander angesteuert werden. Der Motortreiber gibt pro Kanal einen Strom von einer Stärke von bis
zu 2A bei einer Spannung von bis zu 24V ab. Diese Leistungsabgabe ist mehr als genug für die
eingesetzten Getriebemotoren. Da pro Seite jeweils zwei Motoren im Modell verbaut werden, sind pro
Kanal der L298N H-Brücke zwei Motoren parallel anzuschließen. Dadurch drehen sich die Motoren auf
einer Seite des Roboter Autos immer gleich schnell.
Der L298N Motortreiber ermöglicht es, die Drehzahl der Motoren beliebig über ein PWM Signal zu
regeln. Diese Geschwindigkeitsansteuerung ist für die Kurvenfahrt, das Drehen auf der Stelle und die
gleichmäßige Beschleunigung bzw. das Bremsen des Roboter Autos sehr wichtig.
Die Motortreiber vom Typ L298N H-Brücke erwarten je nach Modell an den Steuereingängen ein Signal
mit einer Spannung von 5V. Die meisten Single Board Computer sind 3,3V Module. Somit ist bei der
Verwendung des Motortreibers darauf zu achten, dass ein Motortreiber verwendet wird, der mit dem
3,3V Signal des Raspberry Pi zusammenarbeitet. Mit dem in diesem Buch vorgestellten Motortreiber
gibt es keine Probleme im Zusammenspiel mit dem Raspberry Pi und den 3,3V der GPIO Ausgängen.
2 Einführung elektronische Komponenten
8
Auf dem nachfolgenden Bild ist ein Motortreiber auf Basis einer L298N H-Brücke zu sehen. Gut zu
erkennen sind im unteren Teil des Bildes in der Mitte die 6 Eingänge für die logische Ansteuerung des
Motortreibers.
Abbildung 8 Motortreiber L298N H-Brücke
2.6 Batterie
Die im Roboter Auto verbauten Komponenten benötigen unterschiedlich große Spannungen. Der
Raspberry Pi benötigt eine Versorgungsspannung von 5V bei ca. 1,2A. Die Getriebemotoren benötigen
wiederum eine etwas höhere Spannung von 3V bis 6V, aber wesentlich weniger Amper. Möchte man
dann noch sein Auto mit LEDs ausstatten, werden häufig Spannungen von unter 3V benötigt.
Wie sich über viele Versuche herausgestellt hat, ist die beste Lösung für ein Roboter Auto die
Spannungsversorgung über eine einzige Stromquelle. Ein Batteriehalter mit 6 bis 8 AA / Mignon Akkus
hat sich in verschiedenen Modellen bewährt.
Typischerweise hat eine Mignonzelle als Akku eine Spannung von 1,2V bei ca. 1800 mA. Bei der
Verwendung von 6 Mignon Zellen ist so eine Versorgungsspannung für das Roboter Auto von 7,2 V
möglich bei 1800 mA. Bei den Mignonzellen gibt es auch unterschiedlich starke Zellen.
Im nachfolgenden Bild ist der Batteriehalter inkl. sechs AA Batterien mit 2100mA und 1,2V pro Zelle
sowie das Druckknopfanschlusskabel für den Anschluss an den Batteriehalter zu sehen.
4 Roboter Auto Chassis
12
4 Roboter Auto Chassis
Angefangen hatte alles mit der Idee, ein Chassis aus Pappe zu bauen, das sogenannte Cardboard
Roboter Auto. Die Erfahrung hat aber gezeigt, dass der Bau des Chassis aus Pappe zeitaufwändig und
schwierig ist und häufig mehrerer Anläufe bedarf. Als wesentlich einfacher hat sich der Bau eines
Chassis aus LEGO® Bausteinen erwiesen. Eine weitere, sehr komfortable Möglichkeit ist die
Verwendung eines Chassisbausatzes. Die nachfolgenden drei Unterkapitel beschreiben verschiedene
Möglichkeiten, ein Chassis für das Roboter Auto zu bauen:
• Chassis – aus LEGO® Bausteinen
• Chassis – Acrylglas Bausatz
• Chassis – aus Pappe
4.1 Chassis aus LEGO ® Bausteinen
In diesem Kapitel wird beschrieben, wie ein Roboter Auto aus LEGO® Bausteinen aufgebaut wird. Das
Roboter Auto ist aus den LEGO® Bausteinen einfach und schnell zusammengesteckt. Es werden auch
keine speziellen Werkzeuge oder besondere handwerkliche Fähigkeiten benötigt.
Zeitaufwand:
Der Zeitaufwand für den Bau des Chassis beläuft sich auf ca. 20 Minuten.
Abbildung 13 Modell aus LEGO® Bausteinen
Die notwendigen Bausteine für die Motorhalterung können auch im Internet bei spezialisierten
Onlineshops einzeln gekauft werden. Das Wesentliche bei dieser Bauanleitung ist die Motorenhalterung
aus LEGO® Bausteinen. Um die Motorenhalterung herum wird dann das eigentliche Chassis des
Roboter Autos individuell aufgebaut.
4 Roboter Auto Chassis
16
4.2 Chassis aus Acrylglas Bausatz
Es gibt eine Vielzahl von vorgefertigten Chassis. Mit diesen Bausätzen minimiert sich die Komplexität
des Baus eines Roboter Autos deutlich. Der hier vorgestellte Bausatz besteht aus zwei vorgefertigten
Acrylglas Platten. Auf ihnen werden die Getriebemotoren und die weiteren Komponenten des Roboter
Autos befestigt. Mit Gewinde-Messingstiften werden die beiden Acrylglas Platten übereinander
befestigt. Zwischen den beiden Platten bleibt etwas Platz für z. B. den Motortreiber und den Akku.
Zeitaufwand:
Der Zeitaufwand, das Chassis mit den Motoren zusammen zu bauen, beträgt ca. 15 Minuten.
Abbildung 20 Roboter Auto mit Acrylglas Chassis
4.2.1 Übersicht der Einzelteile
Der Bausatz besteht aus den folgenden Einzelteilen:
• 2 x Acrylglas Platten
• 4 x Getriebemotoren
• 4 x Räder
• 4 x 20 Loch-Encoder (werden für dieses Projekt nicht verwendet)
• 6 x Gewindestifte aus Messing (Abstandhalter)
• Verschiedene Schrauben, Muttern und Motorenhalter aus Acrylglas
6 Verkabelung der elektronischen Komponenten
27
6 Verkabelung der elektronischen Komponenten
In diesem Kapitel geht es darum, alle Komponenten des Roboter Autos miteinander zu verkabeln. Für
die Kommunikation zwischen Raspberry Pi und dem Motortreiber werden 6 der 40 Anschlüsse der
Stiftleiste des Raspberry Pis benötigt.
Zeitaufwand:
Die Verkabelung mit den kleineren Lötarbeiten dauert ca. 90 Minuten.
Das nachfolgende Bild zeigt die Stiftleiste auf einem Raspberry Pi:
Abbildung 31 Raspberry Pi 40 polige Stiftleiste
Für die ersten Tests wird das Modell am besten stationär betrieben, um nicht den Akku anschließen zu
müssen der eine begrenzte Laufzeit bedingt durch die verwendeten Batterien hat. Für den stationären
Betrieb wird ein Netzteil benötigt mit min. 7V bis max. 9V Gleichstrom und mindestens 2A. Das hier
gezeigte Netzteil verfügt über einen Regler für verschiedene Ausgangsspannungen.
Abbildung 32 Netzteil für den stationären Betrieb
6 Verkabelung der elektronischen Komponenten
28
Das Netzteil wird anstelle der Batterie angeschlossen. Sollte kein Netzteil wie beschrieben verfügbar
sein, können die weiteren Schritte auch mit dem Akku durchgeführt werden.
Nachfolgend wird der Aufbau und die Verkabelung des Roboter Autos am Beispiel der Batterie
beschrieben.
Benötigte Komponenten
• 1 x Raspberry Pi
• 4 x Getriebemotor
• 1 x micro-USB Kabel
• 1 x L298N H-Brücke / Motortreiber
• 1 x Step-Down Converter
• 5 x 20cm Kupferkabel zweiadrig
• 1 x Batteriehalter
• 1 x Kabel mit Druckknopfanschluss am Batteriehalter
• 6 x Female to Female Jumper Kabel
Die Verkabelung der elektronischen Komponenten ist in 4 Abschnitte unterteilt.
• Anschließen der elektronischen Komponenten an die Batterie für die Stromversorgung
• Motortreiber mit Raspberry Pi logisch verbinden
• Verkabelung der Getriebemotoren
• Getriebemotoren mit dem Motortreiber verbinden
6.1 Elektronische Komponenten anschließen
Der Motortreiber wird zusammen mit dem Step-Down Converter von der Batterie mit Strom versorgt.
Die drei blauen Lüsterklemmen des Motortreibers sind mit VMS, GND und 5V beschriftet. Die
Beschriftung bedeutet im Einzelnen:
• VMS = die Versorgungsspannung
• GND = Erdung
• 5V = Ausgangsspannung (Die 5V Spannung ist nicht stabil genug für den Raspberry Pi)
Die beiden Lüsterklemmen VMS und GND sind als Eingänge für die Stromversorgung vorgesehen. In
die beiden Lüsterklemmen des Motortreibers wird eines der 20cm langen zweiadrigen Kupferkabel
sowie das Druckknopfanschlusskabel für die Batterie angeschlossen.
Bitte darauf achten, dass die Pole VMS für + und GND für - richtig angeschlossen werden. Der Pluspol
(VMS) wird generell mit dem roten Kabel verbunden, die Erdung (GND) wird generell mit dem
schwarzen Kabel verbunden.
7 Software Installation und Konfiguration
35
7 Software Installation und Konfiguration
In diesem Kapitel wird erklärt, welche Software auf dem Raspberry Pi und dem PC installiert wird. Da
das Roboter Auto mobil ist und weder Monitor noch Tastatur besitzt, wird es so konfiguriert, dass remote
auf den Raspberry Pi für die Programmierung, Konfiguration und Steuerung zugegriffen werden kann.
Remote bedeutet, dass der Zugriff über W-LAN auf den Raspberry Pi erfolgt.
Die nachfolgende Tabelle stellt eine Übersicht der zu installierenden Programme bereit.
Was Wo Nutzen
Raspbian Raspberry Pi Raspberry Pi Betriebssystem inkl. Programme
Midnight Commander Raspberry Pi Dateiexplorer für das Terminal Fenster
TightVNC Server Raspberry Pi Remote Desktop Server
TightVNC Viewer Windows Rechner Remote Desktop Viewer
Samba Server Raspberry Pi Netzwerkfreigabe
PuTTY Windows Rechner Zugriff über eine Remote Shell
Python Raspberry Pi Programmiersprache
W-LAN Raspberry Pi Netzwerkzugriff über W-LAN
Notepad++ Windows Rechner Erweiterter Texteditor unter Windows
Subversion Raspberry Pi Zentrale Software Versionsverwaltung
Mjpg-streamer Raspberry Pi Live Video Streaming
Tabelle 9 Software Auswahl
Die nachfolgenden Kapitel beschreiben detailliert die Software Installation und Konfiguration.
7.1 Betriebssystem auf SD Karte vorbereiten
Das für dieses Projekt verwendete Raspberry Pi Betriebssystem basiert auf Debian, einer Linux
Distribution, und wird von der Raspberry Pi Foundation unter dem Namen Raspbian (Raspberry Pi +
Debian = Raspbian) veröffentlicht.
Als erstes wird die SD-Karte soweit konfiguriert, dass der Raspberry Pi hochgefahren werden kann.
Dazu wird eine sogenannte Image Datei mit Raspbian als Betriebssystem benötigt. Es stehen
verschiedene Image Dateien auf der Seite von RaspberryPi.org zum Download bereit. Bitte wählt dort
das neueste Raspbian Image (full version) aus:
Webseite : http://www.raspberrypi.org/downloads/
Wenn das Image als ZIP Datei heruntergeladen ist, dieses bitte entpacken. In einem nächsten Schritt
muss das entpackte Image auf die SD Karte installiert werden. Dazu gibt es verschiedene Tools, die
die Installation durchführen.
Eine Anleitung, wie das Image auf der SD-Karte installiert wird, folgt hier:
8 Programmieren mit Scratch
51
8 Programmieren mit Scratch
Scratch5 ist eine Programmierumgebung, die von dem MIT-Scratch-Team für Kinder und Jugendliche
entwickelt wurde. In der Scratch eigenen Entwicklungsumgebung werden Programme visuell entwickelt.
So ist es möglich, Kindern und Jugendlichen die Grundprinzipien der Computerprogrammierung
spielerisch beizubringen.
Seit September 2015 wird Scratch von der Raspberry Pi Foundation für den Einsatz auf dem Raspberry
Pi zusammen mit dem Raspbian Jessie Betriebssystem angeboten. Interessant ist Scratch für das
Roboter Auto Projekt geworden, da die Ansteuerung der GPIOs mit einem PWM Signal ermöglicht wird.
So ist es möglich, die Geschwindigkeit der Motoren des Roboter Autos zu regeln.
Die Entwicklungsumgebung Scratch wird über das grafische Menü des Raspberry pi unter „Menu ->
Programming -> Scratch“ aufgerufen.
Abbildung 53: Scratch Entwicklungsumgebung
8.1 Scratch Programmbeispiel
Die Programmierung mit Scratch beginnt mit der Initialisierung der GPIO Pins. In diesem Beispiel soll
der GPIO Pin 4 als „out“ / „pwm“ konfiguriert werden. Damit kann ein PWM Signal über den Pin 4 an
den Motortreiber gesendet und somit die Geschwindigkeit eines Motors geregelt werden. Mit den beiden
GPIO Pins 22, 27 wird die Drehrichtung des Motors festgelegt.
Im Folgenden wird die Auswahl der Funktionsbausteine zur Erstellung eines Einführungsprogramms in
Scratch beschrieben, um die Basisfunktionen kennen zu lernen:
1. Im Menüpunkt „Control“ (gelber Button) wird die Funktion „When clicked“ mit der grünen Fahne
ausgewählt. Diese Initialfunktion dient zum Starten des Programmes und muss zum
Programmstart mit der linken Maustaste angeklickt werden um diese zu starten.
5 Viele Informationen rund um Scratch sind auf der folgenden Webseite zu finden: https://scratch.mit.edu
8 Programmieren mit Scratch
52
2. Daran anschließend wird die Funktion „broadcast“ angefügt. Sie hat in diesem Beispiel die
Aufgabe den GPIO-Server zu starten. Dazu wird der Befehl „gpioserveron“ in der Funktion
eingetragen.
3. Es folgt eine „broadcast“ Funktion die den GPIO Pin 22 als „out“ definiert.
4. Es folgt eine weitere „broadcast“ Funktion die den GPIO Pin 27 ebenfalls als „out“ definiert.
5. In einer weiteren „broadcast“ Funktion wird der GPIO Pin 22 auf „on“ gesetzt.
6. Daran anschließend folgt eine „broadcast“ Funktion die den GPIO Pin 27 als „off“ definiert.
7. Daran angefügt kommt eine „broadcast“ Funktion, die den GPIO Pin 4 mit dem Befehl
„config4outputpwm“ als „pwm out“ bestimmt.
8. Die jetzt folgende broadcast Funktion ist eine Kombination aus „broadcast“ und „join“ Funktion.
Die join Funktion findet sich unter dem grünen Menüpunkt von Scratch mit dem Namen
„Operators“. Diese beiden kombinierten Funktionen steuern die Geschwindigkeit der Motoren.
In diesem Beispiel wird ein Signal von 50% erzeugt, sodass 50% der maximalen Leistung am
Motor anliegt.
9. Anschließend wird mit der Funktion „wait“ 2 Sekunden lang das PWM Signal am Pin 4 erzeugt,
damit sich der Motor 2 Sekunden lang dreht.
10. Mit der letzten Funktion wird das PWM Signal am GPIO Pin 4 wieder auf 0% gesetzt, sprich der
Motor wird gestoppt.
In Scratch programmiert sieht das Programm wie folgt aus.
Abbildung 54 Scratch Beispiel
Dieses einfache Scratch Programm zeigt wie durch die Auswahl der geeigneten Funktionsbausteine ein
Motor 2 Sekunden lang gedreht werden kann. Im jetzt folgenden Abschnitt wird das wesentlich
komplexere Steuerungsprogramm für das Roboter Auto vorgestellt.
9 Programmieren mit Python
55
9 Programmieren mit Python
In diesem Kapitel geht es um die Programmierung des Python Programms für die Fahrzeugsteuerung.
Das Ziel ist es, mit dem ersten selbst geschriebenen Python Programm das Roboter Auto über die
Konsole mit der Tastatur fernzusteuern. Mit diesem Verständnis können neben dem Roboter Auto noch
viele weitere Projekte entstehen wie z. B. die Steuerung eines Bootes oder das einfache Blinken lassen
von LEDs.
Im folgenden Kapitel werden die ersten Erfahrungen gesammelt, wie die Ansteuerung der GPIOs mit
einem Python Programm funktioniert. In Kapitel 12 wird die Steuerung über ein Web-Interface vorgestellt
und programmiert.
Voraussetzungen prüfen:
Die erste Voraussetzung, die erfüllt sein muss, ist die vollumfängliche Abarbeitung des Kapitels 7.
9.1 Steuerungsprogramm in Python
Bitte einen neuen Ordner im Home-Verzeichnis des Users Pi mit dem Namen z. B. „robot“ anlegen.
Diesen mit den entsprechenden Rechten über das Terminal Fenster versehen, so dass dieser Ordner
über die Samba Freigabe zugreifbar ist. Der entsprechende Befehl für die Anpassung der Rechte des
Ordners ist wie folgt.
Befehl:
sudo chmod a+rw robot
Jetzt ist dieser Ordner über die Samba Freigabe für den Windows PC erreichbar, und es können die
beiden Python Programme „RobotControl.py“ und „L298NHBridge.py“ direkt dort abgelegt werden.
Die Python Programme werden mit dem Texteditor Notepad++ erstellt. Die Datei für die Steuerung über
die Tastatur soll den Namen „RobotControl.py“ erhalten. Die zweite Datei für die Ansteuerung des
Motortreibers erhält den Namen „L298NHBridge.py“.
Abbildung 56 RobotControl.py Python Programm
9 Programmieren mit Python
56
9.1.1 Python Programm – RobotControl.py
Mit dem Programm „RobotControl.py“ wird das Roboter Auto über das Terminal Fenster oder über
PuTTY ferngesteuert. Wird das Programm ausgeführt, erscheint ein kleines Menü in der Konsole, das
die Tastaturbelegung erläutert.
Den nachfolgend grau markierten Quellcode des Programmes bitte in die Zwischenablage kopieren und
im Notepad++ in die Datei „RobotControl.py“ einfügen und in dem Ordner „/home/pi/robot“ auf dem
Raspberry Pi abspeichern.
Innerhalb des Quellcodes der jeweiligen Python Programme sind Erklärungen eingefügt, die die
Funktionen und Konfigurationsmöglichkeiten im Programm weiter erklären.
#!/usr/bin/env python
# coding: latin-1
# Autor: Ingmar Stapel
# Datum: 20160731
# Version: 2.0
# Homepage: http://custom-build-robots.com
# Dieses Programm ist das sogenannte Steuerprogramm fuer das Roboter
# Auto ueber die Konsole und Tastatur vom PC aus.
# Es werden verschiedene Python Klassen importiert deren Funktionen
# im Programm benoetigt werden fuer die Programmverarbeitung.
import sys, tty, termios, os, readchar
# Das Programm L298NHBridge.py wird als Modul geladen. Es stellt
# die Funktionen fuer die Steuerung der H-Bruecke zur Verfuegung.
import L298NHBridge as HBridge
# Variablen Definition der linken und rechten Geschwindigkeit der
# Motoren des Roboter-Autos.
speedleft = 0
speedright = 0
# Das Menue fuer den Anwender wenn er das Programm ausfuehrt.
# Das Menue erklaert mit welchen Tasten das Auto gesteuert wird.
print("w/s: direction")
print("a/d: steering")
print("q: stops the motors")
print("p: print motor speed (L/R)")
print("x: exit")
9 Programmieren mit Python
57
# Die Funktion getch() nimmt die Tastatureingabe des Anwenders
# entgegen. Die gedrueckten Buchstaben werden eingelesen. Sie werden
# benoetigt um die Richtung und Geschwindigkeit des Roboter-Autos
# festlegen zu koennen.
def getch():
ch = readchar.readchar()
return ch
# Die Funktion printscreen() gibt immer das aktuelle Menue aus
# sowie die Geschwindigkeit der linken und rechten Motoren wenn
# es aufgerufen wird.
def printscreen():
# der Befehl os.system('clear') leert den Bildschirmihalt vor
# jeder Aktualisierung der Anzeige. So bleibt das Menue stehen
# und die Bildschirmanzeige im Terminal Fenster steht still.
os.system('clear')
print("w/s: beschleunigen")
print("a/d: lenken")
print("q: stoppt die Motoren")
print("x: Programm beenden")
print("========== Geschwindigkeitsanzeige ==========")
print "Geschwindigkeit linker Motor: ", speedleft
print "Geschwindigkeit rechter Motor: ", speedright
# Diese Endlosschleife wird erst dann beendet wenn der Anwender
# die Taste X tippt. Solange das Programm laeuft wird ueber diese
# Schleife die Eingabe der Tastatur eingelesen.
while True:
# Mit dem Aufruf der Funktion getch() wird die Tastatureingabe
# des Anwenders eingelesen. Die Funktion getch() liesst den
# gedrueckte Buchstabe ein und uebergibt diesen an die
# Variablechar. So kann mit der Variable char weiter
# gearbeitet werden.
char = getch()
# Das Roboter-Auto faehrt vorwaerts wenn der Anwender die
# Taste "w" drueckt.
if(char == "w"):
# das Roboter-Auto beschleunigt in Schritten von 10%
11 Live Video Stream
69
11 Live Video Stream
Für die Konfiguration des live Video Streamings sind Systemanpassungen an der Installation des
Raspberry Pi notwendig. So muss der von der Raspberry Pi Foundation und Broadcom entwickelte
V4L2 Treiber installiert werden bzw. das dazugehörige Modul geladen werden.
Anschließend müssen kleinere Anpassungen vorgenommen werden, bis die volle Funktionalität des
Videostreamings funktioniert. Dazu dann mehr in den folgenden Unterkapiteln.
Zeitaufwand:
Der Zeitaufwand beträgt ca. 45 Minuten.
11.1 Kernelmodul bcm2835-v412 laden
Für das Laden des Kernelmoduls „bcm2835-v4l2“ muss folgender Befehl ausgeführt werden.
Befehl:
sudo modprobe bcm2835-v4l2
� Wichtig ist, dass die Raspberry Pi Kamera angeschlo ssen ist und in der
Konfiguration des Raspberry Pi aktiviert wurde. And ernfalls kommt es zu
einem Fehler bei dem Ausführen des Befehls.
Der folgende Befehl zeigt alle geladenen Kernelmodule. Damit lässt sich beispielsweise überprüfen, ob
das Modul „bcm2835-v4l2“ geladen ist.
Befehl:
sudo lsmod
Auf der folgenden Webseite erfährt man mehr zu Ubuntu und den Kernelmodulen im Allgemeinen.
Webseite: http://wiki.ubuntuusers.de/Kernelmodule
11.2 Mjpg-streamer konfigurieren
Jetzt erfolgt die finale Konfiguration des mjpg-streamers unter Raspbian.
Dazu bitte wieder mit dem Midnight Commander die Datei „/opt/mjpg-streamer/start.sh“ öffnen und die
nachfolgende Zeile suchen:
./mjpg_streamer -i "./input_uvc.so" -o "./output_ht tp.so -w ./www"
12 Web-Interface Steuerung über W-LAN
73
12 Web-Interface Steuerung über W-LAN
Dieses Kapitel behandelt die Umsetzung eines Web-Interfaces zur Steuerung des Roboter Autos mit
einem Web-Browser. Das Web-Interface des Roboter Autos kann über einen Web-Browser von einem
Smartphone, Laptop oder Tablet aus aufgerufen werden. Das Interface zeigt dann die für die Steuerung
des Autos notwendigen Funktionen sowie das live Video aus dem Auto heraus an.
Als einfache Webseite mit einem Overlay realisiert, zeigt das Web-Interface die vier Tasten für die
Vorwärts-, Rückwärts-, Links- und Rechts- Fahrt an. Die fünfte Taste in der Mitte des Bedienfeldes
stoppt die Motoren. Als Hintergrundbild der Steuerung wird die aktuelle Sicht aus dem Roboter Auto
heraus angezeigt.
Zeitaufwand:
Der Zeitaufwand für die Konfiguration und Entwicklung des Web-Interface beträgt ca. 2 Stunden.
Abbildung 62 Web-Interface Steuerung
12.1 WebIOPi Framework installieren
Für die Kommunikation zwischen Webseite (Web-Interface) und den GPIOs des Raspberry Pi wird
WebIOPi eingesetzt. Die hier beschriebene Anleitung bezieht sich auf die Version 0.7.1 von WebIOPi.
WebIOPi übernimmt hier neben der Ansteuerung der GPIOs zusätzlich die Funktion eines Web-Servers
und stellt für den Webzugriff die Webseite online. So kann über die IP Adresse des Raspberry Pi das
Web-Interface aufgerufen werden.
Auf der Webseite von WebIOPi gibt es neben einer ausführlichen Einführung und
Programmierbeispielen das WebIOPi Paket zum Download.
Webseite: http://webiopi.trouch.com/
15 Ausblick
93
15 Ausblick
Das vermittelte Wissen aus diesem Buch kann als Basis gesehen werden, weitere Projekte mit dem
Raspberry Pi umzusetzen. Die Erfahrung, wie der Raspberry Pi in Interaktion mit der Außenwelt treten
kann, ermöglicht die Umsetzung vieler Ideen vor allem im Bereich des Internet of Things, dem Internet
der Dinge. Das Beispiel des hier in diesem Buch gebauten Roboter Autos zeigt genau diesen Trend
auf. Das Roboter Auto hat eine eindeutige IP Adresse und ist aus dem Internet heraus erreichbar und
steuerbar. So sind viele Anwendungsmöglichkeiten denkbar, wie der Prototyp des Discoverer zeigt, ein
mit GPS Empfänger und Metalldetektor ausgestattetes Schatz- bzw. Metallsuchfahrzeug.
Abbildung 67 Roboter Auto - Discoverer
Autonom fahrende Roboter Auto
Keine Lust mehr das Roboter-Auto selbst fernzusteuern? Dann tunen Sie doch ihr Roboter-Auto mit
Sensoren und Co. für das autonome Fahren!
Wie das funktioniert und welche Komponenten Sie dazu benötigen beschreibt das Buch „Roboter-Autos
mit dem Raspberry Pi: Planen, bauen, programmieren“ welches auf diesem E-Book aufsetzt und von
mir geschrieben wurde.
Sie finden das Buch z. B. auf der Amazon Seite unter der folgenden URL.
Webseite : Amazon
Weitere Ideen für Roboter Autos und Bilder aus der Community gibt es hier:
Webseite : http://custom-build-robots.com/hall-of-fame
Wer sein Roboter Auto ebenfalls auf der Webseite zeigen möchte, schickt ein Bild an:
E-Mail: [email protected]