Raspberry Pi (Raspi) - bol.libol.li/raspi/Skript Raspi.pdf · Beim ersten Booten meldet sich das...

Raspberry Pi ("Raspi")

(Das Inhaltsverzeichnis befindet sich am Ende des Dokuments.)

1 Erste Schritte

1.1 Raspi in Betrieb nehmen

Der Raspberry Pi 2 Model B und seine Anschlüsse:

Unsere Konfiguration:- Raspberry Pi 2 Model B - Quadcore, 1GB RAM- 8GB MicroSD Karte mit Adapter, NOOBS (OS für Raspberry Pi) bereits installiert- Steckernetzteil MicroUSB 5V/2A- VGA-Bildschrim mit HDMI to VGA Adapter- USB-Tastatur- USB-Maus- Netzwerkanschluss

Ausserdem:- Flachbandkabel und Cobbler zum hinausführen der 40 GPIO-Pins (GPIO = General Purpose Input/Output)- Full Size Breadboard (Steckplatine für externe Bauteile)

Skript Raspi.odt bma/01.07.2016 Seite 1

Beim ersten Booten meldet sich das Raspberry Pi Software Configuraton Tool:

Hier sollte man das Tastaturlayout ändern (Navigieren kann man mit den Pfeil- und Tab-Tasten sowie mit Enter und Esc):

4 (Internationalisation Options) -> I3 (Change Keyboard Layout) -> Generic 105-key (Intl) PC (so belassen!) -> Other (languages) -> German (Switzerland)Das Raspi-Konfigurationstool kann übrigens jederzeit von der Konsole aus mit sudo raspi-config gestartet werden.

Nach dem Beenden dieses Tools ist man automatisch als Benutzer pi angemeldet. Das Passwort für den Benutzer pi lautet raspberry.

Achtung: Die Änderungen der Einstellungen werden erst beim nächsten Neustart wirksam.

Mit dem Befehl startx wird die grafische Benutzeroberfläche gestartet.


1.2 Programmieren mit Python

Python ist eine leicht zu erlernende Programmiersprache mit vielen Möglichkeiten. Auf dem Raspi sind Python 2 und Python 3 installiert. Wir verwenden Python 2.

Vorher sollten wir aber noch einen Ordner für unsere Programm erstellen, z.B. in einer Console (Console oder Shell oder Terminal bedeutet alles dasselbe):

Python 2 (Python Shell) lässt sich über das Menu (Menu -> Programming -> Python 2) starten. In der Python Shell bekommt man mit dem Menu File -> New Window ein neues Editorfenster, in welches man ein Python-Programm eingeben kann, z.B. dieses einfache Zahlenratespiel:

Hier nochmals der Quellcode (spiel1.py):

import randomzahl = random.randrange(1000); tipp = 0; i = 0while tipp != zahl: tipp = input("Dein Tipp:") if zahl < tipp: print "Die gesuchte Zahl ist kleiner als ",tipp if zahl > tipp: print "Die gesuchte Zahl ist größer als ",tipp i += 1print "Du hast die Zahl beim ",i,". Tipp erraten"


Hinweis: In Python werden Anweisungsblöcke nicht durch geschweifte Klammern gebildet, sondern durch Einrückung. Beispielsweise gehören alle Anweisungen zu einer while-Schleife, welche weiter eingerückt sind als das Wort while.

