RASPBERRY PI Physical Computing · Heerdegen-Leitner & Heerdegen, 2016 Seite 6 5) Das Projekt 1 in Python Die Bibliothek RPi.GPIO muss zuerst installiert werden, um die GPIO-Ports

Heerdegen-Leitner & Heerdegen, 2016 Seite 1

RASPBERRY PI

Physical Computing

Mit dem Raspberry Pi kann man Leuchtdioden aber auch Geräte steuern. Man braucht

dazu eine geeignete Programmierumgebung. Python und Scratch sind solche geeigneten

Programmiersprachen. Scratch ist die einfachere Programmiersprache. Mit dieser

können wir Leuchtdioden z.B. zum Blinken bringen.

Wir brauchen dazu:

1) ScratchGPIO

Das ist eine kleine Erweiterung für Scratch um damit die GPIO-Pins des Raspberry Pi

zum Steuern unter Scratch verwenden zu können.

Wie können wir ScratchGPIO einrichten?

Wir öffnen das LXTerminal unseres Raspberry Pi-Desktops und tippen in die

Kommandozeile:

sudo wget http://goo.gl/Pthh62 -O isgh7.sh

Nachdem wir mit Enter bestätigt haben, wird der Installer heruntergeladen.

Danach tippen wir in die Kommandzeile:

sudo bash isgh7.sh

ScratchGPIO7 wird installiert. Auf dem RasPi-Desktop erscheinen zwei Icons mit den

Namen ScratchGPIO7 und ScratchGPIO7plus. Die Scratch-Oberfläche hat sich nicht

verändert, aber einige zusätzliche Scripts ermöglichen Scratch nun mit den GPIO-Pins

des Raspberry Pi zu kommunizieren. Beim Starten von Scratch erscheint als Erstes ein

Dialog, der meldet, dass die Remote Sensor Extensions nun aktiviert sind. Dies

quittieren wir mit OK! (ScratchGPIO7 ist die Standartversion während

ScratchGPIO7plus für kompliziertere Projekte verwendet wird.)


2) Benötigte elektronische Bauteile

.) eine Steckplatine (Breadboard) - damit ersparen wir uns das Löten; die beiden

äußeren (rot, blau) Längsreihen sind mit Kontakten miteinander verbunden. Sie werden

oft als Plus- und Minuspol zur Stromversorgung genutzt. Bei den inneren (grün) Reihen

sind jeweils 5 Kontakte miteinander verbunden.

.) Leuchtdioden - oder LEDs leuchten, wenn Strom in einer Richtung durch sie fließt.

Sie haben zwei Anschlussdrähte, einen längeren, das ist der Pluspol oder die Anode und

einen kürzeren, das ist der Minuspol oder die Kathode. LEDs haben nur einen sehr

geringen Widerstand, d.h. sie lassen beliebig viel Strom durch. Damit sie nicht sofort

durchbrennen, muss zwischen dem GPIO-Pin und dem Pluspol der LED ein Widerstand

(VORwiderstand) eingebaut werden.

.) elektrische Widerstände (220 Ohm, 20 MOhm) - sie begrenzen den Strom, der

durch eine Leitung fließt. Die Maßeinheit für den Widerstand ist Ohm. Auf ganz alten

Widerständen sieht man noch den Widerstandswert in ganz kleinen, sehr schwer

lesbaren Zahlen. Heute wird der Widerstandswert mit Farbcodes (verschiedene farbige

Ringe auf den Widerständen) angegeben.

.) Jumper-Kabel (male - male) - sie werden als Steckbrücken auf dem Steckbrett

gebraucht. Man kann sich auch mit kleinen Drahtstücken solche Steckbrücken bauen.


.) Jumper-Kabel (female - male) - mit ihnen wird die Verbindgung zwischen GPIO-Pin

des Raspberry Pi und der Steckplatine hergestellt.

3) GPIO-Schnittstelle

Der Raspberry Pi hat eine Ein- und Ausgabeeinheit, die GPIO-Schnittstelle (General

Purpose Input/Output). Es handelt sich dabei um zwei Reihen mit insgesamt 40 Pins

(beim älteren Modell B sind es nur 26 Pins). An diese Pins können wir mit Jumper-Kabeln

elektrische Schaltkreise anschließen.

Hier eine Übersicht über die 40 Pins und deren Aufgaben:

Die mit einer Zahl bezeichneten Pins (z.B. GPIO17) können sowohl als Eingang als auch

als Ausgang verwendet werden. An ihnen liegt entweder die Spannung 0 Volt oder +3,3

Volt an! Es gibt je zwei Pins mit +3,3 Volt Spannung und +5 Volt Spannung. Außerdem

gibt es acht Pins mit Masseanschluss (Ground)!

4) Projekt 1: Eine blinkende LED

