Conrad 4019631150028 Operation Manual [de]
2
Alle Versuche im Überblick
Adventskalender Raspberry Pi 2017 .............. 3
Die wichtigsten Bauteile kurz erklärt .......................... 3
Steckbrett ............................................... 3
LEDs ................................................... 3
RGB-LEDs ............................................... 3
Widerstand .............................................4
Servo .................................................. 4
GPIO-Verbindungskabel .................................... 4
1. Tag .....................................5
Heute im Adventskalender ..................................5
Raspberry Pi vorbereiten ................................... 5
Betriebssysteminstallation in Kürze ........................... 5
LED leuchtet ............................................. 5
Das Programm ........................................... 6
2. Tag .....................................7
Heute im Adventskalender .................................. 7
Zwei LEDs blinken abwechselnd rot und grün ................... 7
Das Programm ........................................... 7
3. Ta g .....................................8
Heute im Adventskalender ..................................8
Zwei LEDs blinken mit Python abwechselnd rot und grün ..........8
Das Programm ........................................... 8
So funktioniert das Programm ............................... 8
4. Tag .................................... 10
Heute im Adventskalender ..................................10
LEDs mit Taster umschalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10
Das Programm ...........................................10
5. Ta g .....................................12
Heute im Adventskalender ..................................12
LEDs auf der Weihnachtspyramide mit Python umschalten .........12
Die Weihnachtspyramide ...................................12
Das Programm ...........................................12
So funktioniert das Programm ...............................13
6. Ta g .....................................14
Heute im Adventskalender ..................................14
Scratch-Katze schaltet LEDs .................................14
Das Programm ...........................................14
7. Tag .................................... 16
Heute im Adventskalender ..................................16
LEDs mit einer Smartphone-App schalten .......................16
Umsetzung des Projekts ....................................17
Das Programm ...........................................17
Die App ................................................18
8. Ta g .................................... 20
Heute im Adventskalender .................................20
LEDs dimmen ........................................... 20
Das Programm .......................................... 20
9. Ta g .................................... 22
Heute im Adventskalender ................................. 22
LEDs mit Python dimmen .................................. 22
Das Programm .......................................... 22
So funktioniert das Programm .............................. 22
10. Tag ................................... 24
Heute im Adventskalender ................................. 24
LEDs mit App dimmen .................................... 24
Das Programm .......................................... 24
Die App ............................................... 25
11. Tag ....................................26
Heute im Adventskalender .................................26
Servo steuern ........................................... 26
Das Programm .......................................... 26
12. Tag ................................... 27
Heute im Adventskalender ..................................27
Servo dreht mit Python ....................................27
Das Programm ...........................................27
So funktioniert das Programm .............................. 28
13. Tag ................................... 29
Heute im Adventskalender ................................. 29
Servo mit App steuern .................................... 29
Das Programm .......................................... 29
Die App ............................................... 29
14. Tag ....................................31
Heute im Adventskalender ..................................31
Sensorkontakt aus Knete ...................................31
So funktionieren Sensorkontakte .............................31
Das Programm .......................................... 32
15. Tag ................................... 33
Heute im Adventskalender ................................. 33
RGB-Farbspiele .......................................... 33
Das Programm .......................................... 33
16. Tag ...................................34
Heute im Adventskalender ................................. 34
RGB-Farbmischung ....................................... 34
Das Programm .......................................... 34
17. Tag .................................... 35
Heute im Adventskalender ................................. 35
Analoge Anzeige mit Servo ................................. 35
Das Programm .......................................... 35
18. Tag ................................... 37
Heute im Adventskalender ..................................37
Drehbare Weihnachtspyramide ..............................37
Das Programm ...........................................37
19. Ta g ...................................38
Heute im Adventskalender .................................38
Drehbare Weihnachtspyramide mit Taster steuern ............... 38
Das Programm .......................................... 38
So funktioniert das Programm .............................. 39
20. Tag ...................................40
Heute im Adventskalender .................................40
Drehbare Weihnachtspyramide mit App-Steuerung ............... 40
Das Programm .......................................... 40
Die App ................................................41
21. Tag ................................... 43
Heute im Adventskalender ................................. 43
Weihnachtspyramide mit Knetesteuerung ...................... 43
Das Programm .......................................... 43
So funktioniert das Programm .............................. 44
22. Tag ...................................45
Heute im Adventskalender ................................. 45
Drehbare Weihnachtspyramide mit Knete steuern ............... 45
Das Programm .......................................... 45
23. Tag ................................... 47
Heute im Adventskalender ..................................47
RGB-Farbspiele mit Python ..................................47
Das Programm ...........................................47
So funktioniert das Programm .............................. 48
24. Tag ...................................50
Heute im Adventskalender .................................50
Uhr für Wartezeit bis zum nächsten Adventskalender ............. 50
Das Programm .......................................... 50
So funktioniert das Programm ...............................51
Adventskalender Raspberry Pi 2017
Mit einem normalen PC oder gar einem Notebook einfache Elektronik zu steuern ist – auch wenn es nur
ein paar LEDs sind – für den Hobbyprogrammierer mit kaum vertretbarem Aufwand verbunden. Dem PC
fehlen einfach die dafür notwendigen Schnittstellen. Außerdem ist das Windows-Betriebssystem denkbar
ungeeignet dafür, mit Elektronik zu kommunizieren.
Der RaspberryPi ist – obwohl es auf den ersten Blick gar nicht so aussieht – ein vollwertiger Computer.
Vieles geht etwas langsamer, als man es von modernen PCs gewohnt ist, dafür ist der RaspberryPi aber
auch viel kleiner und vor allem billiger als ein PC.
Dieser Adventskalender enthält für jeden Tag ein Hardwareexperiment mit dem RaspberryPi. Die Experimente werden mit Scratch oder Python programmiert. Beide Programmiersprachen sind auf dem RaspberryPi vorinstalliert. Alle Experimente funktionieren mit dem RaspberryPi3.
Die wichtigsten Bauteile kurz erklärt
Steckbrett
Für den schnellen Aufbau elektronischer Schaltungen, ohne dass man löten muss,
enthält der Adventskalender ein Steckbrett. Hier können elektronische Bauteile
direkt in ein Lochraster gesteckt werden.
Bei diesem Steckbrett sind alle äußeren Längsreihen über Kontakte (X und Y) miteinander verbunden. Diese Kontaktreihen werden oft als Plus- und Minuspol zur Stromversorgung der Schaltungen genutzt. In den anderen Kontaktreihen sind jeweils fünf
Kontakte (A bis E und F bis J) quer miteinander verbunden, wobei in der Mitte der
Platine eine Lücke ist. So können hier größere Bauelemente eingesteckt und nach
außen hin verdrahtet werden.
Die Verbindungen auf dem Steckbrett.
3
LEDs
LEDs (zu Deutsch: Leuchtdioden) leuchten, wenn Strom in Durchflussrichtung durch sie fließt. LEDs werden in Schaltungen mit
einem pfeilförmigen Dreieckssymbol dargestellt, das die Flussrichtung vom Pluspol zum Minuspol oder zur Masseleitung angibt.
Eine LED lässt in der Durchflussrichtung nahezu beliebig viel Strom
durch, sie hat nur einen sehr geringen Widerstand. Um den Durchflussstrom zu begrenzen und damit ein Durchbrennen der LED zu
verhindern, wird üblicherweise zwischen dem verwendeten GPIO-Pin und der Anode der LED oder zwischen Kathode und Massepin ein 220-Ohm-Vorwiderstand eingebaut. Dieser Vorwiderstand schützt auch
den GPIO-Ausgang des RaspberryPi vor zu hohen Stromstärken. Die LEDs im Adventskalender haben
den Vorwiderstand bereits eingebaut und können daher direkt an die GPIO-Pins angeschlossen werden.
LED in welcher Richtung anschließen?
Die beiden Anschlussdrähte einer LED sind unterschiedlich lang. Der längere ist der Pluspol, die Anode,
der kürzere die Kathode. Einfach zu merken: Das Pluszeichen hat einen Strich mehr als das Minuszeichen
und macht damit den Draht quasi etwas länger. Außerdem sind die meisten LEDs auf der Minusseite
abgeflacht, vergleichbar mit einem Minuszeichen. Auch leicht zu merken: Kathode = kurz = Kante.
Schaltplan einer LED mit Vorwiderstand.
RGB-LEDs
Eine normale LED leuchtet immer nur in einer Farbe. Die im Adventskalender verwendeten RGB-LEDs
können wahlweise in mehreren Farben leuchten. Bei ihnen sind im Prinzip drei verschiedenfarbige LEDs
in einem transparenten Gehäuse eingebaut. Jede dieser drei LEDs hat eine eigene Anode, über die sie mit
einem GPIO-Pin verbunden wird. Die Kathode, die mit der Masseleitung verbunden wird, ist nur einmal
vorhanden. Deshalb hat eine RGB-LED vier Anschlussdrähte.
Die Anschlussdrähte von RGB-LEDs sind unterschiedlich
lang, damit sie eindeutig zu erkennen sind. Anders als bei
normalen LEDs ist die Kathode hier der längste Draht.
RGB-LEDs funktionieren wie drei einzelne LEDs und brauchen deshalb auch drei Vorwiderstände. Diese sind in den
im Adventskalender enthaltenen RGB-LEDs ebenfalls eingebaut.
Anschlusspins einer RGB-LED.
4
Widerstand
Widerstände werden zur Strombegrenzung an empfindlichen elektronischen Bauteilen sowie als Vorwiderstände für LEDs verwendet. Die Maßeinheit für Widerstände
ist Ohm. 1.000 Ohm entsprechen einem Kiloohm, abgekürzt kOhm. 1.000 kOhm
entsprechen einem Megaohm, abgekürzt MOhm. Oft wird für die Einheit Ohm auch
das Omega-Zeichen Ω verwendet.
Die farbigen Ringe auf den Widerständen geben den Widerstandswert an. Mit etwas
Übung sind sie deutlich leichter zu erkennen als winzig kleine Zahlen, die man nur
noch auf ganz alten Widerständen findet.
Die meisten Widerstände haben vier solcher Farbringe. Die ersten beiden Farbringe
bezeichnen die Ziffern, der dritte einen Multiplikator und der vierte die Toleranz.
Dieser Toleranzring ist meistens gold- oder silberfarben – Farben, die auf den ersten
Ringen nicht vorkommen. Dadurch ist die Leserichtung immer eindeutig. Der Tole-
Interner Schaltplan für eine RGB-LED mit drei Vorwiderständen.
Farbe Widerstandswert in Ohm
1. Ring
(Zehner)
Silber 10−2 = 0,01 ±10%
Gold 10−1 = 0,1 ±5%
Schwarz 0 100 = 1
Braun 1 1 101 = 10 ±1%
Rot 2 2 102 = 100 ±2%
Orange 3 3 103 = 1.000
Gelb 4 4 104 = 10.000
Grün 5 5 105 = 100.000 ±0,5%
Blau 6 6 106 = 1.000.000 ±0,25%
Violett 7 7 107 = 10.000.000 ±0,1%
Grau 8 8 108 = 100.000.000 ±0,05%
Weiß 9 9 109 = 1.000.000.000
Belegung der GPIO-Pins.
2. Ring
(Einer)
ranzwert selbst spielt in der Digitalelektronik kaum eine Rolle. Die Tabelle zeigt die
Bedeutung der farbigen Ringe auf Widerständen.
3. Ring
(Multiplikator)
4. Ring
(Toleranz)
GPIO-Pin des RaspberryPi passt. LEDs und andere Bauteile können direkt in diese Steckbuchsen gesteckt werden. Zusätzlich sind
Pinleisten enthalten, die in das Steckbrett gesteckt werden, um die
Verbindungskabel mit Kontaktreihen zu verbinden. Jede Pinleiste
verfügt über drei Pins, die voneinander unabhängig, also nicht
elektrisch verbunden sind.
In welcher Richtung ein Widerstand eingebaut
wird, ist egal. Bei LEDs dagegen spielt die Einbaurichtung eine große Rolle.
Servo
Ein Servo ist ein kleiner Motor mit einem Arm, an
dem Gegenstände befestigt werden können. Mit
einem Steuerungssignal kann dieser um einen
bestimmten Winkel gedreht werden. Servos haben
drei Anschlussleitungen, zwei dienen der Stromversorgung, auf der dritten empfängt das Servo die
Steuerungssignale.
GPIO-Verbindungskabel
Die farbigen Verbindungskabel haben alle auf
beiden Seiten eine Steckbuchse, die auf einen
Vorsichtsmaßnahmen
Auf keinen Fall sollte man irgendwelche GPIO-Pins miteinander verbinden und abwarten ab, was passiert.
Nicht alle GPIO-Pins lassen sich frei programmieren. Ein paar sind für die Stromversorgung und andere
Zwecke fest eingerichtet.
Einige GPIO-Pins sind direkt mit Anschlüssen des Prozessors verbunden, ein Kurzschluss kann den
Rasp berryPi komplett zerstören. Verbindet man über einen Schalter oder eine LED zwei Pins miteinander, muss immer ein Schutzwiderstand dazwischengeschaltet werden. Eine Ausnahme bilden die LEDs
mit eingebautem Vorwiderstand.
Für Logiksignale muss immer Pin1 verwendet werden, der +3,3V liefert und bis 50mA belastet werden kann. Pin6 ist die Masseleitung für Logiksignale.
Pin2 und 4 liefern +5V zur Stromversorgung externer Hardware. Hier kann so viel Strom entnommen
werden, wie das USB-Netzteil des RaspberryPi liefert. Diese Pins dürfen aber nicht mit einem GPIOEingang verbunden werden.
1. Tag
5
Heute im Adventskalender
• 1 LED rot mit eingbautem Vorwiderstand
• 1 GPIO-Verbindungskabel
Raspberry Pi vorbereiten
Um den Raspberry Pi in Betrieb zu nehmen, braucht man:
• USB-Tastatur und Maus
• HDMI-Kabel für Monitor
• Netzwerkkabel
• MicroSD-Karte mit Betriebssystem Raspbian Jessie
• Micro-USB-Handyladegerät als Netzteil (mindestens 2 A)
Das Netzteil muss als Letztes angeschlossen werden, damit schaltet sich der Raspberry Pi automatisch
ein. Es gibt keinen eigenen Ein-/Ausschalter.
Betriebssysteminstallation in Kürze
Für alle, die ihren Raspberry Pi noch nicht mit der aktuellen Raspbian-Version betriebsbereit haben, folgt
hier die Systeminstallation in zehn Schritten:
1.NOOBS (mindestens Version 2.0.0) von www.raspberrypi.org/downloads auf den PC herunterladen
und Zip-Archiv auf die Festplatte entpacken.
2.Wurde die SD-Karte bereits benutzt, mit SD-Formatter im PC neu formatieren: www.sdcard.org/
downloads/formatter_4. Dabei Format Size Adjustment einschalten (die SD-Karte muss mindestens
4GB groß sein).
3.Die Dateien und Unterverzeichnisse von NOOBS auf die SD-Karte kopieren.
4.SD-Karte aus dem PC nehmen, in den RaspberryPi stecken und booten. Ganz unten Deutsch als Installationssprache wählen. Dann wird automatisch auch die deutsche Tastatur ausgewählt.
5.Das Häkchen beim vorausgewählten Raspbian-Betriebssystem setzen und oben links auf Install klicken. Nach Bestätigung einer Sicherheitsabfrage, dass die Speicherkarte überschrieben wird, startet die
Installation, die einige Minuten dauert.
6.Nach abgeschlossener Installation bootet der RaspberryPi neu.
7.Im Menü unter Einstellungen das Tool Raspberry Pi Configuration
starten.
8.Auf der Registerkarte Lokalisierung im Feld Zeitzone festlegen die
Optionen Europe und Berlin auswählen. Sprachumgebung und Tasta-
tur sollten automatisch auf Deutsch gesetzt sein.
9.Auf der Registerkarte Schnittstellen den Schalter SSH auf Aktiviert
setzen, wenn Sie über das Netzwerk Daten vom PC auf den RaspberryPi
übertragen wollen.
10.Auf OK klicken und den RaspberryPi über den Menüpunkt Shut-
down neu booten. Eine eventuell auftauchende Warnung wegen eines
unsicheren Passworts kann ignoriert werden.
1. Tag
LED leuchtet
Das Experiment zeigt, wie LEDs angeschlossen werden. Achten Sie darauf, dass die LED richtig herum eingebaut ist. Die Kathode (kurzer Draht)
ist mit dem GND-Pin des RaspberryPi verbunden, die Anode (langer
Draht) mit dem GPIO-Pin4. Stecken Sie die LED einfach direkt in die
GPIO-Verbindungskabel. Alle Schaltungsaufbauzeichnungen sind in den
Downloads zum Adventskalender in Farbe enthalten, damit Sie die Leitungen besser erkennen können.
Bauteile: 1 LED rot mit eingbautem Vorwiderstand, 2 GPIO-Verbindungskabel
Gesteuert wird das Ganze über ein Programm in Scratch.
Die erste LED leuchtet am Raspberry Pi.
6
GPIO-Server in Scratch starten.
Programme zum Download
Die im Adventskalender verwendeten Programme und Aufbauzeichnungen gibt es hier zum Download:
www.buch.cd. Tragen Sie für dieses Produkt den Code 15002-8 in das Eingabefeld ein.
Öffnen Sie die Webseite direkt mit dem auf dem RaspberryPi vorinstallierten Browser und
laden Sie die Zip-Datei in das Home-Verzeichnis /home/pi herunter.
Starten Sie den Dateimanager auf dem RaspberryPi. Er zeigt beim Start automatisch das
Home-Verzeichnis an. Klicken Sie mit der rechten Maustaste auf die heruntergeladene Zip-Datei
und wählen Sie im Kontextmenü Hier entpacken. Das Archiv enthält insgesamt 25 Verzeichnisse, jeder
Tag ist in einem eigenen Verzeichnis abgelegt. Zusätzlich gibt es ein allgemeines Verzeichnis.
Das Programm
Scratch ist auf dem RaspberryPi im Menü unter Entwicklung vorinstalliert
und gilt als eine der am leichtesten zu erlernenden Programmiersprachen. Seit
Raspbian Jessie unterstützt Scratch die GPIO-Schnittstelle des RaspberryPi. Die
GPIO-Unterstützung muss vor der ersten Verwendung über den Menüpunkt Bear-
beiten/Start GPIO server eingeschaltet werden.
In Scratch braucht man beim Programmieren keinen Programmcode zu tippen.
Die Blöcke werden einfach nur per Drag-and-drop aneinandergehängt. Die Blockpalette im linken Teil des Scratch-Fensters enthält, nach Themen geordnet, die
verfügbaren Blöcke.
Dieses Scratch-Programm 01led01 lässt die LED eine halbe Sekunde leuchten.
Textfeld werden die jeweilige Pinbezeichnung und entsprechende Schlüsselwörter eingetragen. Klicken
Sie dazu in das Textfeld im Block, wählen Sie Neu/edit... und geben Sie den Text ein.
Sie können das Programm auf dem Bildschirm selbst zusammenbauen oder das Programm 01led01 aus dem Download zum
Adventskalender verwenden. Wählen Sie dazu Öffnen im Menü
Datei und klicken Sie im nächsten Dialogfeld auf die Schaltfläche
pi, um das persönliche Home-Verzeichnis auszuwählen, in dem
die heruntergeladenen Programme liegen.
Klicken Sie in Scratch oben links auf das gelbe Symbol Steue-
rung. Daraufhin werden in der Blockpalette links die Blöcke zur
Steuerung angezeigt. Für dieses erste Programm brauchen wir nur
diese gelben Blöcke.
Ziehen Sie die Blöcke, die Sie brauchen, einfach aus der Blockpalette in das Skriptfenster in der Mitte von Scratch.
Der Block Wenn (grüne Fahne) ange-
klickt dient dazu, ein Programm zu star-
ten. Die folgenden Skriptelemente werden ausgeführt, wenn man
auf das grüne Fähnchen rechts oben in Scratch klickt. Der Block
ist oben rund, passt also unter keinen anderen Block. Er muss
immer als Erstes gesetzt werden.
Die GPIO-Befehle werden über den ScratchBlock sende... an alle ausgegeben. In das
Am Anfang wird der GPIO-Pin4 mit config4out als Ausgang definiert. Jeder GPIO-Pin kann entweder
Ausgang oder Eingang sein.
Im nächsten Schritt wird über einen weiteren Scratch-Block sende... an alle mit dem Text gpio4on die
an GPIO-Pin4 angeschlossene LED eingeschaltet.
Danach wartet das Programm eine halbe Sekunde. Dazu bietet Scratch einen eigenen
Block warte...Sek. an. Scratch verwendet wie viele amerikanische Programme den
Punkt als Dezimaltrennzeichen, nicht das in Deutschland übliche Komma. Eine halbe Sekunde wird also
als 0.5 eingetragen und nicht als 0,5.
Zuletzt wird über einen weiteren Scratch-Block sende... an alle mit dem Text gpio4off die an GPIO-Pin4
angeschlossene LED wieder ausgeschaltet
Das Programm startet, wenn man oben rechts im Scratch-Fenster auf das grüne Fähnchen klickt.
2. Tag
7
Heute im Adventskalender
• 1 Steckbrett (SYB 46)
• 1 LED grün mit eingebautem Vorwiderstand
• 1 GPIO-Verbindungskabel
• 2 Pinleisten (3 Pins)
Zwei LEDs blinken abwechselnd rot und grün
Das Experiment des 2. Tags lässt beide LEDs abwechselnd rot und grün
leuchten. Gesteuert wird das Ganze über eine Endlosschleife in Scratch.
Bauteile: 1 Steckbrett, 1 LED rot mit eingbautem Vorwiderstand, 1 LED
grün mit eingbautem Vorwiderstand, 3 GPIO-Verbindungskabel, 2
Pinleisten (3 Pins)
Diesmal nutzen wir, wie bei den meisten Experimenten in diesem
Adventskalender, ein Steckbrett zum Aufbau der Schaltung. Verwenden
Sie die mitgelieferten Pinleisten, um die GPIO-Verbindungskabel am
Steckbrett anzuschließen.
Das Programm
Am Anfang werden die beiden GPIO-Pins4 und 10 mit config4out und
config10out als Ausgänge definiert.
2. Tag
Eine wiederhole fortlaufend-Schleife sorgt dafür, dass die beiden LEDs
endlos blinken, und zwar so lange, bis der Benutzer auf das rote Stoppsymbol oben rechts in Scratch klickt.
Zwei LEDs blinken am RaspberryPi.
Wenn die rote LED an Pin4 eingeschaltet und die grüne an Pin10 ausgeschaltet ist, wartet das Programm eine halbe Sekunde. Danach werden
auf die gleiche Weise die grüne LED an Pin10 eingeschaltet und die rote
an Pin4 ausgeschaltet. Nach einer weiteren halben Sekunde wiederholt sich der Zyklus.
Das Programm 02led02 steuert die beiden LEDs.
8
3. Tag
3. Ta g
Heute im Adventskalender
• 2 GPIO-Verbindungskabel
Zwei LEDs blinken mit Python abwechselnd rot und grün
Das Experiment des 3. Tags lässt wieder zwei LED abwechselnd rot und
grün leuchten. Allerdings verwenden wir diesmal Python statt Scratch.
Bauteile: 1 Steckbrett, 1 LED rot mit eingebautem Vorwiderstand,
1 LED grün mit eingebautem Vorwiderstand, 3 GPIO-Verbindungskabel,
2 Pinleisten (3 Pins)
Python ist auf dem RaspberryPi ebenfalls vorinstalliert, sogar in zwei
verschiedenen Versionen. Python3 ist nicht einfach, wie der Name vermuten lässt, eine neuere Version von Python2. Die Sprachen verwenden
teilweise eine andere Syntax. Programme sind also nicht eins zu eins
kompatibel. Viele externe Bibliotheken sind nur für eine der beiden
Versionen erhältlich. Entwickler von Python-Programmen müssen ihren
Nutzern also immer mitteilen, mit welcher Version ein Programm funktioniert. Wir verwenden in diesem Adventskalender immer das moderne
Python 3.
Starten Sie im Menü unter Entwicklung das Programm Python3. IDLE
ist eine komplette Python-Shell und -Entwicklungsumgebung. Für den
Start in die Programmierung sind keine zusätzlichen Komponenten
nötig.
Zwei LEDs blinken am Raspberry Pi.
Öffnen Sie über File/Open das Programm 03led02.py aus dem Download oder öffnen Sie in der Python-Shell über File/New ein neues Fenster und tippen Sie das Programm ein.
Das Programm
Das Programm ist eine fast genaue Umsetzung des Scratch-Programms
vom 2. Tag, jedoch mit einem wichtigen Unterschied: Die LEDs blinken
nicht ewig, sondern genau zehnmal.
#!/usr/bin/python
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(4, GPIO.OUT)
GPIO.setup(10, GPIO.OUT)
for i in range(10):
GPIO.output(4, True)
GPIO.output(10, False)
time.sleep(0.5)
GPIO.output(10, True)
GPIO.output(4, False)
time.sleep(0.5)
GPIO.cleanup()
So funktioniert das Programm
#!/usr/bin/python
Python-Programme, die über die Kommandozeile gestartet werden, müssen am Anfang immer obige
Zeile enthalten. Bei Programmen, die nur über die Python-Shell gestartet werden, ist das nicht nötig.
Aus Gründen der Kompatibilität sollten Sie sich aber angewöhnen, diese Zeile am Anfang jedes PythonProgramms einzutragen.
import RPi.GPIO as GPIO
import time
Ein großer Vorteil von Python ist die einfache Erweiterbarkeit um neue Funktionen aus Funktionsbibliotheken. Für nahezu jede Aufgabe gibt es bereits fertige Bibliotheken, sodass Sie viele Standardaufgaben
nicht mehr selbst zu lösen brauchen. Die Bibliothek RPI.GPIO wird für die Unterstützung der GPIO-Pins
importiert, die Bibliothek time enthält Zeitfunktionen, zum Beispiel, um eine Wartezeit zwischen dem
Blinken der beiden LEDs zu realisieren.
GPIO.setmode(GPIO.BCM)
Die Bibliothek RPi.GPIO unterstützt zwei Methoden zur Bezeichnung der Pins. Im Modus BCM werden
die bekannten GPIO-Portnummern verwendet, die auch in Scratch genutzt werden. Im Modus BOARD
entsprechen die Bezeichnungen den Pinnummern auf der Raspberry-Pi-Platine. Üblicherweise wird BCM
verwendet. Deshalb und um die Python-Programme mit den Scratch-Programmen leichter vergleichen zu
können, verwenden wir in diesem Adventskalender ebenfalls den Modus BCM.
GPIO.setup(4, GPIO.OUT)
GPIO.setup(10, GPIO.OUT)
Die Funktion GPIO.setup initialisiert einen GPIO-Pin als Ausgang oder als Eingang. Der erste Parameter
bezeichnet den Pin je nach vorgegebenem Modus, BCM oder BOARD, mit seiner GPIO oder Pinnummer. Der
zweite Parameter kann entweder GPIO.OUT für einen Ausgang oder GPIO.IN für einen Eingang sein.
for i in range(10):
Schleifen mit for arbeiten eine bestimmte Anzahl von Durchläufen ab. Dabei kann im Parameter
range() außer einer einfachen Zahl auch ein Wertebereich oder eine Berechnungsfunktion angegeben
werden.
9
Einrückungen sind in Python wichtig
In den meisten Programmiersprachen werden Programmschleifen oder Entscheidungen eingerückt,
um den Programmcode übersichtlicher zu machen. In Python dienen diese Einrückungen nicht nur
der Übersichtlichkeit, sondern sind für die Programmlogik sogar zwingend nötig. Dafür braucht man in
dieser Sprache keine speziellen Satzzeichen, um Schleifen oder Entscheidungen zu beenden.
GPIO.output(4, True)
GPIO.output(10, False)
Die eingerückten Zeilen werden in jedem Schleifendurchlauf einmal ausgeführt. Die Funktion GPIO.
output setzt den Status eines GPIO-Pins. Jeder Pin kann auf zwei verschiedene Zustände gesetzt werden.
True schaltet den Pin ein, False schaltet ihn wieder aus. Die obigen Zeilen schalten die LED an GPIO-
Pin4 ein und die LED an GPIO-Pin10 aus.
time.sleep(0.5)
Das Programm wartet eine halbe Sekunde.
GPIO.output(10, True)
GPIO.output(4, False)
time.sleep(0.5)
Anschließend wird die LED an GPIO-Pin10 ein- und die LED an GPIO-Pin4 ausgeschaltet. Danach wartet
das Programm wieder eine halbe Sekunde.
GPIO.cleanup()
Die letzte Zeile ist nicht mehr eingerückt, sie wird erst ausgeführt, nachdem die Schleife zehnmal
durchgelaufen ist. Am Ende eines Programms müssen alle verwendeten GPIO-Pins wieder zurückgesetzt
werden, um Warnungen beim nächsten Programmstart zu vermeiden. Die obige Zeile erledigt das für
alle vom Programm initialisierten GPIO-Pins auf einmal. Pins, die von anderen Programmen initialisiert
wurden, bleiben davon unberührt. So wird der Ablauf dieser anderen, möglicherweise parallel laufenden
Programme nicht gestört.
10
4. Tag
4. Tag
Heute im Adventskalender
• 1 Taster
• 1 Pinleiste (3 Pins)
LEDs mit Taster umschalten
Das Experiment des 4. Tags schaltet die LEDs nicht automatisch um, sondern erst, wenn der Benutzer einen Taster betätigt.
Bauteile: 1 Steckbrett, 1 LED rot mit eingbautem Vorwiderstand, 1 LED
grün mit eingebautem Vorwiderstand, 1 Taster, 5 GPIO-Verbindungskabel, 3 Pinleisten (3 Pins)
Das Programm
Das Programm funktioniert ähnlich wie das des 2. Tags. Auch hier
werden in einer Endlosschleife abwechselnd die beiden LEDs ein- und
ausgeschaltet. Im Unterschied zum vorherigen Programm erfolgt die
Umschaltung nicht nach einer bestimmten Zeit, sondern erst, wenn der
Benutzer den Taster gedrückt hat.
LEDs mit Taster umschalten.
Das Programm 04taster01 steuert die beiden LEDs über einen Taster.
Am Anfang wird zusätzlich zu den beiden Ausgängen GPIO-Pin7 als Eingang definiert. Eingänge am RaspberryPi verarbeiten digitale Logiksignale. Ist ein Eingang mit +3,3V verbunden, bekommt er das Signal
logisch High, was Scratch als 1 auswertet, ist der Eingang mit GND verbunden, bekommt er das Signal
logisch Low, was Scratch als 0 auswertet.
Achtung
Verwenden Sie nie die +5-V-Pins des RaspberryPi für Logiksignale in Schaltungen. 5V würden die
GPIO-Eingänge überlasten und den RaspberryPi beschädigen.
Ein Druck auf den Taster verbindet in unserer Schaltung den GPIO-Pin7 mit +3,3V. Lässt man den Taster
wieder los, bekommt der Eingang einen undefinierten Zustand, was in der Digitalelektronik nicht passieren darf. Für solche Fälle verfügen alle GPIO-Pins über sogenannte Pull-down-Widerstände, die einen
Eingang, an dem kein Signal anliegt, automatisch auf Low herunterziehen.
Definieren Sie den GPIO-Pin für den Taster mit config7inpulldown, um den eingebauten Pull-downWiderstand am Eingang zu aktivieren.
Wenn eine LED leuchtet, wartet das Programm nicht mehr eine bestimmte Zeit lang, sondern mit einem
warte bis...-Block, bis ein bestimmtes Ereignis eintritt, in diesem Fall bis der GPIO-Pin7 den Wert 1
annimmt, der Taster also gedrückt wurde.
Für die Abfrage selbst ist im warte bis...-Block ein längliches Feld mit spitzen Enden vorgesehen. Hier
muss ein Block aus der grünen Blockpalette Operatoren eingefügt werden. Ziehen Sie den Block mit
dem Gleichheitszeichen auf das Platzhalterfeld im warte bis...-Block.
Dieser Operator ist immer dann wahr, wenn die beiden Werte links und rechts des Gleichheitszeichens
gleich sind.
In unserem Fall soll der Wert des GPIO-Pins7 dem Wert 1 entsprechen. Die Ziffer 1 steht für High. Schreiben Sie also eine 1 in das rechte der beiden Textfelder in dem grünen Block.
Klicken Sie jetzt einmal auf das grüne Fähnchen oben rechts, um das noch unfertige Programm zu starten. Damit werden die GPIO-Pins definiert. Klicken Sie anschließend wieder auf das rote Stoppschild.
Zur Abfrage von GPIO-Eingängen wird der Block Wert von Sensor... aus der blauen Blockpalette Fühlen
verwendet. Wählen Sie im Listenfeld des blauen Blocks den Sensor GPIO-7 aus. Neben einigen vordefi-
nierten Sensoren werden alle GPIO-Pins zur Auswahl angeboten, die als Eingang definiert sind. Deshalb
musste das Programm einmal kurz gestartet werden.
11
Ziehen Sie dann den blauen Block Wert von Sensor... in das linke Feld des grünen Blocks innerhalb des
warte bis...-Blocks.
Danach wartet das Programm mit einem warte...Sek.-Block 0,2 Sekunden. Damit wird verhindert, dass
der Taster sofort wieder als gedrückt gilt, wenn das Programm weiterläuft. Der Benutzer hat so lange Zeit,
den Taster wieder loszulassen.
Erst anschließend werden die LEDs umgeschaltet, und das Programm wartet erneut darauf, dass der
Benutzer den Taster drückt.
Blöcke duplizieren
Beim Bau eines Scratch-Programms brauchen Sie ähnliche Blockkombinationen nicht jedes Mal neu
anzulegen. Klicken Sie mit der rechten Maustaste auf den ersten Block, der dupliziert werden soll.
Wählen Sie dann im Menü Duplizieren. Alle darunterhängenden Blöcke werden automatisch mit
dupliziert. Die duplizierten Blöcke können dann an passender Stelle im Programm wieder eingefügt
werden.
12
5. Tag
5. Ta g
Heute im Adventskalender
• 2 GPIO-Verbindungskabel
LEDs auf der Weihnachtspyramide mit Python umschalten
Das Programm des 5. Tags verwendet Python, um zwei LEDs mit einem
Taster umzuschalten. Die LEDs können diesmal auf die Weihnachtspyramide gesteckt werden und sind mit GPIO-Verbindungskabeln direkt am
RaspberryPi angeschlossen.
Bauteile: 1 Steckbrett, 1 LED rot mit eingebautem Vorwiderstand, 1 LED
grün mit eingebautem Vorwiderstand, 1 Taster, 6 GPIO-Verbindungskabel, 1 Pinleiste (3 Pins)
Die Weihnachtspyramide
Auf der Rückseite des Adventskalenders befinden sich zwei Teile zum
Ausschneiden, die zusammengesetzt eine Weihnachtspyramide ergeben.
Zwei LEDs auf der Pyramide und ein Taster auf dem Steckbrett.
Das Programm
Im Unterschied zum Scratch-Programm von gestern leuchtet im Python-Programm 05pyramide01.py die
rote LED an Pin4 nur, solange der Taster gedrückt ist. Lässt man ihn wieder los, leuchtet stattdessen die
grüne LED an Pin 10.
Die beiden Teile der Weihnachtspyramide.
Falten Sie das ovale Teil entlang der aufgedruckten Linien und schneiden
Sie auf beiden Teilen die kurzen Linienstücke ein. Die runden Löcher im
dreieckigen Teil sind für die LEDs. Setzen Sie die Weihnachtspyramide
dann wie auf der Abbildung gezeigt zusammen.
So wird die Weihnachtspyramide zusammengesetzt.
#!/usr/bin/python
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(4, GPIO.OUT)
GPIO.setup(10, GPIO.OUT)
GPIO.setup(7, GPIO.IN, GPIO.PUD_DOWN)
try:
while True:
if GPIO.input(7)==True:
GPIO.output(4, True)
GPIO.output(10, False)
else:
GPIO.output(10, True)
GPIO.output(4, False)
except KeyboardInterrupt:
GPIO.cleanup()
So funktioniert das Programm
GPIO.setup(7, GPIO.IN, GPIO.PUD_DOWN)
Nach der bereits bekannten Initialisierung der GPIO-Pins für die LEDs wird Pin7 als Eingang für den Taster initialisiert. Der Parameter GPIO.PUD_DOWN schaltet den internen Pull-down-Widerstand ein.
try:
while True:
13
Diese Zeilen leiten eine Endlosschleife mit Abbruchmöglichkeit ein. Die while-Schleife läuft endlos, da
die Bedingung True immer wahr ist. Die davorgeschaltete try-Anweisung lässt aber eine weiter unten
bei except angegebene Abbruchbedingung zu.
if GPIO.input(7)==True:
GPIO.output(4, True)
GPIO.output(10, False)
else:
GPIO.output(10, True)
GPIO.output(4, False)
Das Wort if (englisch für wenn) steht für eine Bedingung. Ist sie erfüllt, wird der folgende eingerückte
Programmteil ausgeführt.
== ist nicht gleich =
Das doppelte Gleichheitszeichen == steht für eine Gleichheitsabfrage, wohingegen das einfache Gleichheitszeichen = für Variablenzuweisungen verwendet wird.
Wenn der Taster an Pin7 gedrückt ist, hat dieser Pin den Wert True. Die LED an Pin 4 wird eingeschaltet,
die LED an Pin10 aus.
Hinter dem Programmteil, der ausgeführt wird, wenn die Bedingung erfüllt ist, kann ein weiterer Block
mit dem Schlüsselwort else stehen. Der darauffolgende Programmteil wird ausgeführt, wenn die Bedingung nicht erfüllt ist.
Ist der Taster an Pin7 also nicht gedrückt, wird die LED an Pin10 eingeschaltet, die LED an Pin4 aus.
except KeyboardInterrupt:
GPIO.cleanup()
Mit Drücken der Tastenkombination [Strg]+[C] auf der Tastatur wird die Abbruchbedingung ausgelöst.
Damit wird die Schleife beendet, und anschließend werden die GPIO-Pins zurückgesetzt.
14
6. Tag
6. Tag
Heute im Adventskalender
• 1 LED gelb mit eingebautem Vorwiderstand
Scratch-Katze schaltet LEDs
Die Katze auf der Scratch-Bühne, dem Teilfenster rechts oben, ist nicht
nur die Symbolfigur von Scratch, sondern ein frei programmierbares
Objekt, das verschiedenste Aktionen ausführen kann. Im Experiment des
6. Tags wird die Katze über einen Hintergrund mit drei verschiedenfarbigen Streifen – grün, gelb und rot – laufen. Je nachdem, welche Hintergrundfarbe die Katze berührt, leuchten die entsprechenden LEDs.
Bauteile: 1 Steckbrett, 1 LED rot mit eingebautem Vorwiderstand, 1 LED
gelb mit eingebautem Vorwiderstand, 1 LED grün mit Vorwiderstand, 4
GPIO-Verbindungskabel, 2 Pinleisten (3 Pins)
Das Programm
Das Programm verwendet die sogenannte Scratch-Bühne, ein grafisches
Ausgabefenster rechts oben auf dem Scratch-Bildschirm. Das verwendete
Hintergrundbild kann mit dem in Scratch mitgelieferten Malprogramm
selbst gemalt werden.
Die Scratch-Katze schaltet drei LEDs.
Das Programm 06katze01 lässt die Scratch-Katze drei LEDs steuern.
Um den Hintergrund zu verändern, klicken
Sie auf der Objektpalette rechts unten auf
dem Scratch-Bildschirm auf das weiße Symbol
Bühne.
Das Scratch-Programmfenster erscheint leer,
da keine Programmblöcke direkt für die Bühne
genutzt werden. Schalten Sie oben auf die Registerkarte Hintergründe und klicken Sie auf Bear-
beiten. Damit startet das Malprogramm, das die
wesentlichen Funktionen eines einfachen Grafikprogramms bietet.
Mithilfe des Rechtecksymbols und der Farbpalette links unten malen Sie drei farbige Balken,
grün, gelb und rot, auf den Hintergrund.
Das Malprogramm für den Hintergrund in Scratch.
Verlassen Sie anschließend das Malprogramm
mit OK, klicken Sie auf der Objektpalette unten
rechts auf die Katze, hier als Objekt1 bezeichnet, und schalten Sie wieder auf die Registerkarte Skripte,
auf der Sie das Programm zusammenbauen.
Nach dem Start werden als Erstes die drei GPIO-Pins für die LEDs als Ausgänge definiert: config4out,
config22out, config11out.
Danach wird die Katze in die Ausgangsposition am linken Rand der Bühne auf
dem grünen Balken gesetzt. Dazu verwenden wir den Block gehe zu x:... y:...
von der Blockpalette Bewegung. Damit wird die Katze an eine absolute Koordinatenposition gebracht.
Die Scratch-Bühne erstreckt sich in horizontaler x-Richtung auf die Länge zwischen den Koordinaten –240
und 240. Standardmäßig steht die Katze bei 0,0 genau in der Mitte. Da sie selbst etwa 100 Koordinateneinheiten breit ist, kommt sie an den im Block eingetragenen Koordinaten x:-150 y:0 an eine gute Aus-
gangsposition, um quer über die Bühne zu laufen.
Danach startet eine Wiederhole fortlaufend-Schleife, die eine endlose Bewegung der Katze erzeugt.
Innerhalb dieser Schleife läuft eine weitere Schleife, die genau 30 Mal wiederholt wird. Da die Katze in jedem Schritt zehn Koordinateneinheiten in x-Richtung
gehen soll, erreicht sie nach 30 Wiederholungen bei x:150 y:0 die Wendeposition am rechten Rand der Bühne.
Innerhalb der Schleife folgen drei falls...sonst-Abfragen, von denen jede prüft, ob die
Katze eine bestimmte Hintergrundfarbe berührt. Ist das der Fall, wird der Block innerhalb der oberen Klammer falls ausgeführt, wenn nicht, wird der andere Block inner-
halb der unteren Klammer sonst ausgeführt.
15
Zur Überprüfung verwenden wir den Block wird Farbe... berührt von der
Blockpalette Fühlen. Klicken Sie auf das farbige Feld im Block, erscheint der
Mauszeiger als Pipette, und Sie können die gewünschte Farbe auf der Scratch-Bühne durch Anklicken
auswählen.
Die erste falls...sonst-Abfrage prüft, ob die Katze die grüne Farbe des mittleren Balkens berührt. Ist das
der Fall, soll die grüne LED an Pin 11 eingeschaltet werden (gpio11on). Berührt die Katze den grünen Balken im Moment der Abfrage nicht, wird diese LED ausgeschaltet (gpio11off).
Nach dem gleichen Schema schaltet die zweite falls...sonst-Abfrage bei Berührung des gelben Balkens
die gelbe LED an Pin 22 ein und aus. Die dritte falls...sonst-Abfrage schaltet bei Berührung des roten
Balkens die rote LED an Pin 4 ein und aus.
Jetzt geht die Katze einen Schritt von zehn Koordinateneinheiten. Der Block
gehe...-er Schritt von der Blockpalette Bewegung bewegt ein Objekt relativ von
seiner aktuellen Position aus, im Gegensatz zum am Anfang verwendeten Block gehe zu x:... y:..., der
das Objekt an eine absolute Koordinatenposition bringt.
Damit man die Bewegung gut mitverfolgen kann, wartet das Programm nach jedem Bewegungsschritt 0,2
Sekunden, bevor die innere Schleife neu startet und die Katze den nächsten Schritt geht.
Hat die Katze nach 30 Schritten die rechte Seite der Bühne erreicht, soll sie sich
um 180 Grad drehen. Dazu verwenden wir den Block drehe... Grad von der Block-
palette Bewegung. Damit die Katze nach der Drehung nicht auf dem Kopf steht, aktivieren Sie das Doppelpfeilsymbol bei der Katze oberhalb des Skriptbereichs.
Danach startet die Endlosschleife, und die Katze läuft wieder zurück. Da nur relative
Bewegungen verwendet werden, braucht man im Skript nicht zwischen dem Gang nach
rechts und nach links zu unterscheiden.
Dieses Symbol schaltet zwischen Drehung und Links-rechtsAusrichtung um.
16
7. Tag
7. Ta g
Heute im Adventskalender
• 2 GPIO-Verbindungskabel
LEDs mit einer Smartphone-App schalten
Einige Schaltungen, die Sie mit diesem Adventskalender aufbauen, werden über eine mobile App
bedient. Hierfür wird eine mobile Webseite programmiert und vom Smartphone aus aufgerufen. Die
mobile Webseite funktioniert auf jedem Smartphone mit WLAN und einem installierten Browser, und
auch über den Browser auf dem Raspberry Pi oder Ihrem PC können Sie die programmierte Seite nutzen.
Wichtig ist, dass sich Smartphone und Raspberry Pi im gleichen Netzwerk befinden. Zusätzlich müssen
Sie folgende Dinge durchführen:
• Schritt 1: Webserver installieren
• Schritt 2: PHP5 installieren
Schritt 1: Webserver installieren
Damit die Webseite auf dem Raspberry Pi ablaufen und von Ihrem Smartphone aus aufgerufen werden
kann, müssen Sie einen Webserver installieren. Wir verwenden den Apache HTTP Server. Für die Installation öffnen Sie das LXTerminal über das Menü Zubehör.
Geben Sie im geöffneten LXTerminal-Fenster folgenden Befehl ein:
sudo apt-get install apache2
Der Webserver wird nun heruntergeladen und installiert. Über das Smartphone (oder auch über den
Browser auf dem Raspberry Pi) können Sie die Installation direkt testen. Hierfür benötigen Sie die IPAdresse des Raspberry Pi. Sie finden sie, wenn Sie mit der Maus über das Netzwerksymbol oben rechts
auf dem Desktop fahren.
Öffnen Sie den Browser in Ihrem Smartphone und geben Sie http://<IP-Adresse Raspberry PI> ein,
das Beispiel aus dem Screenshot zeigt die Adresse http://192.168.178.44.
Durch Klick auf den Menüeintrag öffnet sich die Eingabeaufforderung.
Der Raspberry-Pi-Desktop zeigt die IP-Adresse an.
Die Testseite auf dem Smartphone. Damit ist die
Webserverinstallation abgeschlossen.
Loading...