Wir speichern das Programm im neuen Ordner python unter dem Namen spiel1.py und starten es mit F5 (C# lässt grüssen :-).


1.3 GPIO, Breadboard und externe Bauteile

Die 40 GPIO-Pins des Raspi werden über ein Flachbandkabel und den "Cobbler" (Verbindungsstecker) eins zu eins auf das Breadboard (Steckplatine) herausgeführt.

Cobbler: Pin-Belegung:

Breadboard mit Verdrahtungen (dünne Linien):

Externe Bauteile:Aktoren: LEDs, Laustprecher, Display,...Sensoren: Taster, Regler, Temperaturfühler, Infrarotsensor,...Integrierte Schaltungen: Analog-Digital-Wandler,...Hilfsmittel: Kabel, Widerstände,...


1.4 Erste Schaltungen ohne Python-Programmierung

Achtung: Wir machen jetzt Hardware. Ein grosser Unterschied zu Software besteht darin, dass man beiHardware eine Menge kaputt machen kann, wenn man nicht aufpasst. Also:

- Kein "Try and Error" wie beim Programmieren, sondern jede Schaltung anhand des Plans und mit Menschenverstand überprüfen, bevor man Sie in Betrieb nimmt.

- Ein Kurzschluss ist eine direkte Verbindung zwischen unterschiedlichen Spannungsniveaus, z.B. Ground (=0V) mit 5V. Ein Kurzschluss kann den Raspi zerstören!

Zuerst wollen wir zwei einfache Schaltungen aufbauen, welche nur die Stromversorgung des Raspi verwenden. Es ist also noch keine Programmierung nötig.

Projekt "LED immer an"

Zweck: LED (Leuchtdiode, Light Emitting Diode), die immer leuchtet

Benötigte Bauteile:- LED- 220 Ohm Widerstand (rot-rot-braun)

Aufbau:

Python-Programm:- (keines)

Bemerkungen:- Es kommt drauf an, in welche Richtung die LED eingebaut wird, also: Wenn nichts geht -> umdrehen!- LEDs brauchen immer einen sogenannten Vorwiderstand. Wenn dieser fehlt, geht die LED kaputt!


Projekt "LED mit Taster"

Zweck: LED, die leuchtet, wenn ein Drucktaster gedrückt ist

Benötigte Bauteile:- Drucktaster- LED- 220 Ohm Widerstand (rot-rot-braun)

Aufbau:

Python-Programm:- (keines)

Bemerkungen:- Anschlüsse und Schaltplan des Durcktasters:


1.5 Erste Schaltungen mit Python Programmierung

Nun soll die LED mit einem Python-Programm vom Raspi aus gesteuert werden. Um auf die GPIO-Ports zugreifen zu können, benötigt man root-Rechte. Starten Sie also für alle zukünftigen Projekte die Python-Umgebung nicht über das Menu, sondern von einer Konsole aus mit

sudo idle

Projekt "LED Blinker"

Zweck: LED, die blinkt, bis das Programm mit Ctrl+C gestoppt wird.

Lösungsprinzip: Die LED wird in einer while-Schleife über den GPIO-Pin 25 ein- und ausgeschaltet. Der Pin 25 muss dazu als Output-Pin definiert werden.


Aufbau:

Python-Programm (led_blink.py):

# Libraries importieren:import RPi.GPIO as GPIOimport time

# Standardbezeichnung für GPIO-Ports definieren:GPIO.setmode(GPIO.BCM)

# GPIO Pin 25 als Ausgangssignal festlegen:GPIO.setup(25, GPIO.OUT)

print ("Ctrl+C beendet das Programm")try: # Endlos-Schleife: while True: # LED einschalten GPIO.output(25, 1)


# 1 s warten time.sleep(1) # LED ausschalten GPIO.output(25, 0) # 1 s warten: time.sleep(1)# Falls das Programm mit Ctrl+C gestoppt wird:except KeyboardInterrupt: # GPIO zurücksetzen GPIO.cleanup()

Als nächstes wollen wir zusätzlich den Zustand des Drucktasters über den GPIO-Port vom Programm aus abfragen.

Achtung: Der Drucktaster darf niemals direkt mit dem GPIO-Port verbunden werden! Der Raspi könnte sonst durch allzu hohe Ströme zerstört werden. Das folgende Schema zeigt den korrekten Anschluss:

Der 1 kOhm Widerstand zwischen Taster und GPIO-Port schützt den Port vor zu hohen Strömen (Schutzwiderstand). Der 10 kOhm Widerstand zwischen Taster und Ground (0 V) sorgt dafür, dass der Taster im geöffneten Zustand immer den korrekten Wert 0 an den Port liefert (Pulldown-Widerstand).

Projekt "LED mit Ein-/Aus-Schalter"

Zweck: LED, die durch kurzes Drücken des Tasters eingeschaltet wird, durch nochmaliges Drücken wieder ausgeschaltet usw.

Lösungsprinzip: Der Pin 25 (Output) steuert die LED, der Pin 4 wird als Input konfiguriert und liest den Zustand des Drucktasters. Das Programm merkt sich in einer globalen Variablen, ob die LED im Momentleuchtet oder nicht.

Benötigte Bauteile:- Drucktaster- LED- 220 Ohm Widerstand (rot-rot-braun)- 1 kOhm Widerstand (braun-schwarz-rot)- 10 kOhm Widerstand (braun-schwarz-orange)


Aufbau:

Python-Programm (led_taster_toggle.py):

import RPi.GPIO as GPIOimport time

GPIO.setmode(GPIO.BCM)

# Pin 25 als Ausgangssignal mit Startwert False (= 0) initialisieren:GPIO.setup(25, GPIO.OUT, initial=False)# Pin 4 als Eingangssignal festlegen:GPIO.setup(4, GPIO.IN)

# Globale VariableninOld = False; # letzter Zustand des TastersledOn = False; # LED ein oder aus

print ("Ctrl+C beendet das Programm")try: while True: # Ausgabe des Tasterzustands (Debug) print GPIO.input(4) # Wenn der Taster gedrückt ist und vorher nicht gedrückt war: if GPIO.input(4)==True and inOld == False: # dann wird die LED ein- bzw. ausgeschaltet: ledOn = not ledOn # aktuellen Zustand des Tasters merken: inOld = GPIO.input(4); # LED ansteuern: GPIO.output(25,ledOn) # kurze Zeit warten: time.sleep(0.05)except KeyboardInterrupt: GPIO.cleanup()


2 Ausgabebausteine (Aktoren)

2.1 Mehr mir LEDs

Projekt "LED Dimmer"

Zweck: Die LED soll durch Drücken des Tasters heller bzw. dunkler werden.

Lösungsprinzip: Wir können vom Raspi aus eine LED nur ein- oder ausschalten, es gibt keine Zwischenstufen. Der Trick besteht darin, die LED so schnell blinken zu lassen, dass das menschliche Auge das nicht mehr als Blinken wahrnimmt. Der Zeitanteil in einem Blinkzyklus, während dem die LED leuchtet, bestimmt die Helligkeit. Dieses Verfahren heisst Pulsweitenmodulation.

50% Helligkeit: 20% Helligkeit:

Benötigte Bauteile: wie oben ("LED mit Ein-/Aus-Schalter")- Drucktaster- LED- 220 Ohm Widerstand (rot-rot-braun)- 1 kOhm Widerstand (braun-schwarz-rot)- 10 kOhm Widerstand (braun-schwarz-orange)

Aufbau: wie oben ("LED mit Ein-/Aus-Schalter")


Python-Programm (led_taster_dim.py):


GPIO.setmode(GPIO.BCM)GPIO.setup(25, GPIO.OUT, initial=False)GPIO.setup(4, GPIO.IN)

ledOn = 50; # Anteil von 100, wo die LED leuchtetdimUp = 1; # 1: Taster macht heller, -1: Taster macht dunkler

print ("Ctrl+C beendet das Programm")try: while True: # Wenn Taster gedrückt: if GPIO.input(4)==True: # Helligkeit verändern (Leuchtanteil +1 oder -1) ledOn = ledOn + dimUp # Wenn ganz hell: if ledOn >= 100: # Dimm-Richtung umkehren dimUp = -1; # Wenn ganz dunkel: if ledOn <= 0: # Dimm-Richtung umkehren dimUp = 1 # LED einschalten GPIO.output(25,True) # Ein Blinkzyklus dauert 100*0.0001 s, also 1/100 s) # Leucht-Zeitanteil warten time.sleep(ledOn*0.0001) # LED ausschalten GPIO.output(25,False) # Rest des Blinkzyklus warten time.sleep((100-ledOn)*0.0001)except KeyboardInterrupt: GPIO.cleanup()


Aufgabe "LED Wechselschalter"

Zweck: Zwei LEDs sollen abwechslungsweise leuchten. Umschaltung soll durch Drücken des Tasters erfolgen.

Lösungsprinzip: Zwei parallel geschaltete LEDs, welche separat z.B. über die Output-Pins 25 und 12 gesteuert werden. Der Taster liegt am Input-Pin 4.

Benötigte Bauteile:- Drucktaster- 1 kOhm Widerstand (braun-schwarz-rot)- 10 kOhm Widerstand (braun-schwarz-orange)- 2 Stück LED- 2 Stück 220 Ohm Widerstand (rot-rot-braun)

Aufbau:

Aufgabe "Füssgängerampel"

Zweck: 3 LED (rot, gelb, grün). Zu Beginn soll nur die rote leuchten. Beim Drücken auf den Taster sollen nacheinander die Farben gelb (1 s), grün (2 s), gelb (1 s) und dann wieder rot leuchten.

Aufgabe "Binärzähler"

Zweck: Vier (oder mehr) LEDs, welche im Sekundentakt binär zählen:0000 -> 0001 -> 0010 -> ... -> 1101 -> 1110 -> 1111 -> 0000 -> ...

Lösungsprinzip: Vier parallel geschaltete LEDS (z.B. Pins 25, 12, 16, 21). In einer Schleife fortlaufend von 0 bis 15 zählen. Die einzelnen Bits aus der aktuellen Zahl extrahieren (z.B. mit Division (/) und modulo (%)) und die LEDs entsprechend steuern.


Lösung Aufgabe "LED Wechselschalter"

Zweck: Zwei LEDs sollen abwechslungsweise leuchten. Umschalten soll durch Drücken des Tasters erfolgen.

Lösungsprinzip: Zwei parallel geschaltete LEDs, welche separat z.B. über die Output-Pins 25 und 12 gesteuert werden. Der Taster liegt am Input-Pin 4.

Benötigte Bauteile:- Drucktaster- 1 kOhm Widerstand (braun-schwarz-rot)- 10 kOhm Widerstand (braun-schwarz-orange)- 2 Stück LED- 2 Stück 220 Ohm Widerstand (rot-rot-braun)

Aufbau:

Python-Programm (led_wechselschalter.py):

import RPi.GPIO as GPIOimport timeGPIO.setmode(GPIO.BCM)GPIO.setup(25, GPIO.OUT, initial=False)GPIO.setup(12, GPIO.OUT, initial=False)GPIO.setup(4, GPIO.IN)inOld = False;ledOn = False;print ("Strg+C beendet das Programm")try: while True: print GPIO.input(4) if GPIO.input(4)==True and inOld == False: ledOn = not ledOn inOld = GPIO.input(4); GPIO.output(25,ledOn) GPIO.output(12,not ledOn) time.sleep(0.05)except KeyboardInterrupt: GPIO.cleanup()


Lösung Aufgabe "Füssgängerampel"

Zweck: 3 LED (rot, gelb, grün). Zu Beginn soll nur die rote leuchten. Beim Drücken auf den Taster sollen nacheinander die Farben gelb (1 s), grün (2 s), gelb (1 s) und dann wieder rot leuchten.

Lösungsprinzip: Drei parallel geschaltete LEDS an den Output-Pins z.B. 25, 12 und 16; Taster z.B. am Input-Pin 4.

Benötigte Bauteile:- Drucktaster- 1 kOhm Widerstand (braun-schwarz-rot)- 10 kOhm Widerstand (braun-schwarz-orange)- 3 Stück LED (rot , gelb, grün)- 3 Stück 220 Ohm Widerstand (rot-rot-braun)

Aufbau:

Python-Programm (led_fussgaengerampel.py):

import RPi.GPIO as GPIOimport timeGPIO.setmode(GPIO.BCM)GPIO.setup(25, GPIO.OUT, initial=False) # rotGPIO.setup(12, GPIO.OUT, initial=False) # gelbGPIO.setup(16, GPIO.OUT, initial=False) # grünGPIO.setup(4, GPIO.IN)inOld = False;print ("Strg+C beendet das Programm")try: while True: # rot einschalten: GPIO.output(25,True) # Falls Taster gedrückt (steigende Flanke): if GPIO.input(4)==True and inOld == False: # gelb vor grün Phase: GPIO.output(25, False) GPIO.output(12, True) time.sleep(1) # grün Phase: GPIO.output(12, False) GPIO.output(16, True) time.sleep(2) # gelb vor rot Phase: GPIO.output(16, False)


GPIO.output(12, True) time.sleep(1) # rot: GPIO.output(12, False) GPIO.output(25,True) # Tasterzustand merken inOld = GPIO.input(4) # kurz warten (rot Phase): time.sleep(0.01)except KeyboardInterrupt: GPIO.cleanup()


Lösung Aufgabe "Binärzähler"

Zweck: Vier (oder mehr) LEDs, welche im Sekundentakt binär zählen:0000 -> 0001 -> 0010 -> ... -> 1101 -> 1110 -> 1111 -> 0000 -> ...

Lösungsprinzip: Vier parallel geschaltete LEDS (z.B. Pins 25, 12, 16, 21). In einer Schleife fortlaufend von 0 bis 15 zählen. Die einzelnen Bits aus der aktuellen Zahl extrahieren (z.B. mit Division (/) und modulo (%)) und die LEDs entsprechend steuern.

Benötigte Bauteile:- 4 Stück LED- 4 Stück 220 Ohm Widerstand (rot-rot-braun)

Aufbau (Taster ist auch drauf, wird aber hier nicht gebraucht)

Python-Programm (led_binaerzaehler.py):

import RPi.GPIO as GPIOimport timeGPIO.setmode(GPIO.BCM)GPIO.setup(25, GPIO.OUT, initial=False) # bit 3GPIO.setup(12, GPIO.OUT, initial=False) # bit 2GPIO.setup(16, GPIO.OUT, initial=False) # bit 1GPIO.setup(21, GPIO.OUT, initial=False) # bit 0GPIO.setup(4, GPIO.IN)a = 0;print ("Strg+C beendet das Programm")try: while True: bit0 = a%2 bit1 = (a/2)%2 bit2 = (a/4)%2 bit3 = (a/8)%2 GPIO.output(25, bit3) GPIO.output(12, bit2) GPIO.output(16, bit1) GPIO.output(21, bit0) time.sleep(1) a = (a+1) % 16except KeyboardInterrupt: GPIO.cleanup()


2.2 7-Segment-Anzeige

Wir verwenden die 4-stellige 7-Segment-Anzeige KW4-56NCLB-P von Adafruit (Common Cathode).

Bezeichnung der Stellen und Segmente:

Anschlüsse:

Die Pins DIG.1, DIG.2, DIG.3 und DIG.4 dienen der Steuerung der vier Stellen der Anzeige, die Pins A, B, C, D, E, F, G und DP sind für die sieben Segmente und den Dezimalpunkt.Die beiden Pins ganz rechts oben und unten sind für den Doppelpunkt zwischen der 2. und der 3. Stelle. Wir werden sie nicht verwenden.

Schaltschema:

Vollständiges Datenblatt: https://www.adafruit.com/datasheets/865datasheet.pdf


Um ein Segment an einer bestimmten Stelle zum Leuchten zu bringen, muss muss das entsprechende Segment auf True (+3.3V) und die entsprechende Stelle (DIG.x) auf False (0V) geschaltet werden:

Segment (A,...G, DP):Stelle (DIG.x):

False (0V) True (3.3V)

False (0V) dunkel hell

True (3.3V) dunkel dunkel

Ausserdem müssen die Segment-Pins immer über einen 220 Ohm Widerstand angeschlossen werden.

Projekt "7-Segment manuell"

Zweck: Das Segment C der letzten Stelle (DIG.4) soll durch manuelle Steckverbindung zum Leuchten gebracht werden.

Lösungsprinzip: Der Pin C wird über einen Widerstand mit 3.3V verbunden, der Pin DIG.4 direkt mit GND.

Benötigte Bauteile:- 7-Segment Anzeige- 220 Ohm Widerstand (rot-rot-braun)

Aufbau:

Python-Programm: keines


Soll das gleiche Segment an mehreren Stellen angezeigt werden, genügt es, die entsprechenden DIG-Pins der Anzeige mit GND zu verbinden.

Um bei einer Stelle mehrere Segmente zum Leuchten zu bringen, müssen die entsprechenden Segment-Pins der Anzeige mit 3.3V verbunden werden (je über einen eigenen 220 Ohm-Widerstand).

Aufgabe "Muster manuell"

Erzeugen Sie die folgenden Muster durch manuelle Steckverbindungen

a) b)

c) d)

e) f)

Lösung Aufgabe "Muster manuell"

- (keine)


Projekt "7-Segment programmgesteuert"

Zweck: Das Segment C der letzten Stelle (DIG.4) soll durch ein Python-Programm zum Blinken gebrachtwerden.

Die Schaltung soll so aufgebaut werden, dass auch andere Anzeigemuster erzeugt werden können. Auf diese Weise können wir dieselbe Schaltung für alle weiteren Projekte und Aufgaben verwenden.