Für unser erstes Beispiel verwenden wir Pin# 06 (Ground), also einen Masseanschluss

und Pin# 11 (GPIO17).


Wir bauen die abgebildete Schaltung auf unserem Steckbrett auf: eine LED, ein

Widerstand (220 Ohm), zwei Jumper-Kabeln

Wir wollen Pin# 11 (also GPIO17) als Ausgang verwenden, wir kreieren in SCRATCH

folgenden Befehlsblock und klicken ihn an:


Danach brauchen wir noch folgende Befehlsblöcke:

Klicken wir den on-Befehlsblock an, fließt Strom, die LED leuchtet, klicken wir den off-

Befehlsblock an, fließt kein Strom, die LED leuchtet nicht.

Statt "on" und "off" können wir auch "high" (Strom fließt) und "low" (Strom fließt nicht)

schreiben. Statt "gpio17" können wir auch "pin11" verwenden.

Wir können aber auch "1" (Strom fließt) oder "0" (Strom fließt nicht) verwenden. Dann

müssen wir aber in Scratch mit dem Operator "verbinde" arbeiten.

Mit folgendem kleinen Script können wir unsere LED bereits blinken lassen:


5) Das Projekt 1 in Python

Die Bibliothek RPi.GPIO muss zuerst installiert werden, um die GPIO-Ports des

Raspberry Pi nutzen zu können.

Wir gehen dazu in das LXTerminal und geben folgende Befehle ein:

sudo apt-get update

sudo apt-get install python-dev

sudp apt-get install python-rpi.gpio

Die notwendigen und vor allem aktuellen Module werden installiert.

Nur mit Administratoren-Rechten können wir auf die GPIO-Schnittstelle zugreifen. Im

LXTerminal geben wir folgenden Befehl ein:

sudo idle3

Wir importieren das Modul RPI.GPIO mit dem Befehl

from RPi import GPIO

Mit setmode() geben wir an, mit welcher Art von Pin-Nummerierung wir arbeiten.

GPIO.setmode(GPIO.BOARD)

Nun können wir mit den Pin-Nummern arbeiten, die bei der etwas weiter oben stehenden

Übersicht mit Pin# bezeichnet sind.

Wir machen Pin#11 zum Ausgabekanal!

GPIO.setup(11, GPIO.OUT)

Mit dem Befehl

GPIO.output(11, True)

oder

GPIO.output(11, 1)

leuchtet die LED! Der Wahrheitswert "True" bedeutet, dass am Pin 11 ein

Spannungspegel von 3,3 Volt anliegt. Es fließt also Strom. (1 = Strom fließt)


Mit dem Befehl

GPIO.output(11, False)

oder

GPIO.output(11, 0)

wird die LED ausgeschaltet! Der Wahrheitswert "False" bedeutet, dass am Pin 11 ein

Spannungspegel von 0 Volt anliegt. Es fließt also kein Strom. (0 = Strom fließt nicht)

Das fertige Programm wird folgendermaßen erstellt:

.) Wir öffnen das LXTerminal und geben ein

nano LED1.py

.) Der Texteditor öffnet sich und wir tippen das Programm ein!


import time



while True:


time.sleep(0.5)


time.sleep(0.5)

while True: leitet eine Endlosschleife ein. Der eingerückte Block wird ewig

wiederholt, weil die Bedingung der while-Anweisung immer wahr (True) ist. Das

Programm wird mit der Tastenkombination Strg+C abgebrochen (Keyboard-

Interrupt)!

.) Mit der Tastenkombination STRG+X und anschließendem Bestätigen mit ENTER

speichern wir die Datei ab!

.) Aufrufen können wir die Datei im LXTerminal mit dem Befehl

sudo python LED1.py

.) Oder wir rufen im LXTerminal den Befehl


sudo idle3

auf und wählen in der Python Shell File - Open und öffne die Datei LED1.py.

Anschließend wählen wir Run - Run Module und das Programm wird ausgeführt

6) Projekt 2: Zwei blinkende LEDs

Zwei LEDs sollen nach einem bestimmten Muster blinken. Zuerst sind beide LEDs

ausgeschaltet. Jetzt soll die erste LED leuchten, dann sind beide wieder ausgeschaltet.

Dann soll die zweite LED leuchten. Wieder sind danach beide LEDs ausgeschaltet. Zum

Schluss sollen alle beiden LEDs blinken. Danach beginnt das Blinkmuster wieder von

vorne. Mit dem Wiederhole-Befehl können wir entscheiden, wie oft das Blinkmuster

aufgerufen werden soll. Für dieses Beispiel verwenden wir Pin# 01 (3,3 V), Pin#10

(GPIO15) und Pin#12 (GPIO18).

Wir bauen die abgebildete Schaltung auf unserem Steckbrett auf: zwei LEDs, zwei

