2., aktualisierte und erweiterte Auflage Raspberry-Pi … · Simon Monk: Raspberry-Pi-Kochbuch...

Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 2017

Raspberry-Pi-Kochbuch2., aktualisierte und erweiterte Auflage

Simon Monk

Deutsche Übersetzung von Peter Klicman

033-5.book Seite III Montag, 14. November 2016 1:31 13

Simon Monk

Lektorat: Dr. Michael BarabasÜbersetzung: Peter KlicmannAktualisierungen: Maik SchmidtKorrektorat: Ursula ZimpferSatz: III-satz, www.drei-satz.deHerstellung: Susanne BröckelmannUmschlaggestaltung: Michael Oréal, www.oreal.deDruck und Bindung: M.P. Media-Print Informationstechnologie GmbH, 33100 Paderborn

Bibliografische Information Der Deutschen Nationalbibliothek Die Deutsche Nationalbibliothek ver-zeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.

ISBN: Print 978-3-96009-033-5PDF 978-3-96088-115-1ePub 978-3-96088-116-2mobi 978-3-96088-117-9

2. Auflage 2017

Dieses Buch erscheint in Kooperation mit O’Reilly Media, Inc. unter dem Imprint »O’REILLY«. O’REILLY ist ein Markenzeichen und eine eingetragene Marke von O’Reilly Media, Inc. und wird mit Einwilligung des Eigentümers verwendet.

Copyright © 2017 dpunkt.verlag GmbHWieblinger Weg 17 69123 Heidelberg

Authorized German translation of the English edition of Raspberry Pi Cookbook, 2nd Edition, ISBN 9781491939109 © 2016 Simon MonkThis translation is published and sold by permission of O’Reilly Media, Inc., which owns or controls all rights to sell the same.

Die vorliegende Publikation ist urheberrechtlich geschützt. Alle Rechte vorbehalten. Die Verwendung der Texte und Abbildungen, auch auszugsweise, ist ohne die schriftliche Zustimmung des Verlags urheber-rechtswidrig und daher strafbar. Dies gilt insbesondere für die Vervielfältigung, Übersetzung oder die Verwendung in elektronischen Systemen.

Es wird darauf hingewiesen, dass die im Buch verwendeten Soft- und Hardware-Bezeichnungen sowie Markennamen und Produktbezeichnungen der jeweiligen Firmen im Allgemeinen warenzeichen-, marken- oder patentrechtlichem Schutz unterliegen.

Die Informationen in diesem Buch wurden mit größter Sorgfalt erarbeitet. Dennoch können Fehler nicht vollständig ausgeschlossen werden. Verlag, Autoren und Übersetzer übernehmen keine juristische Verant-wortung oder irgendeine Haftung für eventuell verbliebene Fehler und deren Folgen. Alle Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt und sind möglicherweise eingetragene Warenzeichen. Der Verlag richtet sich im Wesentlichen nach den Schreibweisen der Hersteller. Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektroni-schen Systemen. Kommentare und Fragen können Sie gerne an uns richten:

5 4 3 2 1 0

033-5.book Seite IV Montag, 14. November 2016 1:31 13

Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 2017Inhalt | V

Inhalt

Vorwort zur zweiten Auflage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XIII

1 Setup und Betrieb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.1 Ein Raspberry-Pi-Modell wählen . . . . . . . . . . . . . . . . . . . . . . 11.2 Ein Gehäuse für den Raspberry Pi . . . . . . . . . . . . . . . . . . . . . . 31.3 Auswahl eines Netzteils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.4 Eine Betriebssystem-Distribution wählen . . . . . . . . . . . . . . . . 61.5 Eine MicroSD-Karte mit NOOBS beschreiben . . . . . . . . . . . . 71.6 Das System anschließen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.7 Einen DVI- oder VGA-Monitor anschließen . . . . . . . . . . . . . . 111.8 Einen Composite-Monitor oder Fernseher verwenden . . . . . . 121.9 Die Bildgröße auf Ihrem Monitor anpassen . . . . . . . . . . . . . . 13

1.10 Die Leistung maximieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151.11 Das Passwort ändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171.12 Den Pi direkt in ein Terminal booten . . . . . . . . . . . . . . . . . . . 181.13 Den Raspberry Pi herunterfahren . . . . . . . . . . . . . . . . . . . . . . 191.14 Ein Raspberry-Pi-Kameramodul installieren . . . . . . . . . . . . . . 211.15 Bluetooth nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

2 Vernetzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272.1 Kabelgebundener Anschluss an ein Netzwerk . . . . . . . . . . . . 272.2 Die IP-Adresse ermitteln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292.3 Eine statische IP-Adresse einstellen . . . . . . . . . . . . . . . . . . . . . 312.4 Den Netzwerknamen eines Raspberry Pi einstellen . . . . . . . . 332.5 Eine WLAN-Verbindung einrichten . . . . . . . . . . . . . . . . . . . . 342.6 Anschluss per Konsolenkabel . . . . . . . . . . . . . . . . . . . . . . . . . 362.7 Den Pi entfernt über SSH steuern . . . . . . . . . . . . . . . . . . . . . . 392.8 Den Pi entfernt per VNC steuern . . . . . . . . . . . . . . . . . . . . . . 412.9 Den Pi entfernt per RDP steuern . . . . . . . . . . . . . . . . . . . . . . . 42

2.10 Filesharing in einem Mac-Netzwerk . . . . . . . . . . . . . . . . . . . . 44

033-5.book Seite V Montag, 14. November 2016 1:31 13

VI | Inhalt

2.11 Den Pi-Screen auf dem Mac nutzen . . . . . . . . . . . . . . . . . . . . 462.12 Einen Raspberry Pi als NAS (Network Attached Storage)

nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472.13 Im Netzwerk drucken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

3 Betriebssystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533.1 Dateien grafisch verschieben . . . . . . . . . . . . . . . . . . . . . . . . . 533.2 Eine Terminal-Session starten . . . . . . . . . . . . . . . . . . . . . . . . 543.3 In einem Terminal durch das Dateisystem navigieren . . . . . . 553.4 Dateien oder Ordner kopieren . . . . . . . . . . . . . . . . . . . . . . . . 593.5 Dateien oder Ordner umbenennen . . . . . . . . . . . . . . . . . . . . 603.6 Eine Datei editieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613.7 Den Inhalt einer Datei ansehen . . . . . . . . . . . . . . . . . . . . . . . 633.8 Eine Datei ohne Editor erzeugen . . . . . . . . . . . . . . . . . . . . . . 643.9 Ein Verzeichnis anlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

3.10 Dateien oder Verzeichnisse löschen . . . . . . . . . . . . . . . . . . . . 653.11 Befehle mit Superuser-Rechten ausführen . . . . . . . . . . . . . . . 663.12 Dateizugriffsrechte verstehen . . . . . . . . . . . . . . . . . . . . . . . . . 673.13 Dateizugriffsrechte ändern . . . . . . . . . . . . . . . . . . . . . . . . . . . 693.14 Den Eigentümer einer Datei ändern . . . . . . . . . . . . . . . . . . . . 703.15 Einen Screenshot erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . 713.16 Software installieren mit apt-get . . . . . . . . . . . . . . . . . . . . . . . 723.17 Installierte Software mit apt-get löschen . . . . . . . . . . . . . . . . 733.18 Python-Pakete per pip installieren . . . . . . . . . . . . . . . . . . . . . 743.19 Dateien über die Kommandozeile herunterladen . . . . . . . . . . 753.20 Quellcode mit Git herunterladen . . . . . . . . . . . . . . . . . . . . . . 763.21 Ein Programm oder Skript beim Booten automatisch

ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 763.22 Ein Programm oder Skript beim Booten automatisch als

Service ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 773.23 Ein Programm oder Skript in regelmäßigen Abständen

automatisch ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 793.24 Das Verzeichnissystem durchsuchen . . . . . . . . . . . . . . . . . . . 803.25 Die Kommandozeilen-Historie nutzen . . . . . . . . . . . . . . . . . . 813.26 Die Prozessoraktivität überwachen . . . . . . . . . . . . . . . . . . . . 833.27 Mit Archivdateien arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . 853.28 Angeschlossene USB-Geräte auflisten . . . . . . . . . . . . . . . . . . 863.29 Ausgaben der Befehlszeile in eine Datei umleiten . . . . . . . . . 863.30 Dateien verketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 873.31 Pipes nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 883.32 Die Ausgabe im Terminal unterbinden . . . . . . . . . . . . . . . . . 893.33 Programme im Hintergrund ausführen . . . . . . . . . . . . . . . . . 89

033-5.book Seite VI Montag, 14. November 2016 1:31 13

Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 2017Inhalt | VII

3.34 Befehls-Aliase anlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 903.35 Datum und Uhrzeit setzen . . . . . . . . . . . . . . . . . . . . . . . . . . . 913.36 Freien Speicherplatz auf der SD-Karte ermitteln . . . . . . . . . . . 92

4 Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 934.1 Ein Mediacenter einrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . 934.2 Office-Software auf dem Raspi nutzen . . . . . . . . . . . . . . . . . . 954.3 Andere Browser installieren . . . . . . . . . . . . . . . . . . . . . . . . . . 964.4 Einen Webcam-Server einrichten . . . . . . . . . . . . . . . . . . . . . . 974.5 Einen Emulator für klassische Spielekonsolen ausführen . . . . 1004.6 Minecraft Pi Edition ausführen . . . . . . . . . . . . . . . . . . . . . . . . 1014.7 Einen Minecraft-Server ausführen . . . . . . . . . . . . . . . . . . . . . . 1034.8 Raspberry-Pi-Radiosender . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1054.9 GIMP ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

4.10 Internetradio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