Lösungsprinzip: Jeder Pin der 7-Segment-Anzeige wird gemäss folgenden Tabellen mit einer GPIO-Steuerleitung verbunden:

Segmente (Verbindung über einen 220 Ohm Widerstand):

Segment A B C D E F G

GPIO-Pin 4 5 6 12 13 16 17

Drahtfarbe hellbraun blau violett grün schwarz braun grau

Stellen (Verbindung direkt):

Stelle DIG.1 DIG.2 DIG.3 DIG.4

GPIO-Pin 22 23 24 25

Drahtfarbe orange gelb rot pink

Benötigte Bauteile:- 7-Segment Anzeige- 7 Stück 220 Ohm Widerstände (rot-rot-braun)

Aufbau:


Python-Programm (7seg_segc_dig4_blink.py):

import RPi.GPIO as GPIOimport timeGPIO.setmode(GPIO.BCM)

# Alle Segment-Pins auf Output stellen; Startwert False = ausgeschaltet:GPIO.setup(4, GPIO.OUT, initial = False); # Segment AGPIO.setup(5, GPIO.OUT, initial = False); # Segment BGPIO.setup(6, GPIO.OUT, initial = False); # Segment CGPIO.setup(12, GPIO.OUT, initial = False); # Segment DGPIO.setup(13, GPIO.OUT, initial = False); # Segment EGPIO.setup(16, GPIO.OUT, initial = False); # Segment FGPIO.setup(17, GPIO.OUT, initial = False); # Segment G

# Alle Stellen-Pins auf Output stellen; Startwert True = ausgeschaltet(!):GPIO.setup(22, GPIO.OUT, initial = True); # DIG.1GPIO.setup(23, GPIO.OUT, initial = True); # DIG.2GPIO.setup(24, GPIO.OUT, initial = True); # DIG.3GPIO.setup(25, GPIO.OUT, initial = True); # DIG.4

print ("Strg+C beendet das Programm")try: while True: # Segment C von DIG.4 einschalten: GPIO.output(6,True) GPIO.output(25,False) time.sleep(1) # ... und ausschalten # (eine der beiden Anweisungen würde auch genügen): GPIO.output(6,False) GPIO.output(25,True) time.sleep(1) except KeyboardInterrupt: GPIO.cleanup()

Aufgabe "Muster programmgesteuert"

Schreiben Sie ein Python-Programm, welches die gleichen Muster wie vorhin der Reihe nach anzeigt (je 1 Sekunde).

Hinweis: Der Schaltungsaufbau muss dazu nicht verändert werden.

Aufgabe "Rundlauf"

Schreiben Sie ein Python-Programm, welches bei allen vier Stellen nacheinander die Segmente A, B, C,D, E, F einzeln aufleuchten lässt. Variieren Sie die Geschwindigkeit des "Rundlaufs".

Hinweis: Der Schaltungsaufbau muss dazu nicht verändert werden.


Lösung der Aufgabe "Muster programmgesteuert" (7seg_muster.py)


# Alle Segment-Pins auf Output stellen:GPIO.setup(4, GPIO.OUT, initial = False); # Segment AGPIO.setup(5, GPIO.OUT, initial = False); # Segment BGPIO.setup(6, GPIO.OUT, initial = False); # Segment CGPIO.setup(12, GPIO.OUT, initial = False); # Segment DGPIO.setup(13, GPIO.OUT, initial = False); # Segment EGPIO.setup(16, GPIO.OUT, initial = False); # Segment FGPIO.setup(17, GPIO.OUT, initial = False); # Segment G

# Alle Stellen-Pins auf Output stellen:GPIO.setup(22, GPIO.OUT, initial = True); # DIG.1GPIO.setup(23, GPIO.OUT, initial = True); # DIG.2GPIO.setup(24, GPIO.OUT, initial = True); # DIG.3GPIO.setup(25, GPIO.OUT, initial = True); # DIG.4

# Funktion, die alle Lichter aus macht:def allesAus(): GPIO.output(4,False) GPIO.output(5,False) GPIO.output(6,False) GPIO.output(12,False) GPIO.output(13,False) GPIO.output(16,False) GPIO.output(17,False) GPIO.output(22,True) GPIO.output(23,True) GPIO.output(24,True) GPIO.output(25,True)# end allesAus()

print ("Strg+C beendet das Programm")try: while True: # Muster a: GPIO.output(6,True) GPIO.output(24,False) GPIO.output(25,False) time.sleep(1) # ... und Muster b: GPIO.output(22,False) GPIO.output(23,False) time.sleep(1) # Muster c: allesAus() GPIO.output(5,True) GPIO.output(6,True) GPIO.output(25,False) time.sleep(1) #... und Muster d: GPIO.output(23,False) time.sleep(1)


#... und Muster e: GPIO.output(22,False) GPIO.output(24,False) time.sleep(1) #... und Muster f: GPIO.output(4,True) time.sleep(1) allesAus() except KeyboardInterrupt: GPIO.cleanup()

Lösung der Aufgabe "Rundlauf" (7seg_rundlauf.py)


# Alle Segment-Pins auf Output stellen:GPIO.setup(4, GPIO.OUT, initial = False); # Segment AGPIO.setup(5, GPIO.OUT, initial = False); # Segment BGPIO.setup(6, GPIO.OUT, initial = False); # Segment CGPIO.setup(12, GPIO.OUT, initial = False); # Segment DGPIO.setup(13, GPIO.OUT, initial = False); # Segment EGPIO.setup(16, GPIO.OUT, initial = False); # Segment FGPIO.setup(17, GPIO.OUT, initial = False); # Segment G

# Alle Stellen-Pins auf Output stellen; alle Stellen einschalten:GPIO.setup(22, GPIO.OUT, initial = False); # DIG.1GPIO.setup(23, GPIO.OUT, initial = False); # DIG.2GPIO.setup(24, GPIO.OUT, initial = False); # DIG.3GPIO.setup(25, GPIO.OUT, initial = False); # DIG.4

# Dauer: t = 0.05

print ("Strg+C beendet das Programm")try: while True: GPIO.output(4,True) # Segment A time.sleep(t) GPIO.output(4,False) GPIO.output(5,True) # Segment B time.sleep(t) GPIO.output(5,False) GPIO.output(6,True) # Segment C time.sleep(t) GPIO.output(6,False) GPIO.output(12,True) # Segment D time.sleep(t) GPIO.output(12,False) GPIO.output(13,True) # Segment E time.sleep(t) GPIO.output(13,False) GPIO.output(16,True) # Segment F time.sleep(t) GPIO.output(16,False)except KeyboardInterrupt: GPIO.cleanup()


So wie die 7-Segment-Anzeige aufgebaut ist, kann man zwar die einzelnen Stellen und Segmente ein- und ausschalten, aber man kann an allen Stellen immer nur die gleichen Segmente zum Leuchten bringen. Wie lässt sich aber eine vierstellige Zahl mit unterschiedlichen Ziffern wie z.B. "1234" anzeigen?

Projekt "Eingetippte Zahl anzeigen"

Zweck: Der Benutzer soll eine vierstellige Zahl eintippen, Diese soll dann auf der 7-Segment-Anzeige dargestellt werden und 2 Sekunden stehen bleiben.

Lösungsprinzip: Wir setzen das Zeit-Multiplex-Verfahren ein: An jeder Stelle lassen wir die entprechendeZiffer ganz kurz aufleuchten. Dies wiederholen wir so oft, bis 2 Sekunden vergangen sind. Durch das Nachleuchten der Anzeige entsteht der Eindruck, dass die Segmente dauernd leuchten.

Benötigte Bauteile: wie oben ("7-Segment programmgesteuert")

Aufbau: wie oben ("7-Segment programmgesteuert")

Python-Programm (7seg_zeigezahl.py):


# Segment GPIO-Pins:segA = 4segB = 5segC = 6segD = 12segE = 13segF = 16segG = 17

# Stellen GPIO-Pins:dig1 = 22dig2 = 23dig3 = 24dig4 = 25

# Alle Segment-Pins und Digit-Pins auf Output stellen:for seg in [segA, segB, segC, segD, segE, segF, segG]: GPIO.setup(seg, GPIO.OUT, initial = False);for dig in [dig1, dig2, dig3, dig4]: GPIO.setup(dig, GPIO.OUT, initial = True);

# Funktion zur Anzeige einer Dezimalziffer an einer bestimmten Stelle:def zeigeZifferAnStelle(ziffer, stelle): # alle Segmente und Stellen ausschalten: for seg in [segA, segB, segC, segD, segE, segF, segG]: GPIO.output(seg,False); for dig in [dig1, dig2, dig3, dig4]: GPIO.output(dig,True); # gewuenschte Stelle einschalten: GPIO.output(stelle,False);


# Segmente einschalten je nach zu anzuzeigender Dezimalziffer: if (ziffer == 0): for s in [segA, segB, segC, segD, segE, segF]: GPIO.output(s,True); if (ziffer == 1): for s in [segB, segC]: GPIO.output(s,True); if (ziffer == 2): for s in [segA, segB, segD, segE, segG]: GPIO.output(s,True); if (ziffer == 3): for s in [segA, segB, segC, segD, segG]: GPIO.output(s,True); if (ziffer == 4): for s in [segB, segC, segF, segG]: GPIO.output(s,True); if (ziffer == 5): for s in [segA, segC, segD, segF, segG]: GPIO.output(s,True); if (ziffer == 6): for s in [segA, segC, segD, segE, segF, segG]: GPIO.output(s,True); if (ziffer == 7): for s in [segA, segB, segC]: GPIO.output(s,True); if (ziffer == 8): for s in [segA, segB, segC, segD, segE, segF, segG]: GPIO.output(s,True); if (ziffer == 9): for s in [segA, segB, segC, segD, segF, segG]: GPIO.output(s,True);# end zeigeZifferAnStelle()

print ("Strg+C beendet das Programm")try: while True: # Text von Tastatur einlesen: s = raw_input("Bitte vierstellige Zahl eingeben:") z0 = int(s[3]) # Einer z1 = int(s[2]) # Zehner z2 = int(s[1]) # Hunderter z3 = int(s[0]) # Tausender # Zahl 500 mal anzeigen mit Multiplexing: # Ein Durchgang dauert 4 x 0.001s = 0.004s. # Die Zahl bleibt also 500 x 0.004s = 2s stehen. for i in range (1,500): # Alle Ziffern nacheinander kurz (0.001 s) aufblinken lassen: zeigeZifferAnStelle(z0,dig4) time.sleep(0.001) zeigeZifferAnStelle(z1,dig3) time.sleep(0.001) zeigeZifferAnStelle(z2,dig2) time.sleep(0.001) zeigeZifferAnStelle(z3,dig1) time.sleep(0.001) # Bemerkung: die Tausender-Ziffer bleibt stehen. Klar wieso?except KeyboardInterrupt: GPIO.cleanup()


Aufgabe "Zähler"

Schreiben Sie ein Programm, welches auf der 7-Segment-Anzeige von 0000 bis 9999 zählt, danach wieder von vorn. Variieren Sie die Zählgeschwindigkeit und die Blinkdauer der einzelnen Ziffern. Ab welcher Blinkdauer istdas Blinken von Auge erkennbar?

Zusatzaufgabe "Uhr"

Programmieren Sie eine Uhr, welche auf dem 7-Segment-Display die aktuelle Uhrzeit anzeigt (HH:MM).

Hinweise:- Wenn der Raspi ans Netz angeschlossen ist, stellt er seine Uhr beim Booten automatisch. Mit folgendem Shell-Kommando können Sie die Uhr manuell stellen:

sudo date -s "2016-03-18 13:05:00"

- Die aktuelle Uhrzeit können Sie von Python aus mit folgender Anweisung auslesen:

s = time.strftime("%H:%M:%S") # liefert z.B. "20:48:21"

- Der Doppelpunkt zwischen der 2. und der 3. Ziffer soll im Sekundentakt blinken. Informieren Sie sich anhand des Datenblatts (https://www.adafruit.com/datasheets/865datasheet.pdf), wie der Doppelpunkt zum Leuchten gebracht wird. Erweitern Sie dann den Schaltungsaufbau entsprechend und verwenden Sie eine (zwei?) weitere GPIO-Steuerleitung(en) für den Doppelpunkt.


Lösung Aufgabe "Zähler" (7seg_zaehler.py)


# Segment GPIO-Pins:segA = 4segB = 5segC = 6segD = 12segE = 13segF = 16segG = 17

# Stellen GPIO-Pins:dig1 = 22dig2 = 23dig3 = 24dig4 = 25

# Alle Segment-Pins und Digit-Pins auf Output stellen:for seg in [segA, segB, segC, segD, segE, segF, segG]: GPIO.setup(seg, GPIO.OUT, initial = False);for dig in [dig1, dig2, dig3, dig4]: GPIO.setup(dig, GPIO.OUT, initial = True);

# Funktion zur Anzeige einer Dezimalziffer an einer bestimmten Stelle:def zeigeZifferAnStelle(ziffer, stelle): # alle Segmente und Stellen ausschalten for seg in [segA, segB, segC, segD, segE, segF, segG]: GPIO.output(seg,False); for dig in [dig1, dig2, dig3, dig4]: GPIO.output(dig,True); # gewuenschte Stelle einschalten: GPIO.output(stelle,False); # Segmente einschalten je nach zu anzuzeigender Dezimalziffer: if (ziffer == 0): for s in [segA, segB, segC, segD, segE, segF]: GPIO.output(s,True); if (ziffer == 1): for s in [segB, segC]: GPIO.output(s,True); if (ziffer == 2): for s in [segA, segB, segD, segE, segG]: GPIO.output(s,True); if (ziffer == 3): for s in [segA, segB, segC, segD, segG]: GPIO.output(s,True); if (ziffer == 4): for s in [segB, segC, segF, segG]: GPIO.output(s,True); if (ziffer == 5): for s in [segA, segC, segD, segF, segG]: GPIO.output(s,True); if (ziffer == 6): for s in [segA, segC, segD, segE, segF, segG]: GPIO.output(s,True);


if (ziffer == 7): for s in [segA, segB, segC]: GPIO.output(s,True); if (ziffer == 8): for s in [segA, segB, segC, segD, segE, segF, segG]: GPIO.output(s,True); if (ziffer == 9): for s in [segA, segB, segC, segD, segF, segG]: GPIO.output(s,True);# end zeigeZifferAnStelle()

zahl = 0;print ("Strg+C beendet das Programm")try: while True: z0 = zahl%10 z1 = (zahl/10)%10 z2 = (zahl/100)%10 z3 = (zahl/1000)%10 # Jede 4-stellige Zahl 100 mal anzeigen mit Multiplexing (-> 0.4s): for i in range (1,100): # Alle Ziffern nacheinander kurz (0.001s) aufblinken lassen: zeigeZifferAnStelle(z0,dig4) time.sleep(0.001) zeigeZifferAnStelle(z1,dig3) time.sleep(0.001) zeigeZifferAnStelle(z2,dig2) time.sleep(0.001) zeigeZifferAnStelle(z3,dig1) time.sleep(0.001) zahl = zahl+1except KeyboardInterrupt: GPIO.cleanup()

Lösung Zusatzaufgabe "Uhr"

- (keine Musterlösung)


2.3 Piezo-Buzzer

Der Piezo-Buzzer ist ein einfacher Mini-Lautsprecher mit zwei Anschlüssen. Jedes Mal wenn die Spannung ändert, ertönt ein leises Klicken. Indem man die die Spannung sehr oft ändert, kann man einen Ton erzeugen (z.B. 1000 Mal pro Sekunde ein- und ausschalten -> Ton mit Frequenz 1000 Hz).

Projekt "Tonleiter einfach"

Zweck: Der Buzzer soll eine Tonleiter über 24 Halbtonschritte hinauf- und hinunterspielen. Der tiefste Ton hat 440 Hz. Pro Halbtonschritt erhöht sich die Frequenz um den Faktor 21/12 = 1.059463094 (d.h. in 12 Halbtonschritten verdoppelt sich die Frequenz; dies entspricht einer Oktave).

Lösungsprinzip: Die Pins des Buzzers werden mit GND bzw. GPIO-Pin 18 verbunden. Wir programmieren eine Python-Funktion buzz(pitch, duration), welche einen Ton mit der Frequenz pitch für die Zeitdauer duration abspielt.

Benötigte Bauteile:- 1 Piezo-Buzzer

Aufbau:

Python-Code (buzzer_tonleiter.py):

import RPi.GPIO as GPIOimport timeGPIO.setmode(GPIO.BCM)GPIO.setup(18, GPIO.OUT);

#This is a function to make a tone with buzzer or speaker#Source: https://gist.github.com/mandyRae/983a2547cf8239c88567def buzz(pitch, duration): period = 1.0 / pitch delay = period/2 cycles = int(duration * pitch) for i in range(cycles): GPIO.output(18, True) time.sleep(delay) GPIO.output(18, False) time.sleep(delay)# end buzz()


f = 440.0 # Startfrequenzfor i in range (0,24): f = f * 1.059463094 # 2^(1/12) buzz(f,0.2)for i in range (0,24): f = f / 1.059463094 # 2^(1/12) buzz(f,0.2)GPIO.cleanup()

Projekt "Tonleiter mit PWM"

Zweck: Gleich wie vorhin

Lösungsprinzip: Die GPIO-Programmbibliothek enthält eine Klasse PWM (Pulse Width Modulation), welche das sehr schnelle Ein- und Ausschalten automatisiert. Wir hätten z.B. das LED-Dimming auch mit PWM machen können.

So funktioniert PWM:

# PWM Objekt auf Pin channel mit Frequenz frequency erzeugenp = GPIO.PWM(channel, frequency)

# Starten (dc = "Duty Cycle" ist eine Zahl zwischen 0 und 100, welche angibt, # welchen Zeitanteil eines Zyklus das Signal eingeschaltet ist. p.start(dc)

# Frequenz ändern (freq = neue Frequenz)p.ChangeFrequency(freq)

# Duty Cycle ändern (dc = neuer Hoch-Anteil) p.ChangeDutyCycle(dc)

# Stoppenp.stop()

Benötige Bauteile und Schaltungsaufbau: gleich wie oben

Python-Code (buzzer_tonleiter_pwm.py):

import RPi.GPIO as GPIOimport timeGPIO.setmode(GPIO.BCM)GPIO.setup(18, GPIO.OUT);

f = 440.0p = GPIO.PWM(18,f)p.start(50) # Gleichmässiges Rechteck-Signal, halbe Zyklusdauer eingeschaltet (fix)

for i in range (0,24): p.ChangeFrequency(f) f = f * 1.059463094 # 2^(1/12) time.sleep(0.2)for i in range (0,24): p.ChangeFrequency(f) f = f / 1.059463094 # 2^(1/12) time.sleep(0.2)p.stop()GPIO.cleanup()


Lösung Aufgabe "Lied" (mit PWM)

Benötige Bauteile und Schaltungsaufbau: gleich wie oben

Python-Code (buzzer_lied_pwm.py):


GPIO.setup(18, GPIO.OUT);

G0 = 392; A0 = 440; H0 = 494c = 523; d = 587; e = 659; f = 698; g = 784; a = 880; h = 988

def ton(frequenz, dauer): p.ChangeFrequency(frequenz) # Ton spielen: p.start(50) time.sleep(dauer - 0.1) # Kurze Pause: p.stop() time.sleep(0.1)# end ton()

p = GPIO.PWM(18,c) # PWM Objekt

t = 0.25 # Dauer eine Viertelnote

# "Alli mini Äntli":ton(c,t); ton(d,t); ton(e,t); ton(f,t)ton(g,2*t); ton(g,2*t)ton(a,t); ton(a,t); ton(a,t); ton(a,t)ton(g,4*t)ton(a,t); ton(a,t); ton(a,t); ton(a,t)ton(g,4*t)ton(f,t); ton(f,t); ton(f,t); ton(f,t)ton(e,2*t); ton(e,2*t)ton(d,t); ton(d,t); ton(d,t); ton(d,t)ton(c,4*t)

GPIO.cleanup()


Lösung Aufgabe "Klavier" (mit PWM)

Lösungsprinzip:Die 4 Taster werden über entsprechende Widerstände mit den GPIO-Pins 20, 21, 22 und 23 verbunden.Das Programm fragt die Tasten nacheinander ab und erzeugt via PWM den Ton.

Benötige Bauteile:- 1 Piezo Buzzer- 4 Stück Tastschalter- 4 Stück 470 Ohm Widerstände (gelb-violett-braun, Schutzwiderstände)- 4 Stück 10 kOhm Widerstände (braun-schwarz-orange, Pulldown-Widerstände)

Schaltungsaufbau:

Python-Code (buzzer_klavier_pwm.py):

import RPi.GPIO as GPIOimport timeGPIO.setmode(GPIO.BCM)buzzer_pin = 18c_pin = 20; d_pin = 21; e_pin = 22; f_pin = 23c_freq = 523; d_freq = 587; e_freq = 659; f_freq = 698GPIO.setup(buzzer_pin, GPIO.OUT);GPIO.setup(c_pin, GPIO.IN); GPIO.setup(d_pin, GPIO.IN);GPIO.setup(e_pin, GPIO.IN); GPIO.setup(f_pin, GPIO.IN);

p = GPIO.PWM(buzzer_pin,1)print ("Strg+C beendet das Programm")try: while True: if GPIO.input(c_pin)==True: p.ChangeFrequency(c_freq); p.start(50) elif GPIO.input(d_pin)==True: p.ChangeFrequency(d_freq); p.start(50) elif GPIO.input(e_pin)==True: p.ChangeFrequency(e_freq); p.start(50) elif GPIO.input(f_pin)==True: p.ChangeFrequency(f_freq); p.start(50) else: # keine Taste gedrueckt p.stop()except KeyboardInterrupt: GPIO.cleanup()


3 Grafik und Sound

3.1 Grafische Benutzeroberflächen mit Tkinter

Tkinter ist eine Python-Programmbibliothek, mit welcher sich grafische Benutzeroberflächen programmieren lassen. Ein deutschsprachiges Tutorial gibt es auf www.python-kurs.eu/python_tkinter.php

Projekt "LED ein/aus mit GUI"

Zweck: LED, welche sich mit zwei GUI-Buttons ein- und ausschalten lässt.

Lösungsprinzip: Die LED wird (via Widerstand!) an den GPIO-Pin 25 angeschlossen. Das GUI wird mit Tkinter erstellt.


Aufbau:

Python-Programm (tkinter_led_einaus.py):

import RPi.GPIO as GPIO# Tkinter Bibliothek importieren:from Tkinter import *

LED = 25GPIO.setmode(GPIO.BCM)GPIO.setup(LED,GPIO.OUT)

# Methode zum Einschalten der LED (Event-Handler):def LedEin(): GPIO.output(LED,True)

# Methode zum Ausschalten der LED (Event-Handler):def LedAus(): GPIO.output(LED,False)


# Fenster erzeugen:win = Tk();# Titel setzen:win.title("LED")# Ein Label hinzufuegen:l = Label(win, text="Bitte Button klicken, um die LED ein- und auszuschalten")l.pack()# Zwei Buttons mit Event-Handler erzeugenb1 = Button(win, text="Ein", command=LedEin)b2 = Button(win, text="Aus", command=LedAus)# und dem Fenster hinzufuegen (linksbuendig):b1.pack(side=LEFT)b2.pack(side=LEFT)# Hauptschleife starten:win.mainloop()# Nach dem Schliessen GPIO aufraeumen:GPIO.cleanup()

Projekt "Schieberegler-Test"

Zweck: GUI-Fenster mit einem Schieberegler, dessenaktueller Wert in einem Label angezeigt wird.

Lösungsprinzip: Python-Programm mit Tkinter (nurSoftware)

Python-Programm (tkinter_slider.py):

from Tkinter import *

def show_value(val): # Slider-Wert in Label ausgeben: lab.config(text="Wert = " + str(val))

# Fenster erzeugen:win = Tk()win.title("Slider")# Slider erzeugen mit Bereich und Event-Handlerslider = Scale(win, from_=0, to=100, length = 300, command=show_value, orient=HORIZONTAL)slider.pack()#Startwert setzen:slider.set(23)# Label erzeugen:lab = Label(win, text="##")lab.pack()# Hauptschleife starten:win.mainloop()

Aufgabe: "Buzzer mit Schieberegler für Tonhöhe" (ohne Musterlösung)

Zweck: Die Tonhöhe eines Buzzers soll mit einem GUI-Schieberegler eingestellt werden können. Ausserdem soll der Buzzer mit einem GUI-Button ein- und ausgeschaltet werden können.

Aufgabe: "LED-Dimmer mit Schieberegler" (ohne Musterlösung)

Zweck: Eine LED soll via einen GUI-Schieberegler gedimmt werden können.

Tipp: Verwenden Sie PWM.


3.2 Grafik- und Soundprogrammierung mit Pygame

Pygame ist eine Sammlung von Python-Modulen, die es einem ermöglichen, relativ einfach und schnell Grafiken und Spiele zu programmieren.

Auf www.pygame.org/docs/ ist eine ausführliche Dokumentation zu finden.

Im Ordner python_games auf dem Raspi gibt es einige Spiele, welche mit Pygame programmiert wurden. Probieren Sie sie aus, und schauen Sie sich auch den Quellcode an!

Wir beginnen ganz einfach, nämlich mit dem Abfangen von Keyboard-Events.

Projekt: "Keyboard-Events"

Zweck: Ein Python-Programm soll Keyboard-Events erkennen und ausgeben.

Lösungsprinzip: Unser Programm öffnet (wie jedes Pygame-Projekt) ein Fenster. Keyboard-Ereignisse werden nur erkannt, wenn dieses Fenster aktiv ist.

Python-Programm (pygame_key_event.py):

import pygameimport sys

# Pygame initialisieren:pygame.init()# Fenstergroesse festlegen:pygame.display.set_mode((200,200))

print ("Press Esc to quit")while True: keys=pygame.key.get_pressed() if keys[pygame.K_LEFT] : print("Left") elif keys[pygame.K_RIGHT]: print("Right") elif keys[pygame.K_a]: print("A") elif keys[pygame.K_s]: print("S") elif keys[pygame.K_ESCAPE]: pygame.quit() sys.exit() # Event-Queue abarbeiten: pygame.event.pump()

Aufgabe: Buzzer-Klavier mit Keyboard-Tasten

Zweck: Mit der Tastatur soll auf dem Buzzer Klavier gespielt werden können. Die Tasten A, S, D, F, G, H, J, K sollen den Tönen c, d, e, f,... entsprechen.


Projekt "Analog-Uhr"

Zweck: Analog-Uhr mit Stunden- Minuten und Sekundenzeiger in einem Fenster

Lösungsprinzip: Grafikprogrammierung mit Pygame (nur Software)

Python-Programm (pygame_uhr.py):

import pygame, timefrom pygame.locals import *from math import sin, cos, radians

pygame.init()rot = (255, 0, 0); weiss = (255, 255, 255); schwarz = (0, 0, 0)canvas = pygame.display.set_mode((400, 400))canvas.fill(weiss)# Mittelpunkt der Uhr:MX = 200; MY = 200; MP = ((MX, MY))

# erzeugt einen Punkt mit Abstand r vom Mittelpunkt# für t Minuten nach der vollen Stunde# bzw t Sekunden nach der vollen Minutedef punkt(r, t): alpha = radians(t * 6 - 90) x1 = int(MX + r * cos(alpha)) y1 = int(MY + r * sin(alpha)) return((x1, y1))# end punkt()

# Minutenmarken:for i in range(60): pygame.draw.circle(canvas, schwarz, punkt(190, i), 2)# Stundenmarken (bzw 5-Minutenmarken):for i in range(12): pygame.draw.circle(canvas, schwarz, punkt(190, i * 5), 4)

s1 = 0mainloop = Truewhile mainloop: zeit = time.localtime() s = zeit.tm_sec m = zeit.tm_min h = zeit.tm_hour if h > 12: h = h - 12 hm = (h + m / 60.0) * 5 if s1 <> s: pygame.draw.circle(canvas, weiss, MP, 182) # Mittelpunkt pygame.draw.line(canvas, schwarz, MP, punkt(120, hm), 6) # Stundenzeiger pygame.draw.line(canvas, schwarz, MP, punkt(170, m), 4) # Minutenzeiger pygame.draw.line(canvas, rot, MP, punkt(180, s), 2) # Sekundenzeiger s1 = s pygame.display.set_caption("Aktuelle Zeit: " + time.asctime()) pygame.display.update() # Event zum Beenden des Programms behandeln: for event in pygame.event.get(): if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE): mainloop = False time.sleep(0.1)pygame.quit()


Aufgabe: "Tron"

Zweck: Eine Spielfigur in Form eines kleinen blauenQuadrates soll sich timergesteuert in einem Fenster nachrechts, links, oben oder unten bewegen. Mit den Pfeiltastensoll die Richtung geändert werden können. Ausserdem solldie Figur mit der Leertaste angehalten werden können.Zu Beginn soll sich die Figur am linken Fensterrand aufhalber Höhe befinden und sich nach rechts bewegen.

Tipp: Ein Rechteck kann mit folgender Anweisung gezeichnet werden:

pygame.draw.rect(canvas, farbe, (x, y, w, h))

Lösung Aufgabe "Tron" (pygame_tron.py)

import pygameimport timeimport sys

# Init:pygame.init()weiss = (255, 255, 255); blau = (0, 0, 255)canvas = pygame.display.set_mode((400, 300))pygame.display.set_caption("Tron")canvas.fill(weiss)# Position:posX = 0; posY = 150# Richtung:dx = 1; dy = 0

print ("Press Esc to quit")while True: posX += 10*dx posY += 10*dy keys=pygame.key.get_pressed() if keys[pygame.K_LEFT]: dx = -1; dy = 0 elif keys[pygame.K_RIGHT]: dx = 1; dy = 0 elif keys[pygame.K_UP]: dx = 0; dy = -1 elif keys[pygame.K_DOWN]: dx = 0; dy = 1 elif keys[pygame.K_SPACE]: dx = 0; dy = 0 elif keys[pygame.K_ESCAPE]: pygame.quit() sys.exit() pygame.draw.rect(canvas, blau, (posX, posY, 10, 10)) pygame.display.update() time.sleep(0.1) # Event-Queue abarbeiten: pygame.event.pump() pygame.quit()


Projekt "MP3-Player mit einfachem Tastatur-Lautstärkeregler"

Zweck: Ein Python-Programm soll ein MP3-File über den Audio-Ausgang des Raspi (*) abspielen. Mit den Tasten '+' und '-' soll die Lautstärke variiert werden können, mit Space soll das Abspielen pausiert und mit 'q' soll das Programm verlassen werden (jeweils gefolgt von der Enter-Taste).

Lösungsprinzip: Mit der Klasse pygame.mixer.music können MP3-Dateien abgespielt (genauer: gestreamt) werden. Die Klasse enthält Methoden für Lautstärkeregelung und vieles mehr.Doku: http://pygame.org/docs/ref/music.htmlDas abzuspielende MP3-File befindet sich im Unterordner sound.

(*) Achtung: Allenfalls muss der Raspi zuerst für den Kopfhörer-Ausgang konfiguriert werden:sudo raspi-config -> Advanced Options -> Audio -> Force 3.5mm Jack -> Finish, dann Reboot.

Python-Programm (pygame_play_mp3.py):

import pygameimport os

pygame.mixer.init()

vol = 0.5pause = Falsepygame.mixer.music.load("sound/blackvelvet.mp3")pygame.mixer.music.set_volume(vol)pygame.mixer.music.play()

print "[+]: lauter"print "[-]: leiser"print "[space]: pause/cont."print "[q]: quit"gameloop = Truewhile gameloop: answer = raw_input("press key followed by [ENTER]") if answer == "+": vol = vol + 0.1 if vol > 1: vol = 1.0 pygame.mixer.music.set_volume(vol) if answer == "-": vol = vol - 0.1 if vol < 0: vol = 0.0 pygame.mixer.music.set_volume(vol) if answer == " ": pause = not pause if pause: pygame.mixer.music.pause() else: pygame.mixer.music.unpause() if answer == "q": pygame.mixer.music.stop() gameloop = Falseprint("bye")pygame.quit() # clean exit

Aufgabe "MP3-Player mit Drucktaster-Lautstärkeregler"

Zweck: Bauen Sie einen MP3-Player, bei dem die Lautstärke mit zwei Drucktastern verändert werden kann.


Projekt "verschiedene WAV-Sounds abspielen"

Zweck: Ein Python-Programm soll auf Benutzereingabe (jeweils gefolgt von der Enter-Taste) verschiedene kurze Sounds über den Audio-Ausgang abspielen.

Lösungsprinzip: Mit der Klasse pygame.mixer.Sound lassen sich WAV-Dateien abspielen - auch mehrere gleichzeitig.Doku: http://pygame.org/docs/ref/mixer.html (runterscrollen bis pygame.mixer.Sound).Die abzuspielenden WAV-Files befinden sich im Unterordner sound.

Python-Programm (pygame_play_wavs.py):

import pygame

# setup mixer to avoid sound lag:pygame.mixer.pre_init(44100, -16, 2, 2048)pygame.init()

# load sounds:sound1 = pygame.mixer.Sound('sound/sound1.wav')sound2 = pygame.mixer.Sound('sound/sound2.wav')

print "[a]: sound 1"print "[b]: sound 2"print "[q]: quit"gameloop = Truewhile gameloop: answer = raw_input("press key followed by [ENTER]") if answer == "a": print("playing sound 1 once") sound1.play() if answer == "b": print("playing sound 2 once") sound2.play() if answer == "q": gameloop = Falseprint("bye")pygame.quit() # clean exit

Aufgabe "E-Drum"

Zweck: Bauen Sie ein elektronisches Schlagzeug mit Drucktastern. Im Ordner sound stehen folgende Samples zur Verfügung:


4 Digitale Sensoren

4.1 Numerisches KeyPad

Das numerische KeyPad enthält 12 Tasten (0,.. 9, # und *), welche in einer Matrix von 4 Zeilen und 3 Spalten angeordnet sind. Jede Taste funktioniert als Schalter, welcher die jeweilige Zeile mit der entsprechenden Spalte verbinden kann. Wenn z.B. die Taste 6 gedrückt wird, ist ROW2 mit COL3 verbunden.

Schaltplan: Anschlüsse:

Um die Tasten abzufragen, kann man z.B. die Spalten (COL1,..COL3) nacheinander auf 1 (3.3V) schalten und für jede eingeschaltete Spalte nacheinander die Zeilen (ROW1, ..., ROW4) abfragen.

Wir werden also die Anschlüsse COL1, COL2 und COL3 mit GPIO-Output-Pins des Raspi verbinden, die Anschlüsse ROW1, ROW2, ROW3 und ROW4 mit GPIO-Input-Pins.

Zu beachten ist, dass wir wie früher beim einfachen Tastschalter die Leitungen nicht direkt verbinden dürfen, sondern Schutzwiderstände und Pulldown-Widerstände einsetzen müssen.


Projekt "KeyPad simple"

Zweck: Das Programm soll die KeyPad-Taste ausgeben, welche gedrückt ist.

Lösungsprinzip: Wie oben beschrieben, Verbindungen gemäss folgenden Tabellen:

Spalten (Verbindung direkt):

Anschluss COL1 COL2 COL3

GPIO-Pin 4 5 6

Drahtfarbe grün blau braun

Zeilen (Verbindung über Schutz- und Pulldown-Widerstände):

Anschluss ROW1 ROW2 ROW3 ROW4

GPIO-Pin 12 13 16 17

Drahtfarbe gelb orange rot violett

Benötigte Bauteile:- KeyPad mit montiertem Verbindungsstecker- 4 Stück 470 Ohm Widerstände (gelb-violett-braun, Schutzwiderstände)- 4 Stück 10 kOhm Widerstände (braun-schwarz-orange, Pulldown-Widerstände)

Aufbau:


Python-Programm (keypad_simple.py):


col1 = 4col2 = 5col3 = 6cols = [col1, col2, col3]

row1 = 12row2 = 13row3 = 16row4 = 17rows = [row1, row2, row3, row4]

keys = [ ['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9'], ['*', '0', '#']]

for col in cols: GPIO.setup(col, GPIO.OUT, initial = False);

for row in rows: GPIO.setup(row, GPIO.IN);

print ("Strg+C beendet das Programm")try: while True: for i in range (0,3) : GPIO.output(cols[i],True) for k in range (0,4): if GPIO.input(rows[k]) == True: print keys [k][i] time.sleep(0.01) GPIO.output(cols[i],False)except KeyboardInterrupt: GPIO.cleanup()

Aufgabe "KeyPad Flanke"

Zweck: Das Programm soll jeden Tastendruck nur einmal ausgeben. Dazu muss es für jede Taste die steigende Flanke (also von Aus auf Ein) erkennen (vgl. früher: Ein-Aus-Tastschalter).

Aufgabe "Schliessfach"

Zweck: Ein Schliessfach soll mit einem fixen, 4stelligen Zahlencode gesichert sein. Eine rote bzw. grüne LED soll anzeigen, ob das Fach geschlossen oder geöffnet ist. Beim Programmstart soll das Fach geschlossen sein. Durch Eintippen des richtigen Codes auf dem KeyPad gefolgt von * soll das Schloss geöffnet werden (z.B. 1234*). Mit der KeyPad-Taste # soll das Fach wieder geschlossen werden.

Zusatzaufgabe: Erweitern Sie das Programm, sodass der Schlüsselcode geändert werden kann. Dies darf natürlich nur dann möglich sein, wenn das Fach geöffnet ist, z.B. durch Eingabe des neuen Codes gefolgt von # (z.B. 2345#).


Lösung der Aufgabe "KeyPad Flanke" (keypad_flanke.py)


col1 = 4col2 = 5col3 = 6cols = [col1, col2, col3]

row1 = 12row2 = 13row3 = 16row4 = 17rows = [row1, row2, row3, row4]

keys = [ ['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9'], ['*', '0', '#']]

keydown = [ [False,False,False], [False,False,False], [False,False,False], [False,False,False]]

for col in cols: GPIO.setup(col, GPIO.OUT, initial = False);

for row in rows: GPIO.setup(row, GPIO.IN);

print ("Strg+C beendet das Programm")try: while True: for i in range (0,3) : GPIO.output(cols[i],True) for k in range (0,4): if GPIO.input(rows[k]) == True and keydown[k][i] == False: print keys [k][i] keydown[k][i] = GPIO.input(rows[k]) time.sleep(0.01) GPIO.output(cols[i],False)except KeyboardInterrupt: GPIO.cleanup()

Lösung der Aufgabe "Schliessfach"

- (keine Musterlösung)


4.2 Temperatursensor DS18B20

Der DS18B20 ist ein digitaler Temperatursensor. Der Messwert wird im Sensor digitalisiert und dann in binärer Form an den Raspi geliefert. Er funktioniert mit dem sogenannten 1wire-Protokoll (One-Wire). Dabei erfolgt der gesamte Datenfluss seriell über eine einzige Leitung.

Der Schaltungsaufbau sieht wir folgt aus. Wir verwenden fix den GPIO-Pin 4 für die Datenleitung (mittlerer Pin des DS18B20). Der Widerstand hat 4.7 kOhm (gelb-violett-rot). Achten Sie darauf, dass Sie den Sensor nicht verkehrt herum anschliessen.

Um die Daten des DS18B20 vom Raspi aus lesen zu können, müssen wir zuerst den 1wire-Support konfigurieren.

1wire-Support installieren für GPIO-Pin 4 (einmalig)

Öffnen Sie eine Shell. Machen Sie dann eine Sicherungskopie der Datei /boot/config.txt:

sudo cp /boot/config.txt /boot/config.txt.ORIG

Öffnen Sie die Datei dann in einem Editor, z.B. leafpad:

sudo leafpad /boot/config.txt

Fügen Sie am Ende der Datei die Zeile

dtoverlay=w1-gpio

hinzu, speichern Sie und schliessen Sie den Editor.

Starten Sie anschliessend den Raspi neu:

sudo reboot

>>> Trouble-Shooting:

Falls /boot/config.txt nicht existiert:- ev. Shift-Taste beim Booten drücken, dann -> Konfigurationseditor -> Einstellungen bearbeiten -> config.txt- ev. sudo apt-get update und sudo apt-get upgrade ausführen (nicht upgrade-dist!)

Falls es immer noch nicht geht: - ev. Eintrag in config.txt: dtoverlay=w1-gpio,gpiopin=4,pullup=on und sudo modprobe w1-gpio pullup=1


Nun können (hoffentlich!) die Daten des DS18B20 ausgelesen werden. Wir tun dies zunächst nicht mit einem Python-Programm, sondern direkt von der Shell aus.

Sensor auslesen von der Shell aus

Führen Sie ein einer Shell die unten stehenden Anweisungen aus.

Achtung: Das Verzeichnis 28-000003cee4ca hat bei Ihnen einen leicht geänderten Namen, es muss aber mit 28 beginnen.

Mit dem Befehl cat w1_slave wird der Sensor ausgelesen. Es werden zwei Zeilen ausgegeben. Die zweite Zeile enthält am Ende die Temperatur in 1/1000 Grad Celsius, im obigen Beispiel also zuerst 20.687 °C, später 26.125 °C.

Nun machen wir dasselbe mit einem Python Programm.

Projekt "DS18B20 simple"

Zweck: Die Temperatur soll sekündlich ausgegeben werden.

Lösungsprinzip: Wir tun eigentlich genau dasselbe wie vorhin von der Shell aus, aber mit Python. Ausserdem wird der Temperaturwert aus der Sensor-Antwort herausgefiltert.

Schaltungsaufbau: siehe oben

PythonProgramm (ds18b20_simple.py):

# Source:# https://learn.adafruit.com/adafruits-raspberry-pi-lesson-11-ds18b20-temperature-sensing?view=all# 30.03.2016

import osimport globimport time os.system('modprobe w1-gpio')os.system('modprobe w1-therm') base_dir = '/sys/bus/w1/devices/'device_folder = glob.glob(base_dir + '28*')[0]device_file = device_folder + '/w1_slave'


def read_temp_raw(): f = open(device_file, 'r') lines = f.readlines() f.close() return lines def read_temp(): lines = read_temp_raw() while lines[0].strip()[-3:] != 'YES': time.sleep(0.2) lines = read_temp_raw() equals_pos = lines[1].find('t=') if equals_pos != -1: temp_string = lines[1][equals_pos+2:] temp = float(temp_string) / 1000.0 return temp

print ("Strg+C beendet das Programm")try: while True: print(read_temp()) time.sleep(1)except KeyboardInterrupt: print "bye"

Bemerkungen:- Dieses Programm kommt ohne die GPIO-Library aus. Das Auslesen der Messdaten erfolgt ausschliesslich über das Filesystem.- Die Messung dauert eine gewisse Zeit. Deshalb ist der Messzyklus länger als eine Sekunde.

Dank dem raffinierten 1-wire Protokoll lassen sich auch mehrere Temperatursensoren parallel schalten. Jeder Sensor trägt nämlich eine weltweit eindeutige ID, die bei jeder Messung zusammen mit den Messdaten an den Raspi geschickt wird. Auf diese Weise kann der Raspi die einzelnen Sensoren unterscheiden.

Die Schaltung mit zwei Sensoren sieht so aus:


Der zweite Sensor kann auch ausserhalb des Breadboards in einiger Entfernung angebracht werden. Man braucht dazu Verbindungskabel mit einem Stecker und einer Buchse (male/female). Auf diese Weise kann man z.B. die Temperatur in zwei Räumen überwachen.

Zwei Sensoren über die Shell auslesen

Im Unterschied zu vorhin gibt es jetzt in /sys/bus/w1/devices zwei Verzeichnisse, welche mit 28 beginnen. Jedes dieser Verzeichnisse enthält eine Datei w1_slave mit den Daten des jeweiligen Sensors.

Der erste Sensor misst also 20.187 °C, der zweite 30.562 °C.

Aufgabe "Zwei Temperatursensoren mit Python auslesen"

Passen Sie das obige Python-Programm an, so dass es die Messwerte von zwei (oder mehr?) Sensoren sekündlich ausgibt.


Lösung der Aufgabe "Zwei Temperatursensoren mit Python auslesen" (ds18b20_multi.py)

import osimport globimport time os.system('modprobe w1-gpio')os.system('modprobe w1-therm') base_dir = '/sys/bus/w1/devices/'device_folders = glob.glob(base_dir + '28*') def read_temp_raw(device_folder): device_file = device_folder + '/w1_slave' f = open(device_file, 'r') lines = f.readlines() f.close() return lines def read_temp(device_folder): lines = read_temp_raw(device_folder) while lines[0].strip()[-3:] != 'YES': time.sleep(0.2) lines = read_temp_raw() equals_pos = lines[1].find('t=') if equals_pos != -1: temp_string = lines[1][equals_pos+2:] temp = float(temp_string) / 1000.0 return temp

print ("Strg+C beendet das Programm")try: while True: temps = [] for device_folder in device_folders: temps.append(read_temp(device_folder)) print temps time.sleep(1)except KeyboardInterrupt: print "bye"

Beispiel-Ausgabe:


4.3 Lichtsensor

Als Lichtsensor verwenden wir einen lichtempfindlichen Widerstand (CdS photoresistior):

Je heller es ist, umso geringer ist der Widerstand dieses Bauteils.Ausserdem benötigen wir einen Kondensator. Das ist eine Art Ladungsspeicher. Die Kapazität eines Kondensators wird in der Einheit Farad angegeben.Um die Helligkeit zu messen, entleeren wir zuerst den Kondensator und laden ihn dann über den Lichtsensor auf. Dies geht umso schneller, je geringer der Widerstand des Lichtsensors ist. Wir messen jeweils die Anzahl Zyklen, die es braucht, bis der Kondensator aufgeladen ist. Diese Zahl ist ein Mass fürdie Helligkeit - je kleiner die Zahl, umso heller.


Projekt "Fotozelle einfach"

Zweck: Die Helligkeit soll gemessen und als Zahl ausgegeben werden.

Lösungsprinzip: Wie oben beschrieben; wir verwenden den GPIO-Pin 18.

Benötigte Bauteile:- Photozelle- Kondensator 1 F (1 Mikrofarad)

Aufbau:

Python-Code (photocell_simple.py):

import RPi.GPIO as GPIOimport time GPIO.setmode(GPIO.BCM)

print ("Strg+C beendet das Programm")try: while True: # Pin 18 auf Output stellen und auf Wert 0 setzen. # Dadurch wird der Kondensator entladen. GPIO.setup(18, GPIO.OUT) GPIO.output(18, 0) time.sleep(0.1) # Pin 18 auf Input stellen. # Dadurch wird der Ladevorgang des Kondensators gestartet. GPIO.setup(18, GPIO.IN) # In einer Schleife warten, bis der Kondensator aufgeladen ist. # Anzahl Durchgänge zählen. n = 0 while (GPIO.input(18) == 0): n += 1 # Ergebnis ausgeben. print nexcept KeyboardInterrupt: GPIO.cleanup()


Aufgabe "Auto-LED"

Erweitern Sie das obige Projekt um eine LED, welche immer dann leuchtet, wenn es genügend dunkel ist. Welcher Helligkeitswert eignet sich als Grenze zwischen hell und dunkel?Was passiert, wenn Sie die LED direkt neben dem Lichtsensor platzieren?


5 Analoge Sensoren

5.1 Analog-Digital-Wandler MCP3008 und Potentiometer (Drehregler)

Ein Potentiometer ist ein regelbarer Widerstand. Der linke Pin wird mit GND verbunden, der rechte mit 3.3V. Am mittleren Pin wird die Spannung gemessen. Je nach Position des Reglers liegt zwischen dem GND-Pin und dem mittleren Pin eine Spannung zwischen 0V und 3.3V.

Um diesen analogen Wert vom Raspi aus lesen zu können, braucht es einen Analog-Digital-Converter (ADC). Wir verwenden den Chip MCP3008. Er kann bis zu 8 analoge Signale in digitale Werte umwandeln, und das mit einer Auflösung von 10 Bit, d.h. die digitalen Werte liegen im Bereich von 0 bis 1023 (1023 = 210 -1).

Potentiometer: AD-Wandler MCP3008:

Pin-Belegung des MCP 3008:

CH0 bis CH7 Analoge Eingänge für bis zu 8 Geräte

VDD Power -> 3.3V

VREF Analoge Referenzspannung -> 3.3V

AGND Analog Ground -> GND

CLK Clock

DOUT Datenausgabe MCP3008 -> Raspi

DIN Dateneingabe Raspi -> MCP3008 (Befehle)

CS Chip Select

DGND Digital Ground -> GND

Kommunikationsprotokoll zwischen Raspi und MCP3008:


Dieses Protokoll heisst SPI (Serial Peripheral Interface Bus). Neuere Versionen des Raspi haben dieses Verfahren fest eingebaut. Dazu werden unter anderem die GPIO-Pins MISO und MOSI verwendet (sieheCobbler-Beschriftung). Wir machen es aber manuell, d.h. die Kommunikation wird vollständig in Python programmiert, dafür haben wir bei der Pin-Belegung freie Wahl. Und: So wie wir es machen, funktioniert es auf allen Raspis, auch auf solchen der ersten Generation.

Projekt "Potentiometer auslesen"

Zweck: Die Stellung des Drehreglers soll fortlaufend als Zahl zwischen 0 und 1023 ausgegeben werden.

Lösungsprinzip: wie oben beschrieben. Das SPI-Protokoll ist in einer Funktion readData() umgesetzt. Wir gehen hier nicht weiter auf die Details ein. Diese Funktion wird in einer Endlosschleife aufgerufen.

Die Verbindungen und Pin-Belegungen sind wie folgt:

MCP3008:

Pin CH0 VDD VREF AGND CLK DOUT DIN CS DGNB

GPIO-Pin Mittlerer Pindes

Potentiometers

3V3 3V3 GND 18 23 24 25 GND

Drahtfarbe grün rot rot schwarz orange gelb blau violett schwarz

Potentiometer:

Pin links Mitte rechts

GPIO-Pin GND CH0 desMCP3008

3V3

Drahtfarbe schwarz grün rot

Benötigte Bauteile:- Potentiometer- MCP3008 Analog-Digital-Wandler

Aufbau:Beachten Sie, dass sich die halbrunde Kerbe des MCP3008 auf der rechten Seite befindet.


Python-Programm (mcp3008_simple.py):



def readData(channel): # read SPI data from MCP3008 chip, 8 possible adc channels (0 thru 7) # this function was written by Limor "Ladyada" Fried # for Adafruit Industries, (c) 2015 if ((channel > 7) or (channel < 0)): return -1 GPIO.output(cs, True) GPIO.output(clk, False) # start clock low GPIO.output(cs, False) # bring CS low command = channel command |= 0x18 # start bit + single-ended bit command <<= 3 # we only need to send 5 bits here for i in range(5): if (command & 0x80): GPIO.output(din, True) else: GPIO.output(din, False) command <<= 1 GPIO.output(clk, True) GPIO.output(clk, False) adcout = 0 # read in one empty bit, one null bit and 10 ADC bits for i in range(12): GPIO.output(clk, True) GPIO.output(clk, False) adcout <<= 1 if (GPIO.input(dout)): adcout |= 0x1 GPIO.output(cs, True) adcout >>= 1 # first bit is 'null' so drop it return adcout# end readData()

# Pin-Belegung:clk = 18dout = 23din = 24cs = 25

GPIO.setup(clk, GPIO.OUT)GPIO.setup(cs, GPIO.OUT)GPIO.setup(din, GPIO.OUT) # Input für MCP3008, Output für RaspiGPIO.setup(dout, GPIO.IN) # Output für MCP3008, Input für Raspi

print ("Strg+C beendet das Programm")try: while True: potValue = readData(0) print potValue time.sleep(0.1)except KeyboardInterrupt: GPIO.cleanup()


Aufgabe: LED mit Helligkeits-Regler

Die Helligkeit einer LED soll über ein Potentiometer geregelt werden können (z.B. mit PWM).

Aufgabe: Regelbare LED-Säule

Abhängig von der Stellung eines Potentiometers sollen 0, 1, 2, 3 oder 4 LEDs leuchten.

Aufgabe: Lichtsensor mit dem MCP3008

Erinnern Sie sich an die Fotozelle? Das ist ja auch ein variabler Widerstand, also auch ein analoger Sensor. Wir haben seinen Wert damals umständlich mit Hilfe eines Kondensators bestimmt. Nun könnenwir das auch mit dem MCP3008 tun. Wir müssen im Wesentlichen nur den Drehregler durch die Fotozelle ersetzen. Wir bauen noch einen 220 Ohm Widerstand ein und greifen die Spannung zwischen der Fotozelle und dem Widerstand ab:

Bauen Sie die Schaltung auf. Beachten Sie, dass Sie am Programm überhaupt nichts ändern müssen!

Zusatzaufgabe: Drehregler und Lichtsensor

Schliessen Sie den Drehregler und die Fotozelle an zwei verschiedenen Kanälen des MCP3008 an. Passen Sie das Programm so an, dass beide Werte gelesen und fortlaufend angezeigt werden.


6 Der Raspi als Webserver

6.1 Installationen

Apache installieren

sudo apt-get install apache2 -y

Test: Browser: http://localhost

Wenn Sie die Seite von einem anderen Gerät aus aufrufen wollen, benötigen Sie die IP-Adresse ihres Raspi. Sie finden diese mit dem Befehl (Shell)

hostname -I

Dieser Befehl liefert z.B. 192.168.1.115.

Öffnen Sie Adresse im Browser eines anderen Geräts:


PHP installieren

sudo apt-get install php5-common libapache2-mod-php5 -y

Test: Erzeugen Sie die Datei /var/www/phpinfo.php mit folgendem Inhalt (z.B. mit sudo leafpad):

<?php phpinfo(); ?>

Öffnen Sie sie im Browser. Es sollte eine Seite ähnlich wie diese erscheinen:

GD Library installieren

GD ist eine PHP-Library für Bildbearbeitung. Sie ist Voraussetzung für die Library JPGraph.

GD wird wie folgt installiert:

sudo apt-get install php5-gd -y

Test: Wenn Sie phpinfo.php erneut aufrufen, sollte die Seite einen Abschnitt zu GD enthalten:


JPGraph installieren

JPGraph ist eine PHP-Library, welche Diagramme verschiedenster Art erzeugen kann. JPGraph basiert auf der GD-Library.

Für die Installation von JPGraph gehen Sie wie folgt vor: Laden Sie im Webbrowser von der Seite

http://jpgraph.net/download/

die Datei

jpgraph-4.0.0.tar.gz

herunter (oder ähnlich, je nach Version). Diese wird im Ordner /home/pi/Downloads gespeichert.

Führen Sie in einer Shell die folgenden Befehle aus:

cd /home/pi/Downloads

tar xzf jpgraph-4.0.0.tar.gz

sudo mkdir /usr/share/php

sudo cp -r jpgraph-4.0.0 /usr/share/php

sudo ln -s /usr/share/php/jpgraph-4.0.0/src /var/www/jpgraph

Nun sollten Sie das erste JPGraph-Beispiel anzeigen können (- falls nicht, siehe Fehlerbehebung im nächsten Abschnitt). Öffnen Sie die Seite localhost/jpgraph/Examples/example2.php:

Der PHP-Quellcode des obigen Beispiels sieht so aus (example2.php) :

<?php // content="text/plain; charset=utf-8"require_once ('jpgraph/jpgraph.php');require_once ('jpgraph/jpgraph_line.php');

// Some (random) data$ydata = array(11,3,8,12,5,1,9,13,5,7);

// Size of the overall graph$width=350;$height=250;

// Create the graph and set a scale.// These two calls are always required


$graph = new Graph($width,$height);$graph->SetScale('intlin');

// Setup margin and titles$graph->SetMargin(40,20,20,40);$graph->title->Set('Calls per operator');$graph->subtitle->Set('(March 12, 2008)');$graph->xaxis->title->Set('Operator');$graph->yaxis->title->Set('# of calls');

// Create the linear plot$lineplot=new LinePlot($ydata);

// Add the plot to the graph$graph->Add($lineplot);

// Display the graph$graph->Stroke();?>

Behebung des Fehlers 25128

Um den Fehler zu beheben, führen Sie folgende Anweisungen aus:

cd /usr/share/php/jpgraph-4.0.0/src

sudo cp gd_image.inc.php gd_image.inc.php.ORIG

sudo leafpad gd_image.inc.php

Finden Sie im Editor die Funktion SetAntiAliasing() und kommentieren Sie die angegebene Zeile aus:

Speichern Sie und schliessen Sie den Editor. Nun sollte das Beispiel funktionieren.


6.2 Messdaten veröffentlichen

Projekt "Messdaten anzeigen"

Zweck: Die Messdaten des MCP3008 AD-Wandlers sollen in einer Datei gespeichert und auf einer Webseite grafisch dargestellt werden.

Lösungsprinzip: Ein Python-Programm liest die Daten des MCP3008 ein und speichert sie fortlaufend in einer Datei (/tmp/data.txt). Ein PHP-Skript liest diese Datei und zeigt sie mit Hilfe von JPGraph als Diagramm an.

Aufbau und benötige Bauteile: Wir verwenden den gleichen Schaltungsaufbau mit dem Drehregler und dem MCP3008 wie weiter oben:

Python-Programm (mcp3008_write_file.py):

import RPi.GPIO as GPIOimport timeimport osimport datetime


def readData(channel): # wie oben...# end readData()

# Pin-Belegung:clk = 18dout = 23din = 24cs = 25

GPIO.setup(clk, GPIO.OUT)GPIO.setup(cs, GPIO.OUT)GPIO.setup(din, GPIO.OUT)GPIO.setup(dout, GPIO.IN)


print ("Strg+C beendet das Programm")try: while True: # Datei zum Anhaengen oeffnen (Append): outfile = open("/tmp/data.txt",'a'); potValue = readData(0) # t = datetime.datetime.strftime(datetime.datetime.now(),"%Y-%m-%d %H:%M:%S"); outfile.write(str(potValue) +"\n") outfile.close() time.sleep(1)except KeyboardInterrupt: GPIO.cleanup()

PHP-Skript (/var/www/showdata.php) - man beachte die Ähnlichkeit zum obigen JPGraph-Beispiel example2.php:

<?php // content="text/plain; charset=utf-8"require_once ('jpgraph/jpgraph.php');require_once ('jpgraph/jpgraph_line.php');

// Datenfile in Array lesen:$ydata = file("/tmp/data.txt");// Werte in int-Zahlen umwandeln (waren Strings):$ydata = array_map('intval',$ydata);

// Size of the overall graph$width=350;$height=250;

// Create the graph and set a scale.// These two calls are always required$graph = new Graph($width,$height);$graph->SetScale('intlin');

// Setup margin and titles$graph->SetMargin(40,20,20,40);$graph->title->Set('Raspi Messdaten');$graph->xaxis->title->Set('Zeit [s]');$graph->yaxis->title->Set('Messwert');

// Create the linear plot$lineplot=new LinePlot($ydata);

// Add the plot to the graph$graph->Add($lineplot);

// Display the graph$graph->Stroke();?>

Dieses Diagramm kann übrigens fortlaufend aktualisiert werden (mit Reload im Browser), während das Python-Programm läuft und Daten sammelt. Dies ist möglich, weil das Python-Programm die Datei immer nur kurz zum Schreiben öffnet und sie somit nicht über längere Zeit sperrt.


6.3 Raspi fernsteuern

Projekt "Ferngesteuerte LED"

Zweck: Durch eine Checkbox auf einer Webseite soll eine LED ein- und ausgeschaltet werden können.

Lösungsprinzip: Die Website besteht aus einem einfachen Formular mit einer Checkbox. Durch Klick aufdie Checkbox wird das Formular an sich selbst geschickt. Dabei wird eine leere Datei (/tmp/checkboxon.txt) erzeugt, falls die Checkbox eingeschaltet ist, andernfalls wird diese Datei gelöscht. Ein Python-Programm prüft in einer Endlosschleife, ob die Datei existiert, und schaltet je nachdem die LED ein bzw. aus.

Aufbau und benötige Bauteile: Die LED wird via 220 Ohm Widerstand mit dem GPIO-Port 25 verbunden(wie Projekt "LED Blinker" weiter oben):


PHP-Skript (/var/www/checkboxfile.php):

<?php error_reporting(E_ALL);$value = 'off';if (isset($_GET["myCheckbox"])) { $value = $_GET["myCheckbox"];}if ($value=='on') { // erzeuge (leeres) File: touch("/tmp/checkboxon.txt");} else { // lösche File: unlink("/tmp/checkboxon.txt");}?><head></head><body> <h1>Turn LED on/off and have fun :-)</h1> <form id="myForm" method="get" action="checkboxfile.php"> <input type="checkbox" name="myCheckbox" onclick="document.getElementById('myForm').submit()" <?php if ($value=="on") { echo ' checked'; } ?> /> </form></body>

Python-Programm (led_einaus_file.py):

import RPi.GPIO as GPIOimport timeimport os

GPIO.setmode(GPIO.BCM)GPIO.setup(25, GPIO.OUT)print ("Strg+C beendet das Programm")try: while True: if (os.path.exists("/tmp/checkboxon.txt")): GPIO.output(25, 1) else: GPIO.output(25, 0) time.sleep(0.1)except KeyboardInterrupt: GPIO.cleanup()


Raspberry Pi (Raspi) - bol.libol.li/raspi/Skript Raspi.pdf · Beim ersten Booten meldet sich das...

Documents

Transcript of Raspberry Pi (Raspi) - bol.libol.li/raspi/Skript Raspi.pdf · Beim ersten Booten meldet sich das...