Steckbrücken, zwei Widerstände (220 Ohm), drei Jumperkabeln (female - male)

Pin#10 und Pin#12 sollen als Ausgang verwendet werden. Wir programmieren in

Scratch:

An Pin#01 ist immer ein Spannungspegel von 3,3 Volt vorhanden.


Wenn wir nun programmieren

dann ist auch an Pin#10 ein Spannungspegel von 3,3 Volt vorhanden. Beide Pins (Pin#01

und Pin#10) haben das gleiche elektrische Potenzial, zwischen ihnen gibt es keine

Spannung und es fließt deshalb kein Strom. Die LED leuchtet nicht.

Wenn wir aber programmieren

dann ist an Pin#10 eine Spannung von 0 Volt. Damit wird dieser Pin gegenüber Pin#01

zum Minuspol, weil an Pin#1 immer noch 3,3 Volt anliegen. Es fließt also Strom, die LED

leuchtet.

Somit programmieren wir der Reihe nach:

Beide LEDs leuchten nicht!

LED 1 leuchtet eine halbe Sekunde, danach erlischt sie! Es wird eine halbe Sekunde

gewartet.

LED 2 leuchtet eine halbe Sekunde, danach erlischt sie! Wieder wird eine halbe

Sekunde gewartet.


Beide LEDs werden eingeschaltet. Sie leuchten eine halbe Sekunde.

Beide LEDs werden wieder ausgeschaltet.

Das ganze wiederholen wir 10 mal.

Das ganze Script sieht folgendermaßen aus:



Die Module GPIO und time werden imortiert:


import time

Es wird die Pin-Nummerierung BOARD eingestellt


Wir definieren PIN#10 und Pin#12 als Ausgang!



PIN#10 und Pin#12 werden in den Zustand True versetzt. An beiden Pins liegt nun eine

Spanung von 3,3 Volt. Es fließt kein Strom durch die LEDs. Beide LEDs leuchten nicht.



Das Programm wartet eine halbe Sekunde

time.sleep(0.5)

Pin#12 wird zuerst in den Zustand False versetzt, es fließt Strom, die LED leuchtet.

Nach einer halben Sekunde wird Pin#12 in den Zustand True versetzt, es fließt kein

Strom, die LED leuchtet nicht.


time.sleep(0.5)


time.sleep(0.5)

Das selbe machen wir mit Pin#10:


time.sleep(0.5)



time.sleep(0.5)

Nun werden beide LEDs eingeschaltet, PIN#10 und Pin#12 werden in den Zustand False

versetzt! Strom fließt. Nach einer halben Sekunde werden sie wieder in den Zustand

True versetzt, es fließt kein Strom, LED 1 und LED 2 sind ausgeschaltet.



time.sleep(0.5)



Das fertige Programm wird folgendermaßen erstellt:

.)Wir öffnen das LXTerminal und geben ein

nano LED2.py



import time




while True:



time.sleep(0.5)


time.sleep(0.5)


time.sleep(0.5)


time.sleep(0.5)


time.sleep(0.5)




time.sleep(0.5)




Interrupt)!




sudo python LED2.py


sudo idle3

auf und wählen in der Python Shell File - Open und öffne die Datei LED2.py.

Anschließend wählen wir Run - Run Module und das Programm wird ausgeführt.

8) Projekt 3: Einfache Verkehrsampel

Es soll eine Verkehrsampel mit ihrem typischen Leuchtzyklus - Grün über Gelb nach Rot

und dann von einer Leuchtkombination Rot-Gelb wieder auf Grün - aufgebaut und

programmiert werden.

Wir wollen Pin#06 als Masseanschluss und die Pins #7 (also GPIO04), #12 (also

GPIO18) und #18 (also GPIO24) als Ausgänge verwenden. Wir konfigurieren die Namen

der Pins in Scratch also folgendermaßen:

Wir bauen die abgebildete Schaltung auf unserem Steckbrett auf: drei LEDs (rot, gelb,

grün), drei Widerstände (220 Ohm), vier Jumperkabeln (female - male)


Das fertige Programm sieht dann folgendermaßen aus: Der Leuchtzyklus soll dreimal

wiederholt werden! Der zweite Wiederhole-Block lässt die grüne LED 5 mal blinken ehe

die gelbe eingeschaltet wird.


Wir können aber auch die Nummern der Pins (#7, #12 und #18) konfigurieren

und unsere Verkehrsampel so programmieren:



.)Wir öffnen das LXTerminal und geben ein

nano Verkehrsampel1.py



import time





while True:

GPIO.output (7, True)

time.sleep (4)


time.sleep (2)

GPIO.output (7, False)



time.sleep (4)


time.sleep (0.3)


time.sleep (0.3)


time.sleep (0.3)


time.sleep (0.3)


time.sleep (0.3)


time.sleep (0.3)