5 Python-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1115.1 Zwischen Python 2 und Python 3 wählen . . . . . . . . . . . . . . . . 1115.2 Python-Programme mit IDLE editieren . . . . . . . . . . . . . . . . . 1125.3 Die Python-Konsole nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . 1145.4 Python-Programme über das Terminal ausführen . . . . . . . . . 1155.5 Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1175.6 Werte ausgeben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1175.7 Benutzereingaben einlesen . . . . . . . . . . . . . . . . . . . . . . . . . . . 1185.8 Arithmetik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1195.9 Strings erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

5.10 Strings verketten (verbinden) . . . . . . . . . . . . . . . . . . . . . . . . . 1215.11 Zahlen in Strings umwandeln . . . . . . . . . . . . . . . . . . . . . . . . . 1215.12 Strings in Zahlen umwandeln . . . . . . . . . . . . . . . . . . . . . . . . . 1225.13 Die Länge eines Strings bestimmen . . . . . . . . . . . . . . . . . . . . . 1235.14 Die Position eines Strings in einem anderen String suchen . . . 1245.15 Einen Teilstring extrahieren . . . . . . . . . . . . . . . . . . . . . . . . . . 1245.16 Einen Teilstring durch einen anderen ersetzen . . . . . . . . . . . . 1255.17 Einen String in Groß- oder Kleinbuchstaben umwandeln . . . 1265.18 Befehle bedingt ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1275.19 Werte vergleichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1285.20 Logische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1295.21 Anweisungen genau x-mal ausführen . . . . . . . . . . . . . . . . . . . 1305.22 Befehle wiederholen, bis sich eine Bedingung ändert . . . . . . . 1315.23 Aus einer Schleife ausbrechen . . . . . . . . . . . . . . . . . . . . . . . . . 1325.24 Eine Funktion in Python definieren . . . . . . . . . . . . . . . . . . . . 132

033-5.book Seite VII Montag, 14. November 2016 1:31 13

VIII | Inhalt

6 Python-Listen und -Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1356.1 Eine Liste erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1356.2 Auf Elemente einer Liste zugreifen . . . . . . . . . . . . . . . . . . . . . 1366.3 Die Länge einer Liste ermitteln . . . . . . . . . . . . . . . . . . . . . . . 1376.4 Elemente zu einer Liste hinzufügen . . . . . . . . . . . . . . . . . . . . 1376.5 Elemente aus einer Liste entfernen . . . . . . . . . . . . . . . . . . . . . 1386.6 Eine Liste durch Parsing eines Strings erzeugen . . . . . . . . . . . 1396.7 Iteration über eine Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1406.8 Eine Liste durchzählen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1406.9 Eine Liste sortieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

6.10 Eine Liste zerlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1426.11 Eine Funktion auf eine Liste anwenden . . . . . . . . . . . . . . . . . 1436.12 Ein Dictionary anlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1446.13 Auf ein Dictionary zugreifen . . . . . . . . . . . . . . . . . . . . . . . . . 1456.14 Elemente aus einem Dictionary entfernen . . . . . . . . . . . . . . . 1466.15 Iteration über Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . 147

7 Python für Fortgeschrittene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1497.1 Zahlen formatieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1497.2 Datum & Uhrzeit formatieren . . . . . . . . . . . . . . . . . . . . . . . . 1507.3 Mehrere Werte zurückliefern . . . . . . . . . . . . . . . . . . . . . . . . . 1517.4 Eine Klasse definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1527.5 Eine Methode definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1537.6 Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1547.7 In eine Datei schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1557.8 Aus einer Datei lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1567.9 Pickling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157

7.10 Ausnahmebehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1587.11 Module nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1607.12 Zufallszahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1617.13 Webanfragen aus Python versenden . . . . . . . . . . . . . . . . . . . 1627.14 Kommandozeilenargumente in Python . . . . . . . . . . . . . . . . . 1637.15 Linux-Befehle aus Python heraus ausführen . . . . . . . . . . . . . 1647.16 E-Mail aus Python heraus versenden . . . . . . . . . . . . . . . . . . . 1657.17 Einen einfachen Webserver in Python entwickeln . . . . . . . . . 1667.18 Mehrere Dinge gleichzeitig tun . . . . . . . . . . . . . . . . . . . . . . . 1687.19 Nichts tun mit Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1697.20 Python mit der Minecraft Pi Edition nutzen . . . . . . . . . . . . . 170

8 Computer Vision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1738.1 SimpleCV installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1738.2 Eine USB-Kamera für Computer Vision einrichten . . . . . . . . 174

033-5.book Seite VIII Montag, 14. November 2016 1:31 13

Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 2017Inhalt | IX

8.3 Das Raspberry-Pi-Kameramodul für Computer Vision nutzen 1768.4 Münzen zählen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1778.5 Gesichtserkennung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1828.6 Bewegungserkennung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1838.7 Optische Zeichenerkennung . . . . . . . . . . . . . . . . . . . . . . . . . . 186

9 GPIO-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1879.1 Den GPIO-Anschluss verstehen . . . . . . . . . . . . . . . . . . . . . . . 1879.2 Den Raspberry Pi bei der Arbeit mit dem GPIO-Anschluss

schützen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1909.3 I2C einrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1919.4 Die I2C-Tools nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1949.5 SPI einrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1959.6 PySerial installieren, um aus Python heraus auf den seriellen

Port zuzugreifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1969.7 Minicom zum Testen des seriellen Ports installieren . . . . . . . 1979.8 Ein Steckbrett mit Schaltdrähten nutzen . . . . . . . . . . . . . . . . 1989.9 Ein Steckbrett mit einem Pi-Cobbler nutzen . . . . . . . . . . . . . . 199

9.10 Einen Raspberry Squid nutzen . . . . . . . . . . . . . . . . . . . . . . . . 2019.11 Einen Raspberry-Pi-Squid-Button nutzen . . . . . . . . . . . . . . . . 2039.12 5-V-Signale mit zwei Widerständen in 3,3V umwandeln . . . . 2059.13 5-V-Signale mit einem Pegelwandler-Modul in 3,3V

umwandeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2069.14 Den Raspberry Pi mit Batterien betreiben . . . . . . . . . . . . . . . . 2079.15 Einen Raspberry Pi mit einem LiPo-Akku betreiben . . . . . . . . 2099.16 Erste Schritte mit dem Sense HAT . . . . . . . . . . . . . . . . . . . . . 2119.17 Erste Schritte mit dem Explorer HAT Pro . . . . . . . . . . . . . . . 2139.18 Erste Schritte mit dem RasPiRobot-Board . . . . . . . . . . . . . . . 2149.19 Erste Schritte mit einem Pi-Plate-Prototyping-Board . . . . . . . 2169.20 Ein HAT-Modul (Hardware At Top) entwickeln . . . . . . . . . . 2219.21 Das Pi Compute Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2249.22 Der Pi Zero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225

10 Hardware steuern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22710.1 Eine LED anschließen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22710.2 Die GPIO-Pins in sicherem Zustand verlassen . . . . . . . . . . . . 23010.3 Die Helligkeit einer LED steuern . . . . . . . . . . . . . . . . . . . . . . 23110.4 Einen Summton erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23310.5 Hochleistungs-Gleichstromgeräte mit einem Transistor

schalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23510.6 Ein Hochleistungsgerät mit einem Relais schalten . . . . . . . . . 23710.7 Ein Hochspannungs-Wechselstromgerät steuern . . . . . . . . . . 240

033-5.book Seite IX Montag, 14. November 2016 1:31 13

X | Inhalt

10.8 Eine Benutzerschnittstelle zum Ein- und Ausschalten von Komponenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241

10.9 Eine Benutzerschnittstelle für die PWM-Steuerung von LEDs und Motoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243

10.10 Die Farbe einer RGB-LED ändern . . . . . . . . . . . . . . . . . . . . . 24510.11 Mit vielen LEDs arbeiten (Charlieplexing) . . . . . . . . . . . . . . . 24710.12 Ein Analoginstrument als Anzeige nutzen . . . . . . . . . . . . . . . 25010.13 Mit Interrupts programmieren . . . . . . . . . . . . . . . . . . . . . . . . 252

11 Motoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25711.1 Servomotoren steuern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25711.2 Servomotoren präzise steuern . . . . . . . . . . . . . . . . . . . . . . . . 26111.3 Eine große Anzahl von Servomotoren steuern . . . . . . . . . . . . 26411.4 Die Geschwindigkeit eines Gleichstrommotors steuern . . . . 26711.5 Die Drehrichtung eines Gleichstrommotors steuern . . . . . . . 26911.6 Einen unipolaren Schrittmotor nutzen . . . . . . . . . . . . . . . . . . 27411.7 Einen bipolaren Schrittmotor nutzen . . . . . . . . . . . . . . . . . . . 27811.8 Einen bipolaren Schrittmotor mit einem Schrittmotor-HAT

steuern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28011.9 Ein RasPiRobot-Board zur Steuerung eines bipolaren

Schrittmotors nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28311.10 Einen einfachen Robot-Rover bauen . . . . . . . . . . . . . . . . . . . 285

12 Digitale Eingänge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28912.1 Einen Taster anschließen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28912.2 Etwas per Taster umschalten . . . . . . . . . . . . . . . . . . . . . . . . . 29212.3 Einen Wipp- oder Schiebeschalter nutzen . . . . . . . . . . . . . . . 29412.4 Einen Drei-Wege-Schalter nutzen . . . . . . . . . . . . . . . . . . . . . 29512.5 Eine Taste entprellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29812.6 Einen externen Pull-up-Widerstand nutzen . . . . . . . . . . . . . . 30012.7 Einen Drehgeber nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30112.8 Eine Matrixtastatur nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . 30412.9 Bewegungen erkennen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30812.10 Den Raspberry Pi um GPS erweitern . . . . . . . . . . . . . . . . . . . 30912.11 Tastendruck abfangen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31312.12 Bewegungen der Maus abfangen . . . . . . . . . . . . . . . . . . . . . . 31512.13 Eine Echtzeituhr nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316

13 Sensoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32113.1 Ohmsche Widerstände nutzen . . . . . . . . . . . . . . . . . . . . . . . . 32113.2 Licht messen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32613.3 Temperatur mit Thermistor messen . . . . . . . . . . . . . . . . . . . . 329

033-5.book Seite X Montag, 14. November 2016 1:31 13

Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 2017Inhalt | XI

13.4 Methan erkennen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33213.5 Eine Spannung messen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33513.6 Spannungen zu Messzwecken reduzieren . . . . . . . . . . . . . . . . 33713.7 Ohmsche Sensoren mit einem A/D-Wandler nutzen . . . . . . . 33913.8 Temperatur mit einem A/D-Wandler messen . . . . . . . . . . . . . 34113.9 Die CPU-Temperatur des Raspberry Pi messen . . . . . . . . . . . 34313.10 Temperatur, Luftfeuchtigkeit und Luftdruck mit einem

Sense HAT messen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34513.11 Temperatur messen per digitalem Sensor . . . . . . . . . . . . . . . . 34713.12 Beschleunigung messen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34913.13 Die IMU des Sense HAT nutzen . . . . . . . . . . . . . . . . . . . . . . . 35313.14 Den magnetischen Norden mit dem Sense HAT

bestimmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35513.15 Magneten mit einem Reedschalter aufspüren . . . . . . . . . . . . . 35613.16 Magneten mit dem Sense HAT aufspüren . . . . . . . . . . . . . . . 35713.17 Entfernungen messen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35813.18 Berührungssensoren nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . 36113.19 Sensorwerte ausgeben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36313.20 Daten auf einem USB-Flash-Laufwerk speichern . . . . . . . . . . 365

14 Displays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36914.1 Ein vierstelliges LED-Display nutzen . . . . . . . . . . . . . . . . . . . 36914.2 Nachrichten auf einer I2C-LED-Matrix ausgeben . . . . . . . . . 37114.3 Das Matrix-Display des Sense HAT nutzen . . . . . . . . . . . . . . 37414.4 Nachrichten auf einem alphanumerischen LCD HAT

ausgeben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37614.5 Nachrichten auf einem alphanumerischen LC-Display

ausgeben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37814.6 Ein grafisches OLED-Display nutzen . . . . . . . . . . . . . . . . . . . 38214.7 Adressierbare RGB-LED-Streifen nutzen . . . . . . . . . . . . . . . . 384

15 Das Internet der Dinge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38915.1 GPIO-Ausgänge über eine Webschnittstelle steuern . . . . . . . 38915.2 Sensorwerte auf einer Webseite ausgeben . . . . . . . . . . . . . . . 39515.3 E-Mails und andere Nachrichten per IFTTT

versenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39815.4 Tweets senden per ThinkSpeak . . . . . . . . . . . . . . . . . . . . . . . 40215.5 CheerLights . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40415.6 Sensordaten an ThingSpeak senden . . . . . . . . . . . . . . . . . . . . 40615.7 Mit Dweet und IFTTT auf Tweets reagieren . . . . . . . . . . . . . 408

033-5.book Seite XI Montag, 14. November 2016 1:31 13

XII | Inhalt

16 Arduino und Raspberry Pi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41316.1 Einen Arduino per Raspberry Pi programmieren . . . . . . . . . . 41416.2 Mit dem Arduino über den seriellen Monitor

kommunizieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41616.3 PyFirmata einrichten und einen Arduino von einem

Raspberry Pi steuern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41816.4 Digitale Ausgänge des Arduino vom Raspberry Pi steuern . . 42116.5 PyFirmata mit der seriellen Schnittstelle (TTL-Pegel)

nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42316.6 Digitale Eingänge des Arduino mit PyFirmata einlesen . . . . . 42516.7 Analoge Eingänge des Arduino mit PyFirmata einlesen . . . . . 42716.8 Digitale Ausgänge (PWM) mit PyFirmata nutzen . . . . . . . . . 42916.9 Einen Servo mit PyFirmata steuern . . . . . . . . . . . . . . . . . . . . 43116.10 Maßgeschneiderte serielle Kommunikation mit dem

Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43316.11 Maßgeschneiderte Kommunikation mit dem Arduino

über I2C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43716.12 Kleine Arduinos mit dem Raspberry Pi nutzen . . . . . . . . . . . 44116.13 Erste Schritte mit dem aLaMode-Board und einem

Raspberry Pi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44316.14 Ein Arduino-Shield mit einem aLaMode-Board und einem

Raspberry Pi nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446

A Teile und Lieferanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449

B Pin-Belegungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457

033-5.book Seite XII Montag, 14. November 2016 1:31 13

Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 201711.1 Servomotoren steuern | 257

Kapitel 11 KAPITEL 11

Motoren

11.0 EinführungIn diesem Kapitel wollen wir uns ansehen, wie sich unterschiedliche Motortypenam Raspberry Pi betreiben lassen.

11.1 Servomotoren steuern

Sehen Sie sich das dazugehörige Video auf http://razzpisampler.oreilly.com an.

ProblemSie möchten einen Raspberry Pi nutzen, um die Position eines Servomotors zu steu-ern.

LösungNutzen Sie PWM, um die Impulsbreite am Servomotor und damit dessen Winkelzu ändern. Das funktioniert zwar, doch die erzeugte PWM ist nicht ganz stabil,weshalb der Servo leicht zittert. Eine alternative Lösung, die wesentlich stabilereImpulse erzeugt, bietet die ServoBlaster-Treibersoftware (Rezept 11.2).

Bei einem älteren Raspberry Pi 1 sollten Sie den Servo separat mit 5V versorgen, dadie auftretenden Stromspitzen den Raspberry Pi zum Absturz bringen oder überlas-ten können. Wenn Sie einen Raspberry Pi B+ oder neuer nutzen, sorgen die Verbes-serungen an der Board-eigenen Spannungsversorgung dafür, dass Sie kleine Servosdirekt über den 5V-Pin des GPIO-Anschlusses versorgen können.

Abbildung 11-1 zeigt einen kleinen 9g-Servo (Anhang A, Vermischtes, Seite 453),der problemlos mit einem Raspberry Pi B+ läuft.

033-5.book Seite 257 Montag, 14. November 2016 1:31 13

258 | Kapitel 11: Motoren

Die Anschlüsse des Servos sind üblicherweise farblich gekennzeichnet: 5V mit rot,Masse mit braun und die Steuerung mit orange. 5V und Masse werden mit den 5V-und GND-Pins des GPIO-Anschlusses verbunden. Das Steuerungskabel wird mitPin 18 verbunden.

Wenn Sie mit einer separaten Stromversorgung arbeiten, bietet ein Steckbrett einegute Möglichkeit, alle Anschlüsse zusammenzuhalten.

Abbildung 11-1: Direkt angeschlossener kleiner Servo am Rasbperry Pi B+

Für dieses Rezept benötigen Sie folgende Komponenten:

• 5-V-Servomotor (Anhang A, Vermischtes, Seite 453)

• Steckbrett und Schaltdrähte (Anhang A, Prototyping-Zubehör, Seite 450)

• 1-k-Widerstand (Anhang A, Widerstände und Kondensatoren)

• 5-V-/1-A-Stromversorgung oder 4,8-V-Batteriepaket (Anhang A, Vermischtes,Seite 453)

Den Aufbau auf dem Steckbrett zeigt Abbildung 11-2.

Der 1-k-Widerstand ist nicht unbedingt erforderlich, schützt den GPIO-Pin abervor unerwartet hohen Strömen im Steuersignal, die auftreten können, wenn eseinen Fehler am Servo gibt.

Wenn Sie möchten, können Sie den Servo auch über einen Akku-Pack betreiben.Ein Batteriehalter für vier AA-Akkus liefert um die 4,8V und reicht für ein Servo


Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 201711.1 Servomotoren steuern | 259

aus. Vier Alkali-AA-Zellen liefern 6V und reichen für mehrere Servos, allerdingssollten Sie im Datenblatt prüfen, ob der Servo die 6V verträgt.

Abbildung 11-2: Einen Servomotor steuern

Die Benutzerschnittstelle zum Einstellen des Winkels basiert auf dem gui_slider.py-Programm zur Steuerung der Helligkeit einer LED (Rezept 10.9). Es wurde somodifiziert, dass mit dem Schieberegler ein Winkel von 0 bis 180 Grad eingestelltwerden kann (Abbildung 11-3).

Abbildung 11-3: Benutzerschnittstelle zur Steuerung eines Servomotors

Öffnen Sie einen Editor (nano oder IDLE) und kopieren Sie den folgenden Code.Wie alle Programmbeispiele aus diesem Buch können Sie auch dieses aus demCodebereich von http://www.oreilly.de/raspberrykochbuch herunterladen (unterdem Namen servo.py).

Beachten Sie, dass das Programm eine grafische Benutzerschnittstelle nutzt, d.h.,Sie können es nicht über SSH ausführen.

5V-/1A-Anschluss



Sie müssen es in der Windows-Umgebung des Pi ausführen oder über VNC (Rezept2.8), bzw. RDP (Rezept 2.9) fernsteuern. Sie müssen es außerdem als Superuserausführen, also mit sudo python servo.py starten:

from Tkinter import *import RPi.GPIO as GPIOimport time

GPIO.setmode(GPIO.BCM)GPIO.setup(18, GPIO.OUT)

pwm = GPIO.PWM(18, 100)pwm.start(5)

class App:

def __init__(self, master):

frame = Frame(master) frame.pack() scale = Scale(frame, from_=0, to=180,

orient=HORIZONTAL, command=self.update) scale.grid(row=0)

def update(self, angle): duty = float(angle) / 10.0 + 2.5 pwm.ChangeDutyCycle(duty)

root = Tk()root.wm_title('Servo Control')

app = App(root)root.geometry("200x50+0+0")root.mainloop()

DiskussionServomotoren werden bei der (Fern-)Steuerung von Fahrzeugen und Robotern ein-gesetzt. Die meisten Servomotoren sind nicht umlaufend, d.h., sie drehen sich nichtkomplett, sondern nur in einem Winkel bis zu etwa 180 Grad.

Die Position des Servomotors wird durch die Impulslänge gesetzt. Der Servo erwar-tet einen Impuls alle 20 Millisekunden. Wenn der Puls für eine Millisekunde highist, ist sein Winkel bei 0. Bei 1,5 Millisekunden ist er in der Mittelstellung und bei2 Millisekunden bei 180 Grad (Abbildung 11-4).

Beim Beispielprogramm wird eine PWM-Frequenz von 100 Hz festgelegt, d.h., derServo erhält alle 10 Millisekunden einen Impuls. Tatsächlich werden dadurch auchImpulse erzeugt, die unter dem erwarteten Minimum von einer Millisekunde undüber dem Maximum von zwei Millisekunden liegen.


Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 201711.2 Servomotoren präzise steuern | 261

Abbildung 11-4: Servomotoren

Siehe auchWenn Sie mit mehreren Servomotoren arbeiten oder eine größere Stabilität undPräzision benötigen, können Sie ein spezielles Servo-Controller-Modul nutzen, wiees in Rezept 11.3 beschrieben wird.

