close

Anmelden

Neues Passwort anfordern?

Anmeldung mit OpenID

Abteilung Schule + Wohnen Schulferien und schulfreie Tage

EinbettenHerunterladen
NERKA
Noch eine Raspberry Kurzanleitung
Alfred H. Gitter, 9. 11. 2014
Vorbemerkung
Die vorliegende Schrift bezieht sich auf das Raspberry Pi Modell B, Revision 2, im folgenden mit
Π abgekürzt (Π ist der griechische Großbuchstabe Pi). Vorausgesetzt wird das Wissen der Wikipedia-Seite über den Π und Kenntnis der Programmiersprache Python.
Alle Angaben erfolgen ohne Gewähr für Neuheit, Richtig- oder Vollständigkeit. Die Anleitung
enthält eigene Abbildungen, die ohne künstlerischen Anspruch das Verständnis erleichtern sollen.
Die Umsetzung der hier beschriebenen Experimente erfolgt ausdrücklich auf eigenes Risiko.
Rechts- und Schadenersatzansprüche sind daher ausgeschlossen. Für die Inhalte fremder Internetseiten, auf die verwiesen wird, sind ausschließlich die Betreiber dieser Seiten verantwortlich.
© by Prof. Dr. Alfred H. Gitter, Jena (2014)
1
Inhalt
Vorbemerkung..................................................................................................................................1
Hardware.......................................................................................................................3
Gehäuse............................................................................................................................................3
Energieversorgung...........................................................................................................................3
Bild und Ton....................................................................................................................................3
Tastatur und Maus............................................................................................................................3
LAN und WLAN.............................................................................................................................4
Speicherkarte...................................................................................................................................4
Kontroll-LEDs.................................................................................................................................4
Digitale Anschlusspunkte..............................................................................................5
GPIOs...............................................................................................................................................5
Stiftleiste P1.....................................................................................................................................5
Software.........................................................................................................................6
Betriebssystem.................................................................................................................................6
Paketverwaltung...............................................................................................................................6
Farben..............................................................................................................................................7
Schallausgabe...................................................................................................................................7
Editoren und Browser......................................................................................................................7
Weitere Programme.........................................................................................................................8
Mathematica..................................................................................................................9
Kurze Beschreibung.........................................................................................................................9
Beispiel............................................................................................................................................9
Aufgabe 1.......................................................................................................................................10
Programmieren mit Python..........................................................................................11
Erstes Programm: "Hallo!"............................................................................................................11
Rundung.........................................................................................................................................12
GUI mit Python, Modul Tkinter....................................................................................................12
Periodische Prozeduraufrufe mit Tkinter.......................................................................................14
Experiment 1: LED ein- und ausschalten....................................................................15
Schaltung 1 (Standard-LED mit Vorwiderstand)...........................................................................15
Steuerung der GPIOs von der Konsole..........................................................................................15
Strom und Durchflussspannung der LED......................................................................................16
Blinken mit Python-Programm......................................................................................................17
Dimmen durch Pulsweitenmodulation...........................................................................................18
Experiment 2: Temperatursensor auslesen..................................................................20
Schaltung 2 (Temperatursensor DS18S20)....................................................................................20
Temperaturmessung von der Konsole............................................................................................21
Temperaturmessung mit Python-Programm..................................................................................22
Aufgabe 2.......................................................................................................................................23
Aufgabe 3.......................................................................................................................................23
Aufgabe 4.......................................................................................................................................24
2
Hardware
Gehäuse
Ein Gehäuse für den Π (im Bild nicht gezeigt)
kann man kaufen oder selbst basteln. Bei billigen
Gehäusen sind die Löcher für die Buchsen des Π
mitunter nicht ganz passend und man muss
gegebenenfalls die Gehäuselöcher mit einer
kleinen Feile aufweiten.
Energieversorgung
Die Energieversorgung des Π erfolgt über eine
(im Bild des Π nach rechts oben zeigende, metallische) Mikro-USB-Buchse mit einem Netzgerät
(im Bild oben rechts gezeigt), das eine Ausgangsspannung von genau 5 V und einen Strom von mindestens 700 mA (es darf mehr sein) liefert. Mit
Netzgeräten nicht ausreichender Leistung arbeitet der Π nicht oder fehlerhaft, insbesondere beim
Anschluss weiterer Geräte über die USB-Buchsen (siehe unten). Für einen mobilen Einsatz des Π
kann ein geladener Akku an die Mikro-USB-Buchse angesteckt werden. Im Auto kann der Π über
eine Bordspannungssteckdose und einen Adapter, der 5 V Spannung erzeugt, betrieben werden.
Bild und Ton
Die Abbildung rechts zeigt in der Mitte den Π und oben links ein Kabel zum Anschluss eines Monitors. Der Monitor wird in der Regel über die HDMI-Buchse des Π angeschlossen. Der Monitor
sollte eine HDMI- oder DVI-Eingangsbuchse besitzen und wird mit dem entsprechenden Kabel
(zum Beispiel einem HDMI-DVI-Kabel) angeschlossen. HDMI und DVI übertragen Bild und Ton
in sehr guter Qualität. Es ist daher praktisch, wenn der Monitor Lautsprecher enthält.
Ältere Monitore mit VGA-Buchse können über einen Adapter angeschlossen werden. Es ist auch
möglich, das Bild über die (im Bild des Π nach rechts unten zeigende, gelbe) Cinch-Buchse auf
einem Bildschirm mit Composite Video Eingang zu zeigen. Das Tonsignal kann über die (im Bild
des Π nach rechts unten zeigenden, blauen) Buchse für Klinkenstecker (Stereo, 3,5 mm
Durchmesser) mit einem Kopfhörer gehört werden.
Tastatur und Maus
Als Dateneingabegeräte dienen Tastatur und Maus, die über die beiden (im Bild des Π nach links
unten zeigenden, metallischen) USB-Buchsen des Π angeschlossen werden. Leider hat der Π nur
zwei USB-Buchsen. Wenn man eine Funktastatur mit dazu gehöriger drahtloser Maus (das Bild
zeigt unter dem Π ein besonders kleines Exemplar) mit einem einzelnen USB-Stick (wie im Bild
gezeigt) an eine USB-Buchse anschließt, bleibt die zweite USB-Buchse zur weiteren Verwendung
frei. Da die Energieversorgung der USB-Buchsen beim Π schwach ist, sollten die dort angeschlos3
senen Geräte (also auch Tastatur und Maus) möglichst wenig Strom brauchen. Bei zu hohem Stromverbrauch kann es zu Fehlfunktionen (zum Beispiel der Tastatur) kommen.
LAN und WLAN
Die Verbindung zu einem LAN und damit in der Regel auch zum Internet ist über eine (im Bild des
Π nach links zeigende, metallische)e RJ-45-Buchse möglich, in die ein (im Bild links vom Π
gezeigtes) Patchkabel (auch Ethernet-Kabel oder LAN-Kabel genannt) mit 8-poligen RJ-45-Stecker
passt.
Wenn eine USB-Buchse frei ist, kann dort eine WLAN-Antenne mit einem USB-Stick (im Bild
rechts unten gezeigt) angeschlossen werden. Allerdings sollte man sich vorher, zum Beispiel im
Internet, darüber informieren, welche WLAN-USB-Sticks vom Π erkannt werden und möglichst
wenig Strom brauchen (siehe oben). Die Konfiguration des WLAN-Empfangs kann mit einem
Hilsprogramm geschehen, das im Desktop durch Doppelklick auf WIFI Config gestartet wird.
Speicherkarte
Als Datenspeicher dient beim Π eine SD- oder SDHC-Karte, möglichst eine SDHC-Karte mit einer
Speicherkapazität von mindestens 4 GB. Sie sollte hohe Lese- und Schreibgeschwindigkeiten
haben. Abhängig von der Schreibgeschwindigkeit werden SD- und SDHC-Karten in Klassen
eingeteilt; man sollte eine Karte der Klasse 4 (Schreibgeschwindigkeit  4 Mbyte/s) oder höher
verwenden und auch auf eine hohe Lesegeschwindigkeit achten. Die Karte wird in die
entsprechende Buchse, den SD-Slot (im Bild nicht zu sehen, da er unter der Platine liegt),
eingeschoben, der sich auf der Seite des Π befindet, die gegenüber der USB-Buchsen liegt. Auch
hier sollte man sich vorher, zum Beispiel im Internet, darüber informieren, welche SD- oder SDHCKarten vom Π erkannt werden.
Kontroll-LEDs
Die Tätigkeit der Hardware wird durch fünf kleine LEDs in einer Ecke des Π sichtbar gemacht.
Kontroll-LEDs im Raspberry Pi, Modell B, Revision 2 ( Π )
Name
Farbe
Beschreibung
ACT
grün
blinkt beim Zugriff auf die SD-Karte, ist auch von Programmen schaltbar
PWR
rot
leuchtet, wenn Versorgungsspannung (auf der 3,3 V Leitung) anliegt
FDX
grün
leuchtet, wenn eine Full Duplex-Verbindung zum LAN-Netzwerk besteht
LNK
grün
leuchtet bei Netzwerkverbindung, blinkt bei Datenverkehr über das LAN
100
gelb
leuchtet bei einer LAN-Übertragungsrate von 100 MBit/s (Fast Ethernet)
4
Digitale Anschlusspunkte
GPIOs
Der Π stellt elektrische Anschlusspunkte zur Verfügung, über die digitale Daten (logisch: 0 oder 1)
eingegeben oder ausgegeben werden können. Sie heißen GPIOs (General Purpose Input/Output).
Bei den GPIOs entspricht 0 V einer logischen 0 und 3,3 V einer logischen 1.
Die GPIO sind sehr empfindlich und können durch Überspannung (zum Beispiel 5 V) leicht zerstört werden. Insbesondere sollte man beachten, dass das 5V-Potential des Π nicht auf die GPIOs
gelegt werden darf.
Es gibt beim Π keine Anschlusspunkte zur Ein- oder Ausgabe von analogen elektrischen Signalen.
Stiftleiste P1
Elektrische Anschlusspunkte sind beim Π in als
doppelreihige, 26-polige Stiftleiste namens P1
ausgeführt (siehe Abbildung rechts).
P1
Zweireihige Stiftleiste, P1 genannt, für die
Ein- und Ausgabe digitaler Daten über 26
GPIO-Pins (Stifte). Obere Reihe (rot ge
zeichnet): 13 Pins, von links nach rechts
geradzahlig nummeriert von 2 bis 26.
Unterer Reihe (blau gezeichnet): 13 Pins,
von links nach rechts ungeradzahlig
nummeriert von 1 bis 25. Der Abstand der
Pins beträgt jeweils 2,54 mm (1/10 Zoll).
17 Pins der Stiftleiste sind GPIOs, die anderen Pins sind mit der Signalmasse (GND) oder einem
positiven elektrischen Potential (3,3 V oder 5 V) verbunden.
Pin
Pin
2
4
6
5V
5V
GND
1
3
5
3,3 V
8
10
12
14
16
18
20
22
24
26
GPIO GPIO GPIO
GPIO GPIO
GPIO GPIO GPIO
GND
GND
14
15
18
23
24
25
8
7
7
9
11
13
15
17
19
21
23
25
GPIO GPIO GPIO
GPIO GPIO GPIO
GPIO GPIO GPIO
GND
3,3 V
GND
2
3
4
17
27
22
10
9
11
Pin-Belegung der Stiftleiste P1
5
Software
Betriebssystem
Neue SD-Karten mit mehr als 2 GB Speicherkapazität sind in der Regel bereits mit dem Dateisystem FAT32 formatiert. Falls eine Neuformatierung notwendig ist, kann dies unter Linux mit dem
Programm GParted geschehen. Wir gehen im Folgenden von einer formatierten SD-Karte aus.
Es gibt verschiedene Betriebssysteme, die auf dem Π laufen. Am einfachsten ist die Installation
über die New Out Of Box Software (oder kurz und liebevoll NOOBS genannt). Der Download-Link
und eine leicht verständliche, englischsprachige Anleitung findet sich auf der Webseite
http://www.raspberrypi.org/downloads
Das Ergebnis sollte ein fertige SD- oder SDHC-Karte sein. Diese schiebt man nun in den Π und
schließt Monitor, Maus und Tastatur an, gegebenenfalls noch LAN. Nun startet man den Π, indem
man einfach die Energieversorgung anschließt. Es zeigt sich auf dem Monitor als Startsymbol die
vertraute Himbeere, das Symbol des Π. Anschließend kann man zwischen sechs verschiedenen
Betriebssystemen wählen. Am einfachsten ist die Installation von Raspbian, welches dann bereits
viele nützliche Programme und eine grafische Oberfläche hat, die sich intuitiv bedienen lässt.
Statt mit NOOBS kann das Betriebssystem Raspbian auch direkt auf der Speicherkarte installiert
werden. Dazu läd man von der oben genannten Webseite (wo auch NOOBS angeboten wird) durch
Klicken auf "RASPBIAN Donload ZIP" eine komprimierte (gepackte) neue Version des Betriebssystems und dekomprimiert (entpackt) es. Dann istalliert man es unter Linux, wie in der Anleitung
auf der Webseite www.raspberrypi.org/documentation/installation/installing-images/linux.md beschrieben.
Im folgenden gehen wir davon aus, dass Raspbian installiert wurde. Wenn vor dem Systemstart das
LAN-Kabel angeschlossen wurde, sollte auch bereits eine Ethernet-Verbindung (zum Internet)
stehen.
Paketverwaltung
Die Programme, die mit dem Betriebssystem Raspbian benutzt werden können, sind in Form von
"Paketen" gespeichert, die von einer Paketverwaltung namens APT verwaltet werden. Die für
Raspbian verfügbaren Pakete werden in einer Datenbank geführt, die auf dem Rechner gespeichert
ist. Um diese Datenbank auf einem neuen Stand zu halten, sollte man von Zeit zu Zeit folgenden
Befehl in einer Konsole (auch Kommandozeile oder Terminal genannt) eingeben:
sudo apt-get update
Um die auf dem Rechner verfügbaren ("installierten") Pakete auf den neuesten Stand zu bringen,
gibt man folgenden Befehl in die Konsole ein:
sudo apt-get upgrade
Um ein Programm mit dem Namen prog , das über die Paketverwaltung verfügbar ist (Beispiele,
siehe unten), zu installieren, gibt man in der Konsole den Befehl
6
sudo apt-get install prog
ein. Wenn dies Programm nicht mehr gebraucht wird, kann man es mit dem Befehl
sudo apt-get purge prog
vollständig (einschließlich der Konfigurationsdateien) wieder entfernen.
Farben
Die graphische Oberfläche X11 (X Window System) des Π kann bestimmte Farbnamen erkennen,
so dass diese Farben zum Beispiel in einem Programm benannt werden können (siehe Beispiel
unten, Abschnitt GUI mit Python, Modul Tkinter). Die beim Π verfügbaren Farbnamen sind in der
Datei /usr/share/x11/rgb.txt aufgelistet.
Schallausgabe
Die Ausgabe des Tonsignals (Audio) kann entweder analog über den blauen 3,5mm-Klinenstecker
oder digital über die HDMI-Buchse erfolgen. Die Auswahl des Audioausgangs geschieht in Regel
automatisch durch das Betriebssystem, aber das tut es nicht immer so wie gewünscht. Um die
Auswahl des Audioausgangs zu prüfen, gibt man in der Konsole den Befehl
sudo amixer cget numid=3
ein und schaut den Wert der Variablen values an (0 = automatische Auswahl, 1 = analoger, 2 = digitaler Ausgang). Um das Tonsignal auf den analogen Ausgang zu legen, kann man den Befehl
sudo amixer cset numid=3 1
verwenden. Für den digitalen Ausgang nimmt man entsprechend den Konsolenbefehl
sudo amixer cset numid=3 2
und die automatische Wahl des Audioausgangs wird mit
sudo amixer cset numid=3 0
hergestellt. Die Signalstärke des Audioausgangs (Lautstärke) kann mit einem Hilfsprogramm verändert werden, das mit dem Konsolenbefehl
alsamixer
aufgerufen wird. Wurde ein Verstärker am Audioausgang angeschlossen, ist es besser, dort die
Lautstärke einzustellen.
Editoren und Browser
Raspbian enthält die einfachen Texteditoren Leafpad und Nano . Leafpad hat im Gegensatz zu
Nano eine graphische Benutzeroberfläche und erlaubt das Schreiben von Texten ohne anspruchsvolle Formatierungen. Nano wird typischerweise in der Konsole aufgerufen um ohne grafische
Konfigurationsdateien zu verändern.
7
Auch Browser, zum Beispiel Epiphany, NetSurf oder Midori , stehen zur Verfügung. Statt Midori ist
seit September 2014 Epiphany der bevorzugte Browser für den Π , welcher leistungsfähiger ist und
auch Videos abspielen kann. Falls jedoch Midori gewünscht und nicht bereits vorhanden ist, kann
man es über die Paketverwaltung (siehe oben) als Programm midori installieren.
Das Laden von Webseiten aus dem Internet ist aber aufgrund der schwachen Leistung des Π
langsam. Midori arbeitet schneller, wenn man unter Edit (Menü) > Preferences (Einstellungen) >
Behaviour (Verhalten) ( > Features) das automatische Laden von Bildern und die Ausführung von
Netscape plugins abstellt und unter Privacy (Privatsphäre) ( > Web Cookies) das Speichern von
Internet-Daten auf dem Π erlaubt. Es kann auch nützlich sein, unter General > Startup
(Programmstart) > When Midori starts (Beim Starten von Midori:) die am häufigsten besuchte
Webseite als Startseite festzulegen.
Weitere Programme
Zur graphischen Darstellung von Messdaten oder mathematischen Funktionen gibt es das Programm gnuplot, das mit Textanweisungen von der Konsole oder aus einem anderen Programm
heraus gesteuert wird. Wir installieren es mit folgendem Befehl in der Konsole:
sudo apt-get install gnuplot-x11
Danach testen wir das Programm in der Konsole mit den Befehlen
gnuplot
plot x**3
quit
Weitere Information findet man auf der gnuplot homepage .
Für Textverarbeitung kann man Abiword benutzen. Es kann über die Paketverwaltung (siehe oben)
als Programm abiword installiert werden. Als Tabellenkalkulationsprogramm steht über die Paketverwaltung gnumeric zur Verfügung. Ein Programm, das den Bildschirminhalt (oder einen Teil
davon) als Bild (Screenshot) speichert, ist shutter .
Es gibt auch zahlreiche Spiele für den Π , die mit der Paketverwaltung (siehe oben) geladen werden
können. Beispiele: frozen-bubble , gmchess (chinesisches Schach), knights (großer Speicherbedarf)
und gnuchess (Schachbrett und "Engine"), tris (entspricht Tetris).
8
Mathematica
Kurze Beschreibung
Mit dem Betriebssystem Raspbian wird Mathematica bereit gestellt, ein mächtiges Werkzeug für
computergestütztes wissenschaftliches Rechnen (Scientific Computing). Es verfügt über starke
Befehle, mit denen schwierige Probleme schnell gelöst und graphisch dargestellt werden können.
In Mathematica werden Dokumente angelegt und bearbeitet, die formatierten Text und Bilder
enthalten können und insbesondere Berechnungen durchführen können. Ein solches Dokument
heißt in Mathematica ein Notebook und wird in einer Datei mit der Endung .nb gespeichert.
Jedes Notebook besteht aus nacheinander oder ineinander verschachtelt angeordneten Abschnitten.
Ein solcher Abschnitt heißt Cell. Die Dokumentenstruktur, das heisst der Aufbau aus Cells, wird am
rechten Rand des Dokuments gezeigt. Ausgeblendete Cells können bei Bedarf eingeblendet werden.
Mathematica besteht aus einem Kernel genannten Kernprogramm, das Berechnungen durchführt,
und einer Benutzeroberfläche, dem Front End. Das Front End verfügt über die übliche
Menüsteuerung. Spezielle aufrufbare Fenster (Palettes) erlauben das Einfügen von Sonderzeichen.
Nach Aufruf eines neuen Notebooks (Doppelklick auf das Mathematica-Symbol des Desktops) wird
eine Input Cell bereitgestellt, in die man Befehlszeilen schreibt. Drückt man Shift-Enter, wird das
Programm abgearbeitet und das Ergebnis in einer automatisch erzeugten Output Cell ausgegeben.
Allerdings ist die Ausführung vom des umfangreichen Programms Mathematica auf dem Raspberry
langsam.
Beispiel
Wir tippen folgende Zeilen in das Mathematica-Notebook:
t1 = {{-2, 10}, {0, 3}, {2, 2}}
g1 = ListPlot[t1, Prolog -> AbsolutePointSize[3]]
t2 = Table[{n, n*n - 3 n + 3}, {n, -3, 3, 0.1}]
g2 = ListPlot[t2, PlotJoined -> True]
g3 = Show[g2, g1]
Dann starten wir die Berechnung (Shift-Enter)
und erhalten das Ergebnis in einer Output Cell.
Die erste Befehlszeile erzeugt eine Tabelle mit
Messwertpaaren. Die zweite Zeile zeichnet diese
Tabelle (Liste) als Punkte im Koordinatensystem.
Die dritte Zeile tabelliert die Funktion f(n) = n2 –
3 · n +3, wobei der Definitionsbereich das
Intervall [-3, 3] ist. Die vierte Zeile zeichnet die
Tabelle (Liste) der Funktion und verbindet die
9
Punkte. Die fünfte Zeile zeichnet beide Einzelgraphiken in einer neuen Graphik (g3), siehe
Abbildung rechts, wobei der Bereich der x-Achse von der erstgenannten Einzelgraphik (g2) stammt.
Nun klicken wir mit der rechten Maustaste auf die Graphik g3, wählen Save Graphic As … , und
speichern die Graphik im Format png unter dem Namen math_1.png im Verzeichnis /home/pi/P .
Ein Dopppelklick auf die Datei math_1.png zeigt diese im Standard-Bildbetrachtungsprogramm.
Aufgabe 1
Tabellieren und zeichnen Sie die Funktion √(n!), das heisst: Wurzel aus n Fakultät, im Definitionsbereich [1,10]. Die Wurzel von x schreibt man in Mathematica als Sqrt[x] .
10
Programmieren mit Python
Erstes Programm: "Hallo!"
Python ist die Programmiersprache, welcher der Π seinen Namen verdankt. Als erstes PythonProgramm schreiben wir mit dem Texteditor
#!/usr/bin/python
print("Hallo!")
Die erste Zeile weist das Betriebssystem an, die Datei, die unseren Python-Code enthält, mit dem
Programm python auszuführen, welches im Ordner /usr/bin liegt. Die zweite Zeile soll die Zeichenkette Hallo! auf dem Monitor ausgeben. Wir speichern das Programm im Ordner P unter dem
Namen hallo.py . Dann öffnen wir eine Konsole, bewegen uns mit dem Befehl
cd P
in den Ordner P und geben den Konsolenbefehl
chmod a+x hallo.py
ein, welcher die Erlaubnis zur Ausführung (englisch: execution) der Datei hallo.py erteilt. Mit
./hallo.py
beginnt die Ausführung und in der Konsole sollte der Text Hallo! ausgegeben werden.
Wir erweitern das obige Programm nun derart, dass vor dem Hallo! angezeigt wird, welche PythonVersion installiert ist. Dies ist bedeutsam, weil die Syntax mit Python 3 deutlich verändert wurde.
#!/usr/bin/python
import sys # bindet Modul sys mittels einer import-Anweisung ein
print("\nPython Version") # schreibt Zeichenkette Python Version
print(sys.version) # schreibt die aktuelle Python-Versionsnummer
print("\nHallo!\n") # schreibt Zeichenkette Hallo, \n neue Zeile
Wir führen das Programm in gleicher Weise aus wie zuvor.
Die Anweisung import sys bindet das Modul sys aus der Standardbibliothek ein. Dies Modul stellt
Informationen über den Python-Interpreter zur Verfügung. Wenn man mit mathematischen Funktionen arbeiten will, muss man entsprechend das Modul math einbinden.
# leitet einen einzeiligen Kommentar in Python ein (entspricht // in der Programmiersprache C).
Mit der Zeichenfolge \n erzeugt man ein Steuerzeichen, welches die Textausgabe in eine neue Zeile
weiterrücken lässt. Damit wird die Textausgabe, insbesondere in der Konsole, lesbarer gestaltet.
Allgemein werden Steuerzeichen oft über sogenannte Escape-Sequenzen dargestellt, die im
Quelltext eines Computerprogramms mit einem Backslash ( \ ) eingeleitet werden.
11
Rundung
Führen Sie folgendes Python-Programm in gewohnter Weise aus.
#!/usr/bin/python
a=round(3.453,2)
b=round(13.001,2)
print(a)
print(b)
text1 = "a = %5.2f Grad C" % a
text2 = "b = %5.2f Grad C" % b
print(text1)
print(text2)
Die Funktion round rundet die Zahl, die im ersten Argument übergeben wird mit der Anzahl an
Nachkommastellen (hier: 2), die im zweiten Argument übergeben wird.
Obiges Beispiel zeigt auch, wie man eine bestimmte Formatierung bei der Ausgabe einer Zahl
mittels print zu erreicht. Die auszugebende Zahl wird in der Zeichenkette durch %format ersetzt,
wobei format die Formatierung angibt. 5.2f bedeutet, dass 5 Stellen einer Gleitkommazahl (float)
ausgeben werden, einschliesslich Dezimalpunkt und zweier Nachkommastellen. Vor dem Dezimalpunkt können also höchstens noch zwei Stellen stehen. Mit einer solchen Formatierung können
Zahen in einer Spalte untereinander ausgegeben werden.
GUI mit Python, Modul Tkinter
In der Programmiersprache Python 2 ist das Modul Tkinter, in Python 3 entsprechend tkinter (kleingeschrieben) enthalten. Damit kann man eine grafische Benutzeroberfläche, kurz GUI (englisch:
Graphical User Interface) erstellen. Grafische Elemente, Widgets genannt, sind Window (Fenster)
und darin enthalten, zum Beispiel Label (Feld mit formatiertem Text) und Button (beschriftete
Schaltfläche, auf der ein Mausklick die Ausführung einer Prozedur auslöst). Die Aktionen eines
Fenster-Objekts werden mit der Methode mainloop gestartet.
Als Beispiel schreiben wir folgendes Programm:
#!/usr/bin/python
# -*- coding: utf-8 -*from Tkinter import * # bindet alle Teile des Moduls TKinter ein
def minus(): # Ereignisverarbeitungsprozedur (nach Klick auf b1)
l.config(text=str("nimmer!")) # text ist Attribut von Label l
def null(): # Ereignisverarbeitungsprozedur (nach Klick auf b2)
12
l.config(text=str(1949)) # str() wandelt Zahl in Zeichenkette
def plus(): # Ereignisverarbeitungsprozedur (nach Klick auf b3)
wort=l.cget('text') # weist den Wert des Attributs text zu
if (wort=="immer") or (wort=="nimmer!"): # keine Zahl in wort
l.config(text="immer") # config ist Methode von l
else: # wort enthält keine Zeichenkette, sondern eine Zahl
zahl=int(wort) + 1 # int wandelt Zeichenkette in Zahl um
if (zahl>1990): # Den Sozialismus in seinem Lauf
zahl=1990 # halten weder Ochs noch Esel auf.
l.config(text=str(zahl)) # setzt Attributwert von text
w=Tk() # erzeugt ein window, in das widgets eingefügt werden
w.title('was zählt') # Titel, der oben im window gezeigt wird
w.geometry('245x125') # Breite mal Höhe vom window, Einheit: Pixel
l=Label(master=w, text='1949', bg='ivory', font=('FreeMono', 32))
l.place(x=5, y=5, width=235, height=80) # positioniert Label l
b1=Button(master=w, text='rückwärts', bg='tan', command=minus)
b1.place(x=5, y=90, width=75, height=30) # platziert button b1
b2=Button(master=w, text='Aufbau', bg='gold', command=null)
b2.place(x=85, y=90, width=75, height=30) # platziert button b2
b3=Button(master=w, text='vorwärts', bg='pink', command=plus)
b3.place(x=165, y=90, width=75, height=30) # platziert button b3
w.mainloop() # Endlosschleife zur Reaktion auf Ereignisse (events)
Die Zeile # -*- coding: utf-8 -*- gibt einen Zeichensatz vor, so dass auch Umlaute (ä, ö, ü) verwendet werden können. Wir speichern das Programm im Ordner P unter dem Namen gui.py , öffnen
eine Konsole, bewegen uns in den Ordner P und führen das Programm mit folgenden Befehlen aus:
chmod a+x gui.py
./gui.py
13
Periodische Prozeduraufrufe mit Tkinter
In Tkinter gibt es für widgets (zum Beispiel Label) die Methode after , welche nach einer bestimmten Zeit die Ausführung einer Prozedur (oder Funktion) veranlasst. Wenn die Methode after innerhalb dieser Prozedur steht, entsteht ein wiederholter Aufruf der Prozedur. Damit lassen sich periodisch ablaufende Prozeduren erstellen, ohne dass die Abarbeitung der mainloop unterbrochen wird.
Als Beispiel führen Sie bitte folgendes Python-Programm in gewohnter Weise aus.
#!/usr/bin/python
from Tkinter import *
zahl = 0
def inc():
global zahl
zahl = zahl + 1
l.config(text=str(zahl))
l.after(1000,inc)
w=Tk()
w.geometry('100x50')
l=Label(master=w, text='str(zahl)')
l.place(x=5, y=5, width=90, height=40)
inc()
w.mainloop()
In Tkinter sollte dagegen die Methode sleep (siehe unten) nicht verwendet werden, da damit die
Abarbeitung der mainloop unterbrochen wird. Das Programm reagiert dann nicht mehr auf
Eregnisse und nicht einmal die Größe des Fensters kann verändert werden.
14
Experiment 1: LED ein- und ausschalten
Schaltung 1 (Standard-LED mit Vorwiderstand)
Um mit einem GPIO eine Leuchtdiode an- und auszuschalten, kann
man folgender Weise vorgehen. Der
Leuchtdiodenschaltkreis besteht aus
330 Ω
der Reihenschaltung einer Leuchtdiode (Standard-LED) und eines
passenden Vorwiderstands R (zum
Pin 3
Pin 9
Beispiel 330 Ω oder 470 Ω). Die
von P1
von P1
Anode der Leuchtdiode (langes
GPIO 2
GND
Beinchen) wird mit GPIO 2 (Pin 3
der Stiftleiste P1) verbunden, die
Kathode (kurzes Beinchen) mit einem Ende des Widerstands. Das andere Ende des Widerstands
wird mit GND (Pin 9 von P1) verbunden.
Für den experimentellen Aufbau kann man zum
Beispiel ein 5-poliges Flachkabel an eine 5-polige
Buchsenleiste mit passendem Rastermaß (2,54
mm) löten und es (über angelötete Drähte mit
einem Durchmesser von 0,5 mm oder 0,6 mm)
mit einer Steckplatine verbinden.
Die Buchsenleiste wird auf die fünf Pins 1 bis 9
von P1 aufgesteckt und der Leuchtdiodenschaltkreis wird auf der Steckplatine aufgebaut
(siehe Bild rechts).
Mit einem Computerprogramm kann GPIO 2 als
Datenausgang geschaltet werden. Wenn das Programm eine logische 0 ausgibt, liegt 0 V an GPIO 2;
wenn es eine logische 1 ausgibt, liegt 3,3 V an GPIO 2 und die Leuchtdiode leuchtet. Am
einfachsten kann man die Steuerbefehle von einer Konsole (auch Kommandozeile oder Terminal
genannt) aus geben.
Steuerung der GPIOs von der Konsole
Wenn man die Konsole als normaler Nutzer öffnet, muss man zunächst Root-Zugriffsrechte
erlangen
sudo su
dann wechselt man mit dem Befehl cd in das Verzeichnis gpio
cd /sys/class/gpio
15
und schreibt 2 (die Nummer des GPIO, den wir benutzen wollen) in die Datei export .
echo 2 > export
Der Befehl echo schreibt die nachfolgende Zeichenkette (hier 2) auf den Monitor (Standardausgabe), wenn keine Umleitung erfolgt. Hier wird aber mit dem "größer als"-Zeichen > die
Ausgabe umgeleitet und in die Datei export geschrieben.
Dann wechselt man mit dem Befehl cd in das Verzeichnis gpio2 (das automatisch angelegt wurde),
cd gpio2
schreibt out in die Datei direction und 1 in die Datei value
echo out > direction
echo 1 > value
Die Leuchtdiode sollte nun leuchten, Um sie auszuschalten, schreibt man
echo 0 > value
Weiteres zu diesem Thema findet man im WWW zum Beispiel hier .
Strom und Durchflussspannung der LED
Wir ergänzen die Leuchtdiodenschaltung, indem wir zwischen Leuchtdiode und Vorwiderstand R
ein Amperemeter einfügen (Messbereich zwischen 5 mA und 20 mA). Wenn ein Multimeter
verwendet wird, sollte es vor Einfügung in den Schaltkreis auf Strommessung eingestellt sein.
Als Leuchtdiode soll zunächst eine rote Standard-LED dienen. Nach dem Einschalten der LED (wie
zuvor) fließt ein Strom Irot . Wir ersetzen die rote durch eine grüne Standard-LED und messen
wieder den Strom, Igrün , der durch die eingeschaltete LED fließt.
Der Spannungsabfall an der LED, die Durchflussspannung (Flussspannung, englisch: forward
voltage), ergibt nach dem Ohmschen Gesetz aus
Uf,rot = 3,3 V – R · Irot und Uf,grün = 3,3 V – R · Igrün .
Tragen Sie die gemessenen Ströme und berechneten Spannungen in folgende Tabelle ein.
I ( mA )
Uf ( V )
rote Standard-LED
grüne Standard-LED
Die Ströme liegen deutlich unterhalb von 16 mA, dem maximalen Strom, der durch einen GPIO
fließen darf. Der Gesamtstrom durch alle GPIOs sollte höchstens 50 mA betragen (siehe hier). Die
Ströme liegen erst recht unter dem Strom von 20 mA, für den Standard-LEDs ausgelegt sind.
Verschiedenfarbige LEDs enthalten unterschiedliches Halbleitermaterial. Man erkennt, dass die
Durchlassspannung der Standard-LEDs von deren Farbe abhängt. Je kurzwelliger das abgegebene
Licht ist, desto größer ist die Energie der Photonen und dies erfordert eine größere Energiedifferenz
16
(Bandabstand) im Halbleiter.
Außerdem steigt die Durchlassspannung mit dem Strom und fällt mit der Temperatur (um etwa
2mV / °C).
Blinken mit Python-Programm
Wir benutzen den gleichen Leuchtdiodenschaltkreis und schreiben folgendes Python-Programm.
#!/usr/bin/python
import RPi.GPIO as GPIO # importiere RPi.GPIO und nenne es GPIO
import time # importiere das Modul time (mit der Funktion sleep)
GPIO.setmode(GPIO.BCM) # benutze GPIO-Namen (statt Pin-Nummern)
g = 2 # speichere die Nummer des GPIO-Ausgangs in Variable g
GPIO.setup(g, GPIO.OUT) # setze GPIO g als Ausgang (OUT)
x = int(input("\nWie oft blinken? ")) # Tastatureingabe von x
text1="\nDie LED sollte jetzt "+str(x)+"-mal blinken.\n"
print(text1) # (ab Python-Version 3 ist print eine Funktion)
n = 0 # speichere, wie oft die LED geblinkt hat, in Variable n
try: # Folgendes normalerweise, ohne Druecken von Ctrl-C
for i in range(0,x): # Schleife, die x mal durchlaufen wird
GPIO.output(g,GPIO.HIGH) # schalte den GPIO g ein (HIGH)
n=i+1 # es hat wieder geblinkt
time.sleep(0.2) # warte 0,2 Sekunden
GPIO.output(g,GPIO.LOW) # schalte den GPIO g aus (LOW)
time.sleep(0.3) # warte 0,3 Sekunden
except KeyboardInterrupt: # Folgendes nach Druecken von Ctrl-C
GPIO.output(g,GPIO.LOW) # schalte den GPIO g aus (LOW)
text2="\nAbbruch durch Ctrl-C nach "+str(n)+"-mal blinken.\n"
print(text2) # (ab Python-Version 3 ist print eine Funktion)
GPIO.cleanup() # setzt GPIOs in den Standard-Zustand zurueck
Wir speichern das Programm wird im Ordner P unter dem Namen blink.py , öffnen eine Konsole,
bewegen uns in den Ordner P und geben die Konsolenbefehle
chmod a+x blink.py
sudo ./blink.py
17
ein, worauf gefragt wird, wie oft die LED blinken soll. Wir geben über die Tastatur eine Zahl, zum
Beispiel 10 , ein. Dann erscheint der Text Die LED sollte jetzt 10 mal blinken.
und die LED sollte zehnmal aufleuchten. Um das Programm nochmal zu starten, genügt
sudo ./blink.py
Die Anweisung import import RPi.GPIO as GPIO bindet das Modul RPi.GPIO ein. Damit kann
man in Python-Programmen die GPIOs ansteuern, ähnlich wie mit WiringPi in C- oder C++Programmen. Der Zusatz as GPIO bewirkt, dass der Name des Moduls von RPi.GPIO in (das
kürzerere) GPIO geändert wird, um im Folgenden Schreibarbeit einzusparen.
Man sollte keine deutschen Sonderzeichen, wie zum den Umlaut ü, verwenden. Daher wird im
Kommentar der letzten Programmzeile zurueck statt zurück geschrieben.
Dimmen durch Pulsweitenmodulation
Wir benutzen wieder den gleichen LED-Schaltkreis und schreiben folgendes Python-Programm.
#!/usr/bin/python
import RPi.GPIO as GPIO
import time
#
def leuchte():
global f
po.ChangeFrequency(f)
for i in range(0,101,25):
po.ChangeDutyCycle(i)
print("f = %3.0f Hz, Tastgrad = %4.2f" % (f,float(i)/100))
time.sleep(5)
#
g = 2
f=10
GPIO.setmode(GPIO.BCM)
GPIO.setup(g, GPIO.OUT)
po=GPIO.PWM(g, f)
po.start(0)
leuchte()
#
18
f=100
leuchte()
#
po.stop()
GPIO.cleanup()
Nach dem Speichern im Ordner P, unter dem Namen pwm.py , öffnen wir eine Konsole, bewegen
uns in den Ordner P und starten die Programmausführung mit den Konsolenbefehlen
chmod a+x pwm.py
sudo ./pwm.py
Die LED wird nun mit einem pulsbreitenmodulierten (PWM) periodischen Rechteck-Signal betrieben, welches vom Modul RPi.GPIO ausgegeben wird. Das PWM Rechteck-Signal besteht aus
einem Wechsel von logischer 0 ( 0 V ) und logischer 1 ( 3,3 V ) mit Zeitdauern von taus beziehungsweise tein . Die Periodendauer des Signals ist T = ( tein + taus ) und die Grundfrequenz f ergibt sich
damit als f = 1 / T = 1 / ( tein + taus ) . Der Tastgrad (englisch: duty cycle) ist tein / ( tein + taus ) .
Man kann die Signalform betrachten, indem der Zeitverlauf des Spannungsabfalls am Vorwiderstand R der LED auf einem Oszilloskop sichtbar gemacht wird.
Der Befehl po=GPIO.PWM(g, f) erzeugt eine Instanz namens po des PWM-Objekts zur Ausgabe
auf dem GPIO namens g (hier: GPIO 2) mit der Grundfrequenz f . Die Ausgabe wird mit dem
Befehl po.start(0) begonnen, wobei der Tastgrad zunächst 0 ist (und die LED daher noch dunkel
ist). Mit f = 10 wird der gewünschte Wert der Grundfrequenz auf 10 Hz gesetzt.
In der Prozedur leuchte() erfolgt eine Veränderung des PWM Signals. Der neue Frequenzwert wird
mit dem Befehl po.ChangeFrequency(f) übergeben. Der Tastgrad wird in einer Schleife mit dem
Befehl po.ChangeDutyCycle(i) stufenweise erhöht. Frequenz und Tastgrad werden auf dem
Bildschirm formatiert ausgegeben und die Programmausführung wird dann mit time.sleep(5) für 5s
angehalten. Währenddessen leuchtet die LED mit dem eingestellten PWM Signal. Bei einer
Frequenz von Hz flackert die LED periodisch; diese Frequenz ist also zu niedrig für das Dimmen.
Mit f = 100 wird die Grundfrequenz auf 100 Hz gesetzt und die Prozedur leuchte() wird erneut
aufgerufen. Man erkennt, das bei dieser Frequenz kein periodisches Flackern auftritt. Dies liegt am
Überschreiten der Verschmelzungsfrequenz für die visuelle Wahrnehmung.
Der Befehl po.stop() beendet die Ausgabe des PWM Signals.
Bei genauer Betrachtung fällt aber doch ein unregelmäßiges Flackern auch bei f = 100 Hz auf. Dies
liegt an Unregelmäßigkeiten der vom Modul RPi.GPIO erzeugten, programmgesteuerten Modulation. Die Arbeit des Moduls wird nämlich unregelmäßig durch Aktivitäten des Betriebssystems
unterbrochen, zum Beispiel für Garbage Collection . Es gibt Programme, welche PWM Signale
unter Umgehung des Betriebssystems auf den GPIOs ausgeben können, zum Beispiel pi-blaster .
Damit ist dann auch ein Dimmen ohne unregelmäßiges Flackern möglich.
19
Experiment 2: Temperatursensor auslesen
DS18S20
Schaltung 2 (Temperatursensor DS18S20)
GPIOs können auch Datenströme senden oder empfangen. Im
folgenden sollen die digitalen Daten eines Temperatursensors über
einen Eindraht-Bus (1-Wire) von einem einzelnen GPIO empfangen
werden. Als Temperatursensor wird der DS18S20 der Firma
Maxim/Dallas (ein Nachfolgemodell des Temperatursensors
DS1820) verwendet, welcher Temperatur zunächst in eine analoge
elektrische Spannung und dann mithilfe eines AD-Wandlers in
digitale Signale wandelt, die über einen Eindraht-Bus (1-Wire) 1
gesendet werden können. Der experimentelle Aufbau kann in
ähnlicher Weise wie in Experiment 1 (siehe oben) erfolgen.
Da der Sensor auf einer Steckplatine aufgebaut
werden soll, wird die Bauform TO-92 mit drei
Anschlussbeinchen (Pins) benutzt. Der TO-92DS18S20 ist von vielen Elektronikbauteilehändlern erhältlich (Preis: 2 – 5 €) und das zugehörige
Datenblatt findet man auch leicht im Internet.
DS18S20
1 2 3
Pin 1 GND (Masse)
Pin 2 DQ (Daten)
Pin 3 VDD (Power)
DS18S20
1 2 3
Pin 1 des DS18S20 wird mit GND (Pin 9 der
Stiftleiste P1) verbunden, Pin 2 des TO-92DS18S20 mit GPIO 4 (Pin 7 von P1) und Pin 3
des TO-92-DS18S20 mit einer Spannungsquelle
(hier 3,3 V von Pin 1 der Stiftleiste P1) .
Über Pin 2 des DS18S20 werden binäre Daten
empfangen oder gesendet. Die beiden logischen
Zustände werden hier durch die Spannungen 0 V
(logisch LOW) und 3,3 V (logisch HIGH) vermittelt. Ein 4,7 kΩ Widerstand wird zwischen Pin
Temperatursensor, Gehäuse TO-92
( digitaler
Ausgang )
die ebene
Seite ist
uns zugewandt
4,7 kΩ
Pin 9
von P1
GND
Pin 7
von P1
GPIO 4
Pin 1
von P1
3,3 V
2 und Pin 3 des TO-92-DS18S20 gesteckt.2
1
Für einfache Datenübertragungsaufgaben gibt es verschiedene serielle Bussysteme, die zum Teil von Π und
Raspbian unterstützt werden. Dazu gehört der Eindraht-Bus (1-Wire) , der die Daten seriell (nacheinander),
asynchron (ohne zusätzliches Taktsignal) über nur zwei oder drei Leitungen mit einer Geschwindigkeit von
normalerweise 15,4 kbps über Entfernungen bis etwa 100 m überträgt. Es gibt dabei eine Master-Station (hier: der
Π) und eine oder mehrere Slave-Stationen (hier: ein oder mehrere Sensoren); jede Slave-Station hat eine eindeutige,
vom Hersteller vorgegebene Identifikationsnummer. Wenn der Bus mit drei Leitungen gebaut wird, gibt es neben
der Masseleitung eine Datenleitung und eine für die Versorgungsspannung (zwischen 3 V und 5,5 V). Beim Aufbau
mit zwei Leitungen entfällt die Versorgungsspannungsleitung und die Slave-Station (Sensor) gewinnt die
notwendige Energie "parasitär" aus der Datenleitung. Der Betrieb mit drei Leitungen ist stabiler, und wird hier
daher vorgezogen, aber man braucht eine Leitung mehr. Der Name des Eindraht-Bus (1-Wire) stammt vom Aufbau
mit zwei Leitungen, da dann zusätzlich zur Masse nur eine weitere Leitung gebraucht wird.
2
Der Transistorausgang von Pin 2 des DS18S20 hat eine Open-Drain-Schaltung (so genannt bei Feldeffekttransistoren, bei Bipolartransistoren entspricht dies einer Open-Collector-Schaltung) und nimmt daher die Zustände 0 V
20
GPIO 4 wird verwendet, weil der Treiber w1-gpio (siehe unten) nur diesen GPIO zum 1wire-Bus
macht.
Temperaturmessung von der Konsole
Für die Temperaturabfrage vom Sensor kann man Steuerbefehle für die Konsole in ähnlicher Weise
wie in Experiment 1 benutzen. Nach dem fertigen Aufbau obiger Schaltung müssen zunächst die
Treiber für den Eindraht-Bus (1-Wire) w1-gpio und w1-therm zur Verfügung gestellt werden. Dies
geschieht, nachdem der Sensor an den GPIOs angeschlossen wurde, mit dem Befehl modprobe :
sudo modprobe w1-gpio
und
sudo modprobe w1-therm
Der Befehl sudo wird vorgesetzt, weil die Ausführung von modprobe nur als Root möglich ist.
Um zu prüfen, ob die Treiber erfolgreich geladen wurden, kann man folgenden Befehl ausführen:
lsmod
Mit den obigen Befehlszeilen werden die Treiber jedoch nur vorübergehend geladen. Um sich
zukünftig das Laden der Treiber zu ersparen, kann man dies automatisch beim Systemstart machen
lassen. Dazu wird die Datei modules im Verzeichnis etc im Stammverzeichnis des Nutzers, der den
Sensor abfragt, ergänzt. Zunächst wird diese Datei mit dem Editor nano geöffnet
sudo nano /etc/modules
dann werden folgende Zeilen am Ende der Datei angefügt, gespeichert und die Datei wieder
geschlossen. Statt nano kann man natürlich auch den Editor leafpad benutzen.
w1-gpio
w1-therm
Wenn die Treiber geladen sind, wird mit dem Befehl cd in das Verzeichnis devices gewechselt
cd /sys/bus/w1/devices/
dann lässt man sich mit dem Befehl ls den Inhalt des Verzeichnisses devices anzeigen
ls
Es gibt dort ein Verzeichnis, dessen Name der Seriennummer des Sensors entspricht. In dieses
Verzeichnis wechselt man mit dem Befehl cd
cd Name
oder Offen an. Offen bedeutet, dass der Transistor intern idealerweise vom Ausgang getrennt ist, real über einen
großen Widerstand (hochohmig). Um im Offen-Zustand die Spannung 3,3 V bereitzustellen, wird der Ausgang über
einen sogenannten Pullup-Widerstand mit der 3,3 V Versorgungsspannung verbunden. Wenn der Transistor durchschaltet, also der Ausgang auf 0 V gesetzt wird, fließt Strom durch den Widerstand; aber da der Transistorausgang
niederohmig mit 0 V (Masse) verbunden ist, bleibt die Spannung nahe 0 V.
21
und gibt den Inhalt der Sensor-Datei w1_slave mit dem Befehl cat auf dem Monitor aus
cat w1_slave
Es werden zwei Zeilen ausgegeben. In der zweiten steht nach t= eine Zahl. Fügt man nach den
beiden ersten Ziffern in Gedanken ein Dezimalkomma ein, erhält man die Temperatur in ºC. Wenn
man den Sensor mit zwei Fingern anfasst, erwärmt er sich und ein erneuter Befehl
cat w1_slave
sollte eine höhere Temperatur anzeigen.
Ergänzender Hinweis: Statt des Temperatursensors DS18S20 kann auch der neuere Typ DS18B20
verwendet werden, welcher die Temperatur mit höherer Auflösung (12 bit) ausgibt.
Temperaturmessung mit Python-Programm
Wir benutzen den gleichen Temperatursensor-Schaltkreis und schreiben folgendes Python-Programm. Dabei muss, in der vierten Zeile, für Name der Name des verwendeten Temperatursensors
eingesetzt werden, welcher oben (Abschnitt Temperaturmessung von der Konsole) gefunden wurde.
#!/usr/bin/python
import os
import time
sensor= "Name" # Name des Temperatursensors
os.system('modprobe w1-gpio') # Laden des Treibers w1-gpio
os.system('modprobe w1-therm') # Laden des Treibers w1-therm
pfad = "/sys/bus/w1/devices/"+sensor+"/w1_slave"
text1="\nTemperatur am Sensor "+sensor+", Abbruch durch Ctrl-C"
text2="**********************************************************"
print(text1) # schreibe die Ueberschrift der Messungen
print(text2) # (print ist, ab Python-Version 3, Funktion)
try: # Folgendes normalerweise, ohne Druecken von Ctrl-C
while 1: # Endlosschleife zur Temperaturmessung alle 3 s
zeit = time.strftime("%H:%M:%S") # Uhrzeit in zeit
sd = open(pfad,"r") # oeffne Sensor-Datei
daten = sd.read() # Sensor-Inhalt in daten
sd.close() # schliesse Sensor-Datei
# folgende 4 Befehle entnehmen daten den Temperaturwert
zeile = daten.split("\n")[1] # daten aufteilen, 2. Zeile
22
wort = zeile.split(" ")[9] # zehntes Wort der 2. Zeile
temp = wort[2:] # wort ohne die ersten beiden Zeichen
T = float(temp)/1000 # Zeichenkette zu Zahl, durch 1000
text3 = zeit+": T = "+str(T)+" Grad C" # Ausgabetext
print(text3) # schreibe den Ausgabetext (Messungen)
time.sleep(3) # warte 3 Sekunden
except KeyboardInterrupt: # Folgendes nach Druecken von Ctrl-C
print("\n- Messung beendet -\n") # Ende des Programms
Das Programm wird im Ordner P unter dem Namen temp.py gespeichert. Wir öffnen eine Konsole,
bewegen uns in den Ordner P und geben die Konsolenbefehle
chmod a+x temp.py
sudo ./temp.py
Die Ausführung des Programms kann durch Ctrl-C (Drücken der Taste C , während bereits die Taste
Ctrl oder Strg gedrückt ist) angehalten werden. Um das Programm nochmal zu starten, genügt
sudo ./temp.py
Aufgabe 2
a) Ändern Sie das oben angegebene Python-Programm zur Temperaturmessung so, dass der gerundete Temperaturwert mit einer Nachkommastelle ausgegeben wird (siehe oben, Abschnitt Rundung).
b) Außerdem soll statt des Wortes Grad das Symbol ° erscheinen. Dafür muss, wie im Abschnitt
GUI mit Python, Modul Tkinter beschrieben, ein Zeichensatz vorgegeben werden.
Aufgabe 3
a) Schreiben Sie ein Programm zur Temperaturmessung,
in dem Ein- und Ausgaben über eine GUI erfolgen (siehe
Abbildung rechts). Als Layout-Vorlage soll das oben (im
Abschnitt GUI mit Python, Modul Tkinter) beschriebene
GUI dienen.
Statt einer automatisch fortlaufenden Messung beschränken wir uns zunächst auf Einzelmessungen, die mit einem
Klick auf den Button b1 (measure) ausgelöst werden. Das
Messergebnnis soll im Textfeld (label) angezeigt werden.
Ein Klick auf den zweiten Button, b2 (-> °F), soll die Anzeige von °C auf °F umstellen (und b2
erhält dann die Aufschrift -> °C); ein weiterer Klick soll die Anzeige von °F auf °C zurückstellen.
23
Ein Klick auf den dritten Button, b3 (quit) soll das GUI-Programm beenden. Wenn w die Variable
ist, welche das Fensterobjekt (window) enthält, kann dies durch Aufruf einer Prozedur wie
def qt():
w.destroy()
geschehen. Damit verschwindet das window und das Programm wird beendet.
b) Ergänzen Sie das Programm zur Temperaturmessung mit einem wiederholten Aufruf der Prozedur, welche die Messung vornimmt und für die Erneuerung der Anzeige sorgt. Damit sollte, durch
einen Klick auf den Button b1 (measure), eine automatisch fortlaufende Temperarurmessung ausgelöst werden. Die in Aufgabe 3 festgelegten Ereignisse für Button b2 (-> °F / -> °C) und Button b3
(quit) sollen wie zuvor wirken.
Aufgabe 4
Fügen Sie dem Programm zur Temperaturmessung aus Aufgabe 4 die Speicherung in einer Datei
T_data hinzu. Diese muss am Anfang des Programms geöffnet werden. Nach jeder Messung soll
eine Zeichenkette
time.strftime("%H:%M:%S")+', ' + '%5.1f °C' % round(T,1) + '\n'
in die Datei geschrieben werden, wobei die Variable T den Temperaturwert in°C enthält. Am Ende
des Programms, vor w.destroy() , soll die Datei geschlossen werden.
24
Document
Kategorie
Technik
Seitenansichten
18
Dateigröße
368 KB
Tags
1/--Seiten
melden