time.sleep (2)






Interrupt)!




sudo python Verkehrsampel1.py


sudo idle3

auf und wählen in der Python Shell File - Open und öffne die Datei Verkehrsampel.py.

Anschließend wählen wir Run - Run Module und das Programm wird ausgeführt.

10) Projekt 4: Einen Schalter verwenden

Ein GPIO-Pin kann auch als Eingang benutzt werden, der einem Computerprogramm 0

oder 1 schickt. Das hängt davon ab, welches Signal am Eingang liegt. Man unterschiedet

hier zwischen Low (niedrig) und High (hoch). Dabei bedeutet Low, dass der Eingang mit

der Masse verbunden ist (Wert 0) und High, dass am Eingang eine positive Spannung

anliegt (Wert 1).

ScratchGPIO nutzt interne Pullup-Widerstände im Raspberry Pi, sodass GPIO-Eingänge,

an denen ein nicht gedrückter Schalter angeschlossen ist, immer den Wert 1 haben.

Verbindet man einen solchen GPIO-Eingang über einen Schalter mit Ground, indem man

den Schalter drückt, nimmt er den Wert 0 an. Ein gedrückter Schalter schaltet in

ScratchGPIO einen Eingang also nicht ein sondern aus.

Mit Hilfe eines Schalters soll eine LED ein- und wieder ausgeschaltet werden.

Wir bauen die abgebildete Schaltung auf unserem Steckbrett auf: eine LED, ein

Widerstand (220 Ohm), drei Jumperkabeln (female - male), ein Schalter


Wir konfigurieren Pin#26 als Eingang und Pin#11 als Ausgang. (Das rote Kabel kommt an

Pin#26, das grüne Kabel an Pin#11, das blaue Kabel an Pin#6.)

Unser Programm in Scratch sieht dann so aus:

Wird der Schalter gedrückt, nimmt der GPIO-Eingang an Pin#26 den Wert 0 an! In

diesem Fall leuchtet die LED, die am Pin#11 angeschlossen ist 0.5 Sekunden. Danach

wird sie wieder ausgeschaltet. Durch Anklicken des roten Stopp-Schildes in der

Programmierumgebung Scratch (rechts oben) kann das Programm abgebrochen werden.

11) Projekt 5: Fußgängerampel und Verkehrsampel

In diesem Projekt wird eine einfache Verkehrsampel mit einer Fußgängerampel

kombiniert. Die Ampelschaltung soll während der Rotphase der Verkehrsampel eine


Grünphase für die Fußgänger anzeigen. Mit einem Schalter soll die Ampel in Betrieb

gesetzt werden.

Wir bauen die abgebildete Schaltung auf unserem Steckbrett auf: zwei Steckbretter,

zwei LEDs (rot), zwei LEDs (grün), eine LED (gelb), ein Schalter, fünf Widerstände

(220 Ohm), sieben Jumperkabeln (female - male), zwei Steckbrücken

Das eine Steckbrett enthält die Verkehrsampel für die Autofahrer, das andere die

Fußgängerampel mit dem Schalter. Beide Steckbretter brauchen für die LEDs eine

Masseleitung. Deshalb brauchen wir die lange Steckbrücke!

Auf dem Raspberry Pi werden folgende Pins für die LEDs, den Schalter und die Masse

verwendet:

pin#16 - Verkehrsampel/grün

pin#13 - Verkehrsampel/gelb

pin#12 - Verkehrsampel/rot

pin#15 - Fußgängerampel/rot

pin#18 - Fußgängerampel/grün

pin#26 - Schalter

pin#6 - Masse


Das fertige Script sieht dann folgendermaßen aus:

Am Beginn zeigt die Verkehrsampel grün (Pin#16) für die Autofahrer und die

Fußgängerampel zeigt rot (Pin#15). Wird der Schalter gedrückt, nimmt der GPIO-

Eingang an Pin#26 den Wert 0 an! In diesem Fall blinkt die grüne LED der

Verkehrsampel dreimal. Danach wird sie ausgeschaltet und die gelbe Verkehrsampel

(Pin#13) leuchtet eine Sekunde. Dann zeigt die Verkehrsampel rot (Pin#12), das rote

Licht der Fußgängerampel erlischt, das grüne Licht der Verkehrsampel (Pin#18) wird für

drei Sekunden eingeschaltet. Dann wieder rot der Fußgängerampel. Nach zwei Sekunden

gelb der Verkehrsampel beginnt das Programm wieder von vorne. Durch Anklicken des

roten Stopp-Schildes wird das Programm abgebrochen.

Documents

RASPBERRY PI Physical Computing · Heerdegen-Leitner & Heerdegen, 2016 Seite 6 5) Das Projekt 1 in Python Die Bibliothek RPi.GPIO muss zuerst installiert werden, um die GPIO-Ports