Adafruit hat eine andere Methode der Servosteuerung (http://bit.ly/17FVspk) ent-wickelt.

Eine alternative Lösung bietet die ServoBlaster-Treibersoftware, die wesentlich sta-bilere Impulse erzeugt (Rezept 11.2).

11.2 Servomotoren präzise steuern

ProblemDie PWM-Funktion der RPi.GPIO-Bibliothek ist für Ihre Servoanwendung nichtpräzise und »jitter-frei« genug.

LösungInstallieren Sie den ServoBlaster-Gerätetreiber.

Die von Richard Hurst entwickelte ServoBlaster-Software nutzt die CPU des Rasp-berry Pi, um Impulse zu generieren, die wesentlich genauer sind, als dies mit derRPi.GPIO-Bibliothek möglich ist. Installieren Sie die Software mit den folgendenBefehlen und starten Sie den Raspberry Pi dann neu.



git clone git://github.com/richardghirst/PiBits.gitcd PiBits/ServoBlaster/usersudo makesudo make install

Das Programm aus Rezept 11.1 kann so angepasst werden, dass es den ServoBlaster-Code nutzt. Das modifizierte Programm finden Sie in der Datei servo_blaster.py. Esgeht davon aus, dass der Servo-Steuerpin mit GPIO 18 verbunden ist.

from Tkinter import * import osimport timeservo_min = 500 # uS servo_max = 2500 # uSservo = 2 # GPIO 18

def map(value, from_low, from_high, to_low, to_high): from_range = from_high - from_low to_range = to_high - to_low scale_factor = float(from_range) / float(to_range) return to_low + (value / scale_factor)

def set_angle(angle): pulse = int(map(angle, 0, 180, servo_min, servo_max)) command = "echo {}={}us > /dev/servoblaster".format(servo, pulse) os.system(command) class App: def __init__(self, master): frame = Frame(master) frame.pack() scale = Scale(frame, from_=0, to=180, orient=HORIZONTAL, command=self.update) scale.grid(row=0) def update(self, angle): set_angle(float(angle)) root = Tk()root.wm_title('Servo Control')app = App(root)root.geometry("200x50+0+0")root.mainloop()

Die Benutzerschnittstelle ist mit der aus Rezept 11.1 identisch. Die Unterschiedeliegen in der Funktion set_angle. Diese Funktion nutzt eine Hilfsfunktion namensmap, um einen Winkel mithilfe der Konstanten servo_min und servo_max in eineImpulsdauer umzurechnen. Daraus wird dann ein Befehl konstruiert, der über dieKommandozeile ausgeführt wird. Dieser Befehl beginnt mit einem echo, gefolgt vonder Nummer des zu steuernden Servos, einem Gleichheitszeichen und der Impuls-dauer in Mikrosekunden. Der Stringteil des Befehls wird dann an das Gerät /dev/servoblaster weitergeleitet und die Position des Servos geändert.


Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 201711.2 Servomotoren präzise steuern | 263

ServoBlaster beendenWenn ServoBlaster, oder genauer gesagt der Dienst servo.d,läuft, können Sie die Servo-Pins für nichts anderes verwenden,und Audio funktioniert am Raspberry Pi auch nicht mehr. Sol-len die Pins also für etwas anderes genutzt werden, müssen SieServoBlaster deaktivieren und den Raspberry Pi neu starten.

$ sudo update-rc.d servoblaster disable $sudo reboot

Nach dem Neustart des Raspberry Pi hat ServoBlaster keineKontrolle mehr über die Pins. Natürlich können Sie den Servo-Blaster jederzeit wieder aktivieren:

$ sudo update-rc.d servoblaster enable$ sudo reboot

DiskussionDer ServoBlaster-Treiber ist sehr mächtig und erlaubt es Ihnen, nahzu alle GPIO-Pins zur Steuerung von Servos zu nutzen. Die Standardeinstellung definiert achtGPIO-Pins zur Servosteuerung. Jedem dieser Pins wird ein Kanal zugewiesen. DieStandardzuordnung zeigt Tabelle 11-1.

Der Anschluss so vieler Servos kann einen ziemlichen Kabelsalat verursachen. EinBoard wie das MonkMakes Servo Six vereinfacht die Verkabelung der Servos mitIhrem Raspberry Pi deutlich.

Siehe auchDie vollständige Dokumentation zum ServoBlaster finden Sie auf https://github.com/richardghirst/PiBits/tree/master/ServoBlaster.

Wenn Sie das präzise Timing des ServoBlasters nicht benötigen, kann auch die RPi.GPIO-Bibliothek die Impulse für Ihren Servo erzeugen (Rezept 11.1).

Tabelle 11-1: ServoBlaster-Standardzuordnung von Kanälen und Pins

Servokanal GPIO-Pin

0 4

1 17

2 18

3 27

4 22

5 23

6 24

7 25



11.3 Eine große Anzahl von Servomotoren steuern

ProblemSie möchten eine Reihe von Servomotoren mit hoher Präzision steuern.

LösungZwar können Sie mit dem ServoBlaster-Code aus Rezept 11.2 viele Servos präzisesteuern, das löst aber das Problem der Verkabelung nicht. Sie können das zwar aufeinem Steckbrett aufbauen, doch das ist ziemlich chaotisch und irgendein Kabelsteckt garantiert nicht richtig.

Um den Anschluss einfach zu gestalten, nutzen Sie ein Servomotor-HAT wie inAbbildung 11-5.

Abbildung 11-5: Adafruit-Servomotor-HAT

Dieses HAT ermöglicht die Steuerung von bis zu 16 Servomotoren oder PWM-Kanälen über die I2C-Schnittstelle des Raspberry Pi. Die Servos werden direkt mitdem HAT verbunden.

Die Spannungsversorgung der Logikschaltung des Moduls erfolgt über den 3,3-V-Anschluss des Raspberry Pi und ist völlig von den Servomotoren getrennt, die übereine externe 5-V-Quelle versorgt werden.


Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 201711.3 Eine große Anzahl von Servomotoren steuern | 265

Wenn Sie möchten, können Sie den Servo auch über einen Akku-Pack betreiben.Ein Batteriehalter für vier AA-Akkus liefert um die 4,8V und reicht für einen Servoaus. Vier Alkali-AA-Zellen liefern 6V und reichen für mehrere Servos, allerdingssollten Sie im Datenblatt prüfen, ob der Servo die 6V verträgt.

Die Anschlüsse des Servos sind praktischerweise so angeordnet, dass Sie direkt mitden Pins verbunden werden können. Achten Sie beim Anschluss auf die Polung.

Um die Adafruit-Software für dieses Modul nutzen zu können, müssen Sie I2C aufdem Raspberry Pi aktivieren (Rezept 9.3).

Die Adafruit-Bibliothek ist keine »richtige« Bibliothek mit Installationsskript, son-dern besteht nur aus einem Verzeichnis, das eine Reihe von Dateien enthält. WennSie die Bibliothek nutzen, müssen Sie sich daher in diesem Verzeichnis befinden,sonst findet Ihr Programm die Dateien nicht.

Um die gesamte Adafruit-Software-Bibliothek für den Raspberry Pi herunterzula-den, geben Sie Folgendes ein:

$ git clone https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code.git$ cd Adafruit-Raspberry-Pi-Python-Code$ cd Adafruit_PWM_Servo_Driver

Mit den beiden letzten Zeilen erfolgt ein Wechsel in das Verzeichnis, das denPWM-Code enthält sowie ein entsprechendes Beispielprogramm von Adafruit, dasSie mit dem folgenden Befehl ausführen können:

$ sudo python Servo_Example.py

Im folgenden Programm wird unser Beispiel aus Rezept 11.2 so angepasst, dass Siedie Position des Servos über einen Schieberegler zwischen 0 und 180 Grad einstel-len können. Die Programmdatei muss im Verzeichnis Adafruit_PWM_Servo_Dri-ver abgelegt werden. Der Schieberegler ändert die Servoposition gleichzeitig für diebeiden Kanäle 0 und 1, d.h., die beiden Servos bewegen sich parallel, wenn Sie denSchieberegler nutzen.

Öffnen Sie einen Editor (nano oder IDLE) und kopieren Sie den folgenden Code.Wie alle Programmbeispiele aus diesem Buch können Sie auch dieses aus demCodebereich von http://www.oreilly.de/raspberrykochbuch herunterladen (unterdem Namen servo_module.py). Beachten Sie, dass das Programm eine grafischeBenutzerschnittstelle nutzt und daher nicht über SSH ausgeführt werden kann. Siemüssen es entweder über die Windows-Umgebung auf dem Pi selbst ausführenoder es entfernt über VNC (Rezept 2.8) oder RDP (Rezept 2.9) steuern.

from Tkinter import *from Adafruit_PWM_Servo_Driver import PWMimport time

pwm = PWM(0x40)pwm.setPWMFreq(50)



class App:

def __init__(self, master): frame = Frame(master) frame.pack() scale = Scale(frame, from_=0, to=180, orient=HORIZONTAL, command=self.update) scale.grid(row=0)

def update(self, angle): pulse_len = int(float(angle) * 500.0 / 180.0) + 110 pwm.setPWM(0, 0, pulse_len) pwm.setPWM(1, 0, pulse_len)

root = Tk()root.wm_title('Servo Control')app = App(root)root.geometry("200x50+0+0")root.mainloop()

DiskussionDie erste Zeile nach dem Import erzeugt eine neue PWM-Instanz. Sie nutzt dazu dieI2C-Adresse als Argument, in diesem Fall 0×40. Das Modul besitzt Lötpunkte, überdie Sie die I2C-Adresse ändern können, falls es zu Konflikten mit anderen I2C-Geräten kommt oder wenn Sie mehrere dieser Module nutzen möchten.

In der nächsten Zeile wird eine PWM-Frequenz von 50 Hz festgelegt, mit der alle20 Millisekunden ein Update-Impuls geliefert wird. Die Zeile, mit der die eigentli-che PWM für einen bestimmten Kanal eingestellt wird, lautet folgendermaßen:

pwm.setPWM(0, 0, pulse_len)

Das erste Argument gibt den PWM-Kanal an, dessen Tastverhältnis geändert wer-den soll. Jede Periode wird in 4096 Ticks unterteilt. Das zweite Argument enthältden Tick, bei dem der Impuls beginnen soll. Dieser ist immer 0. Das dritte Argu-ment gibt den Tick an, bei dem der Impuls enden soll. Die beiden Konstanten 500.0 und 110 in der folgenden Zeile wurden durch Austesten ermittelt und solleneinen Standardservo so nah wie möglich an die 180 Grad bringen:

pulse_len = int(float(angle) * 500.0 / 180.0) + 110

Bei der Wahl einer Stromversorgung für dieses Modul müssen Sie daran denken,dass ein normaler Servo leicht 400 mA zieht, wenn er sich bewegt, und unter Lastnoch mehr. Wenn Sie also viele Servos gleichzeitig bewegen möchten, benötigenSie eine entsprechende Stromversorgung.

Siehe auchEin Servo-HAT ist eine gute Sache, wenn Ihr Raspberry Pi nahe der Servomotorenliegt. Sind die Motoren hingegen weiter vom Raspberry Pi weg, können Sie vonAdafruit auch ein Servomodul erwerben (Produkt-ID 815), die die gleiche Servo-


Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 201711.4 Die Geschwindigkeit eines Gleichstrommotors steuern | 267

Controller-Hardware verwendet wie das Servo-HAT, aber nur vier Pins hat, das dieI2C-Schnittstelle des Boards mit dem I2C-Interface des Raspberry Pi verbinden.

Sehen Sie sich die Adafruit-Dokumentation) zu deren Raspberry Pi-Bibliothek an(http://bit.ly/1iomEey.

11.4 Die Geschwindigkeit eines Gleichstrommotors steuern

ProblemSie möchten die Geschwindigkeit eines Gleichstrommotors mit dem Raspberry Pisteuern.

LösungSie können den gleichen Entwurf wie in Rezept 10.5 verwenden, allerdings solltenSie eine Diode zwischen den Motor schalten, damit Stromspitzen nicht den Tran-sistor oder gar den Raspberry Pi beschädigen. Die 1N4001 ist dafür eine geeigneteDiode. Sie hat an einer Seite einen Streifen. Achten Sie also auf die richtige Polung.

Abbildung 11-6: Gleichstrommotor mit hoher Leistung steuern

Sie benötigen folgende Komponenten:

• 3-V- bis 12-V-Gleichstrommotor


Gleichstrom-quelle



• 1-k-Widerstand (Anhang A, Widerstände und Kondensatoren, Seite 451)

• MOSFET-Transistor FQP30N06L (Anhang A, Transistoren und Dioden, Seite451)

• Diode 1N4001 (Anhang A, Transistoren und Dioden, Seite 451)

• Stromversorgung mit einer für den Motor ausreichenden Leistung

Zur Steuerung der Geschwindigkeit des Motors können Sie das Programm aus demCodebereich von http://www.oreilly.de/raspberrykochbuch herunterladen, wo esunter dem Namen gui_slider.py zu finden ist. Beachten Sie, dass das Programm einegrafische Benutzerschnittstelle verwendet und daher nicht über SSH ausgeführtwerden kann. Sie müssen es in der Windows-Umgebung auf dem Pi selbst ausfüh-ren oder es entfernt über VNC (Rezept 2.8) oder RDP (Rezept 2.9) steuern.

DiskussionBei einem Gleichstrommotor mit geringer Leistung (unter 200 mA) können Sieeinen kleineren (und billigeren) Transistor wie den 2B3904 verwenden (Anhang A,Transistoren und Dioden, Seite 451). Den Aufbau für einen 2N3904 sieht auf einemSteckbrett so aus wie in (Abbildung 11-7).

Bei einem kleinen Motor reicht es wahrscheinlich aus, wenn Sie ihn über die 5-V-Leitung des GPIO-Anschlusses versorgen. Wenn der Raspberry Pi dabei abstürzt,müssen Sie eine externe Stromversorgung anschließen (Abbildung 11-6).

Abbildung 11-7: Gleichstrommotor mit geringer Leistung steuern


Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 201711.5 Die Drehrichtung eines Gleichstrommotors steuern | 269

Siehe auchMit dieser Schaltung wird nur die Geschwindigkeit des Motors gesteuert. Sie kannnicht die Drehrichtung des Motors beeinflussen. Wie das funktioniert, wird inRezept 11.5 erläutert.

Die Nutzung von Steckbrett und Schaltdrähten mit dem Raspberry Pi wird inRezept 9.8 beschrieben.

11.5 Die Drehrichtung eines Gleichstrommotors steuern

ProblemSie möchten sowohl die Geschwindigkeit als auch die Drehrichtung eines kleinenGleichstrommotors steuern.

LösungNutzen Sie einen H-Brücken-Chip oder ein H-Brücken-Modul.

Zur Steuerung des Motors stehen zwei Rezepte zur Auswahl. Beim ersten, dem»DIY-Ansatz«, werden ein Steckbrett und ein L293D-Chip verwendet. Beim zwei-ten Ansatz kommt ein fertiges H-Brücken-Modul von SparkFun zum Einsatz, dasdirekt mit dem Raspberry Pi verbunden wird.

Sowohl mit dem L293D als auch mit dem SparkFun-Modul können zwei Motorenohne zusätzliche Hardware angesteuert werden.

Option 1: L293D-Chip und Steckbrett

Wenn Sie sich für die L293D-Variante entscheiden, benötigen Sie folgende Kompo-nenten:


• Steckbrett und Schaltdrähte (männlich/weiblich; siehe Anhang A, Prototy-ping-Zubehör, Seite 450)

• L293D-Chip (Anhang A, Integrierte Schaltungen, Seite 451)


Der Aufbau auf dem Steckbrett wird in Abbildung 11-8 gezeigt.



Abbildung 11-8: L293D-Chip zur Steuerung eines Motors

Stellen Sie sicher, dass Sie den Chip richtig herum anschließen. Er hat auf einerSeite eine kleine Einkerbung, die auf dem Steckbrett nach oben zeigen muss.

Option 2: Motor-Controller-Modul

Wenn Sie sich für einen SparkFun-Motor-Controller (oder ein vergleichbaresMotor-Controller-Modul) entscheiden, benötigen Sie folgende Komponenten:


• Schaltdrähte (weiblich/weiblich; Anhang A, Prototyping-Zubehör, Seite 450)

• Stiftleisten (Anhang A, Vermischtes, Seite 453)

• SparkFun-Motortreiber 1A Dual (Anhang A, Module, Seite 452)


Die Verdrahtung wird in Abbildung 11-9 gezeigt. Beachten Sie, dass der abgebil-dete Motor nur ein einfacher Gleichstrommotor ist. Wenn in einem Projekt Räderangetrieben werden sollen, würde man üblicherweise einen Getriebemotor verwen-



den, bei dem ein Motor und ein Getriebe kombiniert werden, um die Drehzahl zureduzieren und das Drehmoment zu erhöhen.

Abbildung 11-9: Verschaltung eines SparkFun-Motor-Controllers

Das Motor-Controller-Modul wird ohne Stiftleisten geliefert, die Sie selbst anbrin-gen müssen, bevor Sie das Modul nutzen können.

Abbildung 11-10 zeigt die Verschaltung des Moduls mit einem kleinen Gleich-strom-Getriebemotor entsprechend der Schaltung aus Abbildung 11-9.

Abbildung 11-10: SparkFun-Motor-Controller mit Getriebemotor



Software

Für welche Hardwarelösung Sie sich auch entscheiden, das Programm, mit dem Sieden Motor ausprobieren können, ist für beide identisch. Es ermöglicht die Eingabedes Buchstabens f (für forward, vorwärts) oder r, gefolgt von einer einzelnen Zifferzwischen 0 und 9. Der Motor läuft dann entweder vor- oder rückwärts mit einerGeschwindigkeit zwischen 0 (Stopp) und 9 (Höchstgeschwindigkeit).

$ sudo python motor_control.pyCommand, f/r 0..9, E.g. f5 :f5Command, f/r 0..9, E.g. f5 :f1Command, f/r 0..9, E.g. f5 :f2Command, f/r 0..9, E.g. f5 :r2

Öffnen Sie einen Editor (nano oder IDLE) und kopieren Sie den folgenden Code.Wie alle Programmbeispiele aus diesem Buch können Sie auch dieses aus demCodebereich von http://www.oreilly.de/raspberrykochbuch herunterladen (unterdem Namen motor_control.py). Das Programm nutzt die Kommandozeile, kannalso auch über SSH ausgeführt werden.

Wenn Sie Python 3 nutzen, müssen Sie raw_input durch input ersetzen:

import RPi.GPIO as GPIOimport time

enable_pin = 18in1_pin = 23in2_pin =24GPIO.setmode(GPIO.BCM)GPIO.setup(enable_pin, GPIO.OUT)GPIO.setup(in1_pin, GPIO.OUT)GPIO.setup(in2_pin, GPIO.OUT)

pwm = GPIO.PWM(enable_pin, 500)pwm.start(0)

def clockwise(): GPIO.output(in1_pin, True) GPIO.output(in2_pin, False)

def counter_clockwise(): GPIO.output(in1_pin, False) GPIO.output(in2_pin, True)

while True: cmd = raw_input("Command, f/r 0..9, E.g. f5 :") direction = cmd[0] if direction == "f": clockwise() else: counter_clockwise() speed = int(cmd[1]) * 10 pwm.ChangeDutyCycle(speed)



DiskussionBevor wir uns ansehen, wie das Programm funktioniert, müssen wir zuerst verste-hen, wie eine H-Brücke arbeitet.

Abbildung 11-11 zeigt, wie sie funktioniert. Im Diagramm werden Schalter anstellevon Transistoren verwendet. Durch die Umkehr der Polarität ändert die H-Brückeauch die Richtung, in der sich der Motor dreht.

In Abbildung 11-11 sind S1 und S4 geschlossen und S2 und S3 offen. Der Stromfließt von Anschluss A (positiv) über Anschluss B (negativ) durch den Motor.Wenn wir die Schalter so umlegen, dass S2/S3 geschlossen und S1/S4 offen sind, istB positiv und A negativ und der Motor dreht sich in die andere Richtung.

Aber vielleicht ist Ihnen die Gefahr bei dieser Schaltung aufgefallen. Wenn S1 undS2 aus irgendeinem Grund beide gleichzeitig geschlossen sind, ist der positiveAnschluss direkt mit dem negativen verbunden und es gibt einen Kurzschluss. DasGleiche trifft zu, wenn S3 und S4 gleichzeitig geschlossen sind.

Sie können eine H-Brücke direkt über Transistoren aufbauen, doch der Einsatzeines H-Brücken-ICs wie der L293D-Chips ist wesentlich einfacher. Der Chip ent-hält darüber hinaus zwei H-Brücken, sodass Sie zwei Motoren steuern können.

Abbildung 11-11: Eine H-Brücke

Der L293 nutzt drei Steuerpins für jeden der beiden Motorsteuerungskanäle. DerEnable-Pin aktiviert bzw. deaktiviert den Kanal als Ganzes. Im Beispielprogrammist er mit einem PWM-Ausgang verbunden, der die Geschwindigkeit des Motorssteuert. Die anderen beiden Pins (IN1 und IN2) steuern die Drehrichtung desMotors. Wie die beiden Pins genutzt werden, zeigen die Funktionen clockwise undcounter_clockwise:



def clockwise(): GPIO.output(in1_pin, True) GPIO.output(in2_pin, False)

def counter_clockwise(): GPIO.output(in1_pin, False) GPIO.output(in2_pin, True)

Ist IN1 an und IN2 aus, dreht sich der Motor in die eine Richtung. Kehrt man dieZustände der beiden Pins um, dreht sich der Motor in die andere Richtung.

Statt eine L293D-Schaltung auf einem Steckbrett aufzubauen, können Sie bei eBaysehr kostengünstige Module erstehen. Diese Leiterplatten enthalten einen L293Dund Schraubklemmen zum Anschluss der Motoren und Stiftleisten für die direkteVerbindung mit dem Raspberry Pi. Wenn Sie ein Controller-Modul für leistungs-starke Motoren benötigen, finden Sie Module, die nach dem gleichen Prinzip arbei-ten, doch mit wesentlich höheren Strömen (20A und mehr) klarkommen. Polulu(https://www.pololu.com) bietet eine beeindruckende Auswahl solcher Motor-Con-troller-Boards an.

Siehe auchDer Adafruit-Schrittmotor-HAT (Rezept 11.8) und das RasPiRobot-Board (Rezept11.9) können ebenfalls genutzt werden, um Geschwindigkeit und Richtung einesGleichstrommotors zu steuern.

Sehen Sie sich das L293D-Datenblatt (http://bit.ly/18c4GKm) und die Produktseitedes SparkFun-Motor-Driver-Moduls (http://bit.ly/ILHVkJ)an.

Die Nutzung von Steckbrett und Schaltdrähten mit dem Raspberry Pi wird inRezept 9.8 beschrieben.

11.6 Einen unipolaren Schrittmotor nutzen

ProblemSie möchten einen unipolaren Schrittmotor mit 5 Anschlüssen mit dem RaspberryPi steuern.

LösungNutzen Sie einen ULN2803-Darlington-Treiber-Chip.

Bei den verfügbaren Motortechnologien liegen Schrittmotoren irgendwo zwischenGleichstrom- und Servomotoren. Wie gewöhnliche Gleichstrommotoren könnensie sich kontinuierlich drehen, gleichzeitig lassen sie sich aber auch sehr genau posi-tionieren, indem man sie Schritt für Schritt in eine beliebige Richtung bewegt.


Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 201711.6 Einen unipolaren Schrittmotor nutzen | 275


• 5-V-Schrittmotor, unipolar, mit 5 Pins (Anhang A, Vermischtes, Seite 453)

• ULN2803-Darlington-Treiber-IC (Anhang A, Integrierte Schaltungen, Seite451)


Abbildung 11-12 zeigt die Verkabelung eines ULN2803. Beachten Sie, dass derintegrierte Schaltkreis zwei solcher Motoren antreiben kann. Um einen zweitenSchrittmotor anzusteuern, müssen Sie vier weitere Pins des GPIO-Anschlusses mitden Pins 5 bis 8 des ULN2803 verbinden und den zweiten Motor mit den Pins 11bis 14.

Abbildung 11-12: Einen unipolaren Schrittmotor mittels ULN2803 steuern

Die 5-V-Leitung des GPIO-Anschlusses sollte für einen kleinen Schrittmotor aus-reichen. Kommt es beim Betrieb zu Problemen oder wird ein größerer Schrittmotorbenötigt, müssen Sie eine separate Stromversorgung für den Motor verwenden (Pin10 des ULN2803).

Öffnen Sie einen Editor (nano oder IDLE) und kopieren Sie den folgenden Code.Wie alle Programmbeispiele aus diesem Buch können Sie auch dieses aus demCodebereich von http://www.oreilly.de/raspberrykochbuch herunterladen (unterdem Namen stepper.py). Das Programm nutzt die Kommandozeile, d.h., Sie kön-nen es über SSH ausführen.


import RPi.GPIO as GPIOimport time

GPIO.setmode(GPIO.BCM)

coil_A_1_pin = 18coil_A_2_pin = 23coil_B_1_pin = 24coil_B_2_pin = 17



GPIO.setup(coil_A_1_pin, GPIO.OUT)GPIO.setup(coil_A_2_pin, GPIO.OUT)GPIO.setup(coil_B_1_pin, GPIO.OUT)GPIO.setup(coil_B_2_pin, GPIO.OUT)

forward_seq = ['1010', '0110', '0101', '1001']reverse_seq = list(forward_seq) # to copy the listreverse_seq.reverse()

def forward(delay, steps): for i in range(steps): for step in forward_seq: set_step(step) time.sleep(delay)

def backwards(delay, steps): for i in range(steps): for step in reverse_seq: set_step(step) time.sleep(delay)

def set_step(step): GPIO.output(coil_A_1_pin, step[0] == '1') GPIO.output(coil_A_2_pin, step[1] == '1') GPIO.output(coil_B_1_pin, step[2] == '1') GPIO.output(coil_B_2_pin, step[3] == '1')

while True: set_step('0000') delay = raw_input("Delay between steps (milliseconds)?") steps = raw_input("How many steps forward? ") forward(int(delay) / 1000.0, int(steps)) set_step('0000') steps = raw_input("How many steps backwards? ") backwards(int(delay) / 1000.0, int(steps))

Wenn Sie das Programm ausführen, wird die Verzögerungszeit zwischen denSchritten angefordert. Der Wert muss hier 2 oder höher sein. Sie werden dann nachden Schritten in jede Richtung gefragt:

$ sudo python stepper.pyDelay between steps (milliseconds)?2How many steps forward? 100How many steps backwards? 100Delay between steps (milliseconds)?10How many steps forward? 50How many steps backwards? 50Delay between steps (milliseconds)?


Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 201711.6 Einen unipolaren Schrittmotor nutzen | 277

DiskussionSchrittmotoren nutzen einen gezahnten Rotor und Elektromagneten, um das Radum jeweils einen Schritt zu bewegen (Abbildung 11-13). Beachten Sie, dass die Far-ben der Anschlüsse variieren.

Abbildung 11-13: Ein Schrittmotor

Wenn die Spulen in einer bestimmten Reihenfolge eingeschaltet werden, dreht sichder Motor. Die Anzahl der Schritte, die ein Schrittmotor benötigt, um eine 360-Grad-Drehung durchzuführen, wird von der Anzahl der Zähne des Rotors be-stimmt.

Im Beispielprogramm wird eine Liste von Strings für die Einschaltzustände genutzt,die für einen einzelnen Schritt notwendig sind:

forward_seq = ['1010', '0110', '0101', '1001']

Die Sequenz, die den Motor in entgegengesetzter Richtung laufen lässt, ist einfachdie umgekehrte Abfolge der Vorwärtsbewegung.

Sie können die Funktionen forward und backward in Ihren Programmen nutzen, umden Motor schrittweise vor und zurück zu bewegen. Das erste Argument beiderFunktionen ist die Verzögerung zwischen den einzelnen Schritten in Millisekun-den. Der hier anzugebende Minimalwert hängt vom verwendeten Motor ab. Wenner zu klein ist, dreht sich der Motor nicht. Üblicherweise reichen zwei Millisekun-den aus. Der zweite Parameter gibt die Anzahl der gewünschten Schritte an.

def forward(delay, steps): for i in range(steps): for step in forward_seq: set_step(step) time.sleep(delay)

Pink

Orange

Gelb Blau

Rot



Bei der forward-Funktion werden zwei verschachtelte for-Scheifen genutzt. Dieäußere geht die Anzahl der gewünschten Schritte durch, während die innereSchleife die Folge der notwendigen Motoraktionen durchläuft. Dabei wird für jedeAktion set_Step aufgerufen.

def set_step(step): GPIO.output(coil_A_1_pin, step[0] == '1') GPIO.output(coil_A_2_pin, step[1] == '1') GPIO.output(coil_B_1_pin, step[2] == '1') GPIO.output(coil_B_2_pin, step[3] == '1')

Die Funktion set_step setzt jeden der Steuerpins entsprechend dem im Argumentübergebenen Muster auf High oder Low.

Die Hauptschleife setzt den Schritt zwischen der Vor- und Rückwärtsbewegung auf0000. Damit werden alle Ausgänge auf 0 gesetzt, wenn sich der Motor nicht dreht.Anderenfalls könnte eine der Spulen an sein und der Motor würde unnötig Stromziehen.

Siehe auchDas Ansteuern eines bipolaren Schrittmotors mit vier Anschlüssen wird in Rezept11.7 erläutert.

Weitere Informationen zu Schrittmotoren, den unterschiedlichen Typen und zurFunktionsweise finden Sie auf Wikipedia. Dort wird auch das Aktivierungsmusterzur Ansteuerung des Motors mit einer schönen Animation erläutert.

Informationen zur Ansteuerung von Servomotoren finden Sie in Rezept 11.1. DieSteuerung von Gleichstrommotoren wird in den Rezepten Rezept 11.4 und Re-zept 11.5 erläutert.

Die Nutzung von Steckbrett und Schaltdrähten mit dem Raspberry Pi wird in Re-zept 9.8 beschrieben.

11.7 Einen bipolaren Schrittmotor nutzen

ProblemSie möchten einen bipolaren Schrittmotor mit vier Anschlüssen mit einem Ras-pberry Pi steuern.

LösungNutzen Sie einen L293D-H-Brücken-Treiber-Chip. Eine H-Brücke wird zur An-steuerung eines bipolaren Schrittmotors benötigt, weil die Richtung des Stroms


Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 201711.7 Einen bipolaren Schrittmotor nutzen | 279

durch die Windungen umgekehrt werden muss, ähnlich wie bei der Steuerung derDrehrichtung bei einem Gleichstrommotor (Rezept 11.5).


• 12-V-Schrittmotor, bipolar, mit 4 Pins (Anhang A, Vermischtes, Seite 453)

• L293D-H-Brücken-IC (Anhang A, Integrierte Schaltungen, Seite 451)


Der hier verwendete 12-V-Motor ist etwas größer als im vorangehenden Unipolar-Schrittmotor-Beispiel. Den Strom für den Motor liefert daher eine externe Strom-versorgung und nicht der Raspberry Pi (Abbildung 11-14).

Abbildung 11-14: Einen L293D zur Steuerung eines bipolaren Schrittmotors nutzen

12-V-Gleichstrom



DiskussionSie können genau das gleiche stepper.py-Programm nutzen, um diesen Schrittmo-tor zu steuern (Rezept 11.6). Beim Entwurf werden beide H-Brücken des L293Dgenutzt, d.h., Sie benötigen für jeden zu steuernden Motor einen dieser Chips.

Siehe auchDie Steuerung eines unipolaren Schrittmotors mit fünf Anschlüssen wird in Re-zept 11.6 erläutert.

Weitere Informationen zu Schrittmotoren, den unterschiedlichen Typen und zurFunktionsweise finden Sie auf Wikipedia. Dort wird auch das Aktivierungsmusterzur Ansteuerung des Motors mit einer schönen Animation erläutert.

Informationen zur Verwendung von Servomotoren finden Sie in Rezept 11.1; dieSteuerung von Gleichstrommotoren wird in den Rezepten 11.4 und 11.5 erläutert.

Sie können einen Schrittmotor auch mit dem RasPiRobot-Board ansteuern (Re-zept 11.9).

Die Nutzung von Steckbrett und Schaltdrähten mit dem Raspberry Pi wird in Re-zept 9.8 beschrieben.

11.8 Einen bipolaren Schrittmotor mit einem Schrittmotor-HAT steuern

ProblemSie möchten mehrere bipolare Schrittmotoren mit einem einzigen Interface-Boardsteuern.

LösungVerwenden Sie das Adafruit-Schrittmotor-HAT (Abbildung 11-5).

Dieses Board kann zwei bipolare Schrittmotoren ansteuern. Abbildung 11-15 zeigtdas Board mit angeschlossenem bipolaren Schrittmotor. Eine Spule ist mit derKlemme M1 verbunden, die andere mit M2. Die Stromversorgung des Motorserfolgt separat über die Schraubklemmen rechts in Abbildung 11-15.

Dieses HAT nutzt I2C, d.h., Sie müssen I2C aktivieren (Rezept 9.3).

Um die Arbeit mit dem HAT zu erleichtern, hat Adafruit eine Python-Bibliothekentwickelt. Sie installieren sie mit den folgenden Befehlen:


Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 201711.8 Einen bipolaren Schrittmotor mit einem Schrittmotor-HAT steuern | 281

$ git clone https://github.com/adafruit/Adafruit-Motor-HAT-Python-Library.git$ sudo apt-get install python-dev$ cd Adafruit-Motor-HAT-Python-Library/$ sudo python setup.py install

Die Bibliothek enthält auch einige Beispiele. Wechseln Sie also in das entspre-chende Verzeichnis und führen Sie das grundlegende Beispiel aus:

$ cd examples$ sudo python StepperTest.py

I2C-BusseWenn Sie wie in Rezept 9.20 beschrieben ein eigenes HAT ent-wickelt und den I2C-Bus 0 aktiviert haben, dann müssen Siediese Änderung in /boot/config.txt rückgängig machen, da Ada-fruit den zu nutzenden I2C-Bus automatisch erkennt und denfalschen wählt, wenn Bus 0 aktiv ist.

In /boot/config.txt löschen Sie die folgende Zeile (oder kommen-tieren sie aus):

dtparam=i2c_vc=on

Danach starten Sie den Raspberry Pi neu.

Abbildung 11-15: Adafruit-Schrittmotor-HAT zur Steuerung eines bipolaren Schrittmotors



DiskussionWenn Sie das Programm ausführen, beginnt sich der Motor zu drehen und es wer-den vier verschiedene Schrittmodi durchlaufen. Sie können das nachfolgende, ein-fache Beispiel nutzen, um Ihren Schrittmotor zu steuern.

Öffnen Sie einen Editor (nano oder IDLE) und kopieren Sie den folgenden Code.Wie alle Programmbeispiele aus diesem Buch können Sie auch dieses aus demCodebereich von http://www.oreilly.de/raspberrykochbuch herunterladen (unterdem Namen stepper_hat.py). Das Programm nutzt die Kommandozeile und kanndaher über SSH ausgeführt werden.

from Adafruit_MotorHAT import Adafruit_MotorHAT import time

HAT = Adafruit_MotorHATstepper_hat = Adafruit_MotorHAT()

stepper = stepper_hat.getStepper(200, 1) # 200 steps/rev, port 1 (M1, M2)

try: while True: speed = input("Enter stepper speed (rpm) ") stepper.setSpeed(speed) steps_forward = input("Steps forward ") stepper.step(steps_forward, HAT.FORWARD, HAT.SINGLE) steps_forward = input("Steps reverse ") stepper.step(steps_forward, HAT.BACKWARD, HAT.SINGLE)

finally: print("cleaning up") stepper_hat.getMotor(1).run(HAT.RELEASE)

Beim Import des Adafruit_MotorHAT-Moduls wird diesem der Name HAT zugewie-sen, um den Quellcode etwas kompakter zu fassen.

Der try/finally-Block stellt sicher, das die Spannung an den Spulen unterbrochenwird, sobald das Programm mit Ctrl-C beendet wird.

Siehe auchEine Diskussion zum HAT-Standard und wie man ein eigenes HAT entwickelt, fin-den Sie in Rezept 9.20.

Weitere Informationen zu diesem HAT und der dazugehörigen Bibliothek finden Sieauf https:// learn.adafruit.com/adafruit-dc-and-stepper-motor-hat-for-raspberry-pi/.

Wie man einen Schrittmotor per L293D steuert, erläutert Rezept 11.7. Wie das miteinem RasPiRobot gemacht wird, erklärt Rezept 11.9.


Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 201711.9 Ein RasPiRobot-Board zur Steuerung eines bipolaren Schrittmotors nutzen | 283

11.9 Ein RasPiRobot-Board zur Steuerung eines bipolaren Schrittmotors nutzen

Sehen Sie sich das dazugehörige Video auf http://razzpisampler.oreilly.com an.

ProblemSie möchten einen bipolaren Schrittmotor steuern und sowohl Motor als auch denRaspberry Pi mit nur einer Quelle mit Strom versorgen.

LösungVerwenden Sie ein RasPiRobot-Board V3.

Das RasPiRobot-Board nutzt die Stromversorgung von seinem DC-Anschluss, umden Motor zu versorgen, und regelt die gleiche Quelle auf 5 V herunter, um denRaspberry Pi zu versorgen. In diesem Fall liefert also die 12-V-Quelle den Stromsowohl für den Schrittmotor als auch für den Raspberry Pi.

Bei älteren Versionen des RasPiRobot-Boards (Version 1 oder 2)darf der Raspberry Pi nicht über den USB-Anschluss versorgtwerden, wenn das RasPiRobot-Board eingeschaltet ist.

Bei Version 3 des Boards ist das kein Problem.

Verbinden Sie den Schrittmotor und die Stromversorgung mit dem RasPiRobot-Board, wie in Abbildung 11-16 gezeigt wird. Die Farben der Anschlüsse des 12-V-Schrittmotors von Adafruit sind (vom DC-Anschluss ausgehend von links nachrechts) gelb, rot, grau und grün.

Bevor Sie das Programm ausführen können, müssen Sie die Bibliothek für denRasPiRobot V3 mit den folgenden Befehlen installieren:

$ git clone https://github.com/simonmonk/raspirobotboard3.git$ cd raspirobotboard3/python$ sudo python setup.py install

Öffnen Sie einen Editor (nano oder IDLE) und kopieren Sie den folgenden Code.Wie alle Programmbeispiele aus diesem Buch können Sie auch dieses aus demCodebereich von http://www.oreilly.de/raspberrykochbuch herunterladen (unterdem Namen stepper_rrb.py). Das Programm nutzt die Kommandozeile und kanndaher über SSH ausgeführt werden.



Abbildung 11-16: Ein RasPiRobot-Board zur Steuerung eines bipolaren Schrittmotors nutzen


from rrb3 import *import time

rr = RRB3(12.0, 12.0) # battery, motor

try: while True: delay = raw_input("Delay between steps (milliseconds)?") steps = raw_input("How many steps forward? ") rr.step_forward(int(delay) / 1000.0, int(steps)) steps = raw_input("How many steps backwards? ") rr.step_reverse(int(delay) / 1000.0, int(steps))

finally: GPIO.cleanup()

DiskussionSie werden feststellen, dass es einen Minimalwert für »Delay between Steps«, alsofür die Verzögerung zwischen zwei Schritten, gibt. Unterschreiten Sie diesen Wert,wird der Motor sich nicht bewegen, sondern nur zucken.


Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 201711.10 Einen einfachen Robot-Rover bauen | 285

Siehe auchMehr Informationen zum RasPiRobot-Board und zu den dazugehörigen Projektenfinden Sie auf der RasPiRobot-Website (http://www.raspirobot.com).

Wie sich ein Schrittmotor mit einem L293D auf einem Steckbrett betreiben lässt,wird in Rezept 11.7 erläutert.

11.10 Einen einfachen Robot-Rover bauen

ProblemSie möchten einen Raspberry Pi als Controller für einen einfachen fahrenden Robo-ter nutzen.

LösungNutzen Sie ein RasPiRobot-Board V3 als Schnittstelle zum Raspberry Pi, um zweiMotoren zu steuern, sowie ein Roboter-Chassis-Kit wie das Magician Chassis.


• RasPiRobot-Board V3 (Anhang A, Module, Seite 452)

• Magician Chassis mit Getriebemotoren (Anhang A, Vermischtes, Seite 453)

• 6xAA-Batteriehalter (Anhang A, Vermischtes, Seite 453)

• USB-WLAN-Adapter

Einen vollständigen Baukasten für diesen Roboter können Sie als MonkMakesRasPiRobot Rover Kit kaufen.

Im ersten Schritt müssen Sie das Magician Chassis zusammenbauen. Zum Chas-sis gehört ein Batteriehalter für vier AA-Batterien, doch um den Raspberry Pi mitzu versorgen, benötigen Sie einen solchen für sechs Batterien. Bei der entspre-chenden Aufbauanweisung des Magician Chassis verwenden Sie also den 6xAA-Batteriehalter.

Verkabeln Sie es so, wie es in Abbildung 11-17 gezeigt wird.



Abbildung 11-17: Verkabelung des fahrenden Roboters

Das Batteriepaket versorgt das RasPiRobot-Board, das wiederum den Raspberry Pimit 5V versorgt. Es wird also nur eine Stromversorgung benötigt.

Der fertige Rover sollte in etwa so wie in Abbildung 11-18 aussehen.

Abbildung 11-18: Der fertige Roboter

RasPiRobot-Board

Schwarz –

Rot +

USB-WLAN-Adapter


Simon Monk: Raspberry-Pi-Kochbuch (ISBN Print: 978-3-96009-033-5), 201711.10 Einen einfachen Robot-Rover bauen | 287

Um den Roboter zu bewegen, nutzen wir ein Programm, das es uns erlaubt, denRover mit den Tasten eines Laptops (oder anderen Computers) zu steuern, der überSSH mit dem Raspberry Pi verbunden ist. Falls noch nicht geschehen, richten SieWLAN (Rezept 2.5) und SSH (Rezept 2.7 auf Ihrem Raspberry Pi ein.

Öffnen Sie einen Editor (nano oder IDLE) und kopieren Sie den folgenden Code.Wie alle Programmbeispiele aus diesem Buch können Sie auch dieses aus demCodebereich von http://www.oreilly.de/raspberrykochbuch herunterladen (unterdem Namen rover.py).

from rrb3 import * import sysimport ttyimport termios

rr = RRB3(9.0, 6.0) # battery, motor

UP=0 DOWN=1 RIGHT = 2 LEFT=3print("Use the arrow keys to move the robot") print("Press Ctrl-C to quit the program")

# Über diese Funktionen liest das Programm die Tastatur ausdef readchar(): fd = sys.stdin.fileno() old_settings = termios.tcgetattr(fd) try: tty.setraw(sys.stdin.fileno()) ch = sys.stdin.read(1) finally: termios.tcsetattr(fd, termios.TCSADRAIN, old_settings) if ch == '0x03': raise KeyboardInterrupt return ch def readkey(getchar_fn=None): getchar = getchar_fn or readchar c1 = getchar() if ord(c1) != 0x1b: return c1 c2 = getchar() if ord(c2) != 0x5b: return c1 c3 = getchar() return ord(c3) - 65 # 0=nach oben, 1=nach unten, 2=rechts, 3=Links Pfeiltasten # Steuert die Bewegung und gibt sie auf dem Bildschirm austry: while True: keyp = readkey() if keyp == UP: rr.forward(1) print 'forward'



elif keyp == DOWN: rr.reverse(1) print 'backward' elif keyp == RIGHT: rr.right(1) print 'clockwise' elif keyp == LEFT: rr.left(1) print 'anti clockwise' elif ord(keyp) == 3: break

except KeyboardInterrupt: GPIO.cleanup()

Um Tastatureingaben abfangen zu können, nutzt dieses Programm die termios-Bi-bliothek sowie die beiden Funktionen readchar und readkey.

Nach dem Import der Bibliotheken wird eine neue Instanz von RRB3 erzeugt. AlsParameter werden dabei die Batterie- und die Motorspannung übergeben (in die-sem Fall 9V und 6V). Wenn Sie Motoren mit anderer Spannung verwenden, müs-sen Sie den zweiten Parameter entsprechend anpassen.

Die Hauptschleife überprüft, ob eine Taste gedrückt wurde, und sendet die entspre-chenden Befehle für vorwärts, rückwärts, links und rechts an die RBB3-Bibliothek.

DiskussionSie können den Rover interessanter gestalten, indem Sie zusätzliche Peripheriege-räte hinzufügen. Sie könnten beispielsweise eine Webcam anschließen und einWebstreaming aufsetzen, um aus Ihrem Rover eine fahrende Spycam zu machen(Rezept 4.4).

Die RBB3-Bibliothek unterstützt auch Entfernungsmesser vom Typ HC-SR04, diein einen Sockel auf dem RasPiRobot-Board V3 eingesteckt werden können. Aufdiese Weise können Sie Hindernisse erkennen. Entsprechende Softwarebeispielefinden Sie in der RRB3-Bibliothek.

Siehe auchMehr Informationen zum RasPiRobot-Board und der RRB3-Bibliothek finden Sieauf GitHub (https://github.com/simonmonk/raspirobotboard3).


2., aktualisierte und erweiterte Auflage Raspberry-Pi … · Simon Monk: Raspberry-Pi-Kochbuch...

Documents

Transcript of 2., aktualisierte und erweiterte Auflage Raspberry-Pi … · Simon Monk: Raspberry-Pi-Kochbuch...