NERKA Noch eine Raspberry Kurzanleitungweb.eah-jena.de/~gitter/nerka/pi_nerka.pdf · 2,0 A Polyfuse. Mit Netzgeräten nicht ausreichender Leistung arbeitet der ...

NERKA

Noch eine Raspberry Kurzanleitung

Alfred H. Gitter , Version vom 29. 9. 2016

Vorbemerkungen

Die vorliegende Schrift wurde und wird für gleich gesinnte Dilettanten erstellt. Sie ist unvollendet

und wird in unregelmäßigen Abständen erweitert oder geändert. Viele der behandelten Themen

liegen außerhalb der professionellen Fachkunde des Autors und die Bezeichnung als "Anleitung"

soll lediglich den einführenden und anwendungsnahen Inhalt charakterisieren und keinen Anspruch

auf überlegenes Wissen nahelegen. Ich hoffe, Leser zum Experimentieren mit dem Raspberry Pi

anzuregen und dafür einige Hinweise von Wert beizusteuern.

Der Raspberry Pi wird im Folgenden mit Π abgekürzt (Π ist der griechische Großbuchstabe Pi). Die

Schrift bezieht sich auf das Modell Raspberry Pi 3 Model B, gilt aber auch für frühere B-Modelle.

Es wird vorausgesetzt, dass als Betriebssystem Raspbian Jessie (Full desktop image based on

Debian Jessie, vom 27. Mai 2016) installiert wird oder wurde. Sie unterscheidet sich leicht von der

Vorgängerversion Wheezy und stark von früheren Raspbian-Versionen. Das Betriebssystem ist für

alle drei genannten Ausgaben des Π gleich. Als Programmiersprache dient Python 3 . Der Leser

sollte über elementare Vorkenntnisse davon verfügen.

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 Internet-

seiten, auf die verwiesen wird, sind ausschließlich die Betreiber dieser Seiten verantwortlich.

© by Prof. Dr. Alfred H. Gitter, Jena (2015 - 2016)

1

InhaltVorbemerkungen..............................................................................................................................1Vorwort (28. Juli 2016)....................................................................................................................3

Hardware.......................................................................................................................4Gehäuse, Energieversorgung, Bild und Ton, Tastatur und Maus, aktiver USB-Hub.......................5Speicherkarte, LAN und WLAN, Kontroll-LEDs, Drucker und externe Datenträger....................6Digitale Anschlusspunkte: GPIOs...................................................................................................9

Software.......................................................................................................................12Boot, Betriebssystem, Konfiguration, Konsole, Paketverwaltung, Cronjobs................................12Editor, Browser und weitere Programme.......................................................................................23Steuerung der GPIOs über a) das Betriebssystem oder b) das Programm raspi-gpio...................30Gnuplot und Mathematica (mit Aufgaben 1 und 2).......................................................................32

Programmieren mit Python..........................................................................................38Erstes Programm: "Hallo!", Beispielprogramm (Zeit, Rundung, formatierte Ausgabe)...............38GUI mit Python, Modul tkinter......................................................................................................41Modul RPi.GPIO zur Steuerung der GPIOs..................................................................................43Noch mehr Python.........................................................................................................................47

Experiment 1: LED ein- und ausschalten....................................................................53Schaltung 1 (LED) und Steuerung der GPIOs von der Konsole...................................................53Blinken und Dimmen mit Python-Programmen............................................................................55Schaltung 2 (LED und Transistor).................................................................................................59Aufgabe 3.......................................................................................................................................60

Experiment 2: Schalter auslesen..................................................................................62Schaltung 3 (Schalter)....................................................................................................................62Daten eingeben mit Python-Programm..........................................................................................63Desktop Shortcut für unser Programm..........................................................................................64Aufgabe 4.......................................................................................................................................65

Experiment 3: Temperatursensor am Eindraht-Bus.....................................................66Schaltung 4 (Temperatursensor DS18S20)....................................................................................66Temperaturmessung von der Konsole mit DS18S20.....................................................................67Python-Programm zur Temperaturmessung mit DS18S20 (mit Aufgabe 5).................................68

Experiment 4: Temperatursensor am I2C Bus.............................................................72Schaltung 5 (Temperatursensor LM75).........................................................................................72Temperaturmessung von der Konsole mit LM75..........................................................................72Python-Programm zur Temperaturmessung mit LM75.................................................................74Aufgabe 6.......................................................................................................................................76

Experiment 5: A/D-Wandler am SPI Bus....................................................................77Schaltung 6 (A/D-Wandler MCP3208) und das Treibermodul für den SPI Bus...........................77Python-Programm zur Spannungsmessung mit MCP3208 (mit Aufgabe 7).................................79

Experiment 6: Textausgabe auf LCD-Anzeigemodul..................................................84Schaltung 7 (LCD-Modul C0802-04)............................................................................................84Controller vom Typ HD47780.......................................................................................................87Beschreiben der Anzeige...............................................................................................................90Aufgabe 8.......................................................................................................................................92

Anhang.........................................................................................................................93Internetradio- und Internetfernsehsender und ihre URLs..............................................................93Raspbian Wichtige Befehle für die Kommandozeile.................................................................98Bash Shell-Variablen..................................................................................................................99

2

Vorwort (28. Juli 2016)

Ein Vorwort ist der Preis, den der Leser eines guten Buches gedanklich entrichtet. Der geistig

geizige oder ungeduldige Leser kann es natürlich überschlagen und gleich mit der spannenden

Technik beginnen. Wer hier weiterliest muss sich nun einen geschichtlichen Rückblick gefallen

lassen.

In einer Elektronikzeitschrift aus dem Jahre 1979 wurden Mikrocomputer zum Lernen und Basteln

angeboten, die den Mikroprozessor Z80 enthielten. Diese Vorgänger des Raspberry Pi ( Π ) wurden

bereits mit Tastatur und Bildschirm (Fernseher) betrieben und verfügten über digitale I/O-Ports

ähnlich den GPIOs des Π. Der Preis für ein System (Platine und Tastatur) mit 2 kB ROM (für das

unveränderbare Betriebssystem) und 2 kB RAM (Arbeitsspeicher) betrug etwa 1000 DM. Wer

wissen will, was DM ist und wie viel 1000 DM in heutiger Währungseinheit entsprechen, soll seine

Großeltern über die gute alte Zeit befragen.

Gespeichert wurden Programme und Daten auf Audiokassetten in Form von binärem Piepsen. Wer

wissen will, was eine Audiokassette ist, ...

Im Jahr 1979 gab es noch kein Internet und schnelle Textnachrichten wurden per Telegramm ver-

sandt. Wer wissen will, was ein Telegramm ist, ...

Ansonsten war es 1979 nicht viel anders als heute (2016). Die künstliche Intelligenz war kurz vor

dem Durchbruch und das baldige Ende fossiler Brennstoffe beschlossene Sache. Im Juli (1979 /

2016) sandte uns eine Raumsonde der USA schöne Photos vom Jupiter.

Mein Chef riet mir damals, mich für Wissenschaft und Technik zu begeistern, denn damit hätte man

auch noch Spass, wenn man mal über 50 ist. Glaubt es nur !

3

Hardware

Der Raspberry Pi ( Π ) ist ein Ein -

platinen computer ( Single Board

Computer = SBC ). Es gibt ihn in

verschiedenen Ausführungen. Wir

benutzen hier das Modell Raspberry

Pi 3 Model B, im folgenden mit

Π_3B abgekürzt (Bild rechts), das

seit Februar 2016 verfügbar ist.

Die älteren Ausgaben, Raspberry Pi

Model B, Revision 2, im folgenden

mit Π_1B abgekürzt, und Raspberry

Pi 2 Model B, im folgenden mit

Π_2B abgekürzt, können aber auch

verwendet werden. In der Regel beschränkt sich die Darstellung auf Eigenschaften des Π, die bei

den drei genannten Modellen gleich sind und die erweiterten Möglichkeiten des Π_3B werden nicht

benutzt.

Wichtigstes Bauelement des Π ist das System-on-a-Chip (SoC) der Firma Broadcom , BCM2835

beim Π_1B , BCM2836 beim Π_2B und BCM2837 beim Π_3B. Das SoC enthält zwei Mikro -

prozes sor en : eine ARM CPU ( ARM1176JZF-S beim Π_1B , ARM Cortex-A7 beim Π_2B und

ARM Cortex-A53 beim Π_3B) und eine GPU ( Grafikprozessor , VideoCore IV bei bei Π_1B ,

Π_2B , und Π_3B ). Der Arbeitsspeicher als SDRAM beträgt 1 GB bei Π_2B und Π_3B , und 512

MB (beziehungsweise 256 MB bis Oktober 2012) beim Π_2B . Den Arbeitsspeicher teilen sich

CPU und GPU. Die Aufteilung kann beim Start des Betriebssystems festgelegt werden (siehe unten,

Raspberry Pi Configuration). Ansonsten bekommt die GPU 64 MB und die CPU den Rest. Die

CPUs des Π verfügen auch über kleinere, schnellere Datenspeicher (Cache) als Level 1 cache und

Level 2 cache. Als Speichermedium dient eine microSD-Karte die in eine Fassung unterhalb des

Boards geschoben wird. Die Ausgabe von Bild und Ton kann am besten über den eingebauten

HDMI-Ausgang erfolgen. Tastatur und Maus werden über USB mit dem Π verbunden. Der Π ist

mit einem internen USB-Hub ausgestattet, welcher zwei (Π_1B) beziehungsweise vier (Π_2B und

Π_3B) USB-2.0-Anschlüsse bereitstellt, sowie einer Ethernet-Schnittstelle zur Einbindung in

Datennetze (LAN). USB und LAN werden vom USB/LAN-Controller gesteuert. Die Aktivität der

CPU und des USB/LAN-Controllers SMSC LAN9514 wird auf dem Board es Π_3B durch vier

LEDs angezeigt. Der Π_3B hat außerdem bereits WLAN und Bluetooth (Chip: BCM43438) mit

Antenne (in obigem Schema oben links auf dem Board zu sehen) integriert. Steckverbinder auf dem

Board erlauben den Anschluss einer speziellen Kamera und eines speziellen Displays. Über 40

elektrische Anschlusspunkte, GPIOs genannt, können digitale Ein- und Ausgaben erfolgen. Die

Leistungsaufnahme hängt natürlich von der Belastung durch den SoC und die Peripheriegeräte ab.

Man sollte mindestens 5 W (oder 1 A bei 5 V) bereitstellen. Empfohlen wird oft sogar ein Netzteil

mit 10 - 13 W Leistung (entsprechend 2 - 2,5 A).

4

Schema des Raspberry Pi 3 Model B, Ansicht von oben

Raspberry Pi 3 Model B V1.2 (c) Raspberry Pi 2015

AHG Juni 2016

Stift leiste P1 (GPIOs) mit 40 Pins

RJ-45Buchse( LAN )HDMI

( Typ A )

2 xUSB 2.0

Energieversorgung

Mikro-USB

SMSCUSB 2.0und LANController

BCM2837S o C

BCM43438802.11n WLAN+ Bluetooth 4.1

undmicroSD

beide auf derRückseite

2 xUSB 2.0

Audio/VideoAus-gang

ACT

5 V

PWR

CSI

-2 (

Kam

era)

100

LNK

DS

I (D

ispl

ay)

Ant

enn

e

LEDs

LEDs

64-Bit-CPUund GPU

ELPIDA1 GB RAM

auf derRückseite

4039

21

3,5 mm 4-poligeKlinkenbuchse

Gehäuse, Energieversorgung, Bild und Ton, Tastatur und Maus, aktiver USB-Hub

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 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 5 V (maximal 5,25 V) und einen Strom von mindestens 1 A (es darf mehr sein) für den Π_3B

(beziehungsweise mindestens 700 mA für den Π_1B und 800 mA für den Π_2B) liefern kann.

Der dem Π über die Mikro-USB-Buchse zugeführte Strom darf beim Π_3B 2,5 A nicht überschrei-

ten, was durch eine selbstrückstellende Sicherung , kurz Polyfuse genannt, gewährleistet wird. Diese

(Typ: MF-MSMF250/16X) befindet sich auf der Rückseite der Platine in der Nähe der Mikro-USB-

Buchse. Der Π_2B ist für eine etwas geringere Leistungsaufnahme ausgelegt und enthält daher eine

2,0 A Polyfuse.

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 Bordspannungs steck dose und einen Adapter, der 5 V Spannung erzeugt, betrieben werden.

Bild und Ton

Die Abbildung rechts zeigt in der Mitte den

Π_1B und oben links ein Kabel zum Anschluss

eines Moni tors . 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 am HDMI-Ausgang oder über den

analogen Videoausgang (Composite Video) des Π angeschlossen werden. Es gibt auch einen

analogen Audio-Ausgang. Beim Π_2B und Π_3B beim werden die analogen Audio- und Video-

signale kombiniert über eine TRRS-Buchse für vierpolige Klinkenstecker bereitgestellt. Beim

Π_1B gibt es eine (gelbe) Cinch-Buchse für das Bild- und einen dreipoligen Klinkenstecker

(Stereo, 3,5 mm Durchmesser) für das Tonsignal.

5

Π_1B mit Peripheriegeräten

Das nebenstehende Schema zeigt die Anschlüsse eines

Klinkensteckers für den 3,5 mm-Analogausgang.

Tastatur und Maus

Als Dateneingabegeräte dienen Tastatur und Maus, die

über die USB-Buchsen des Π angeschlossen werden.

Leider hat der Π_1B nur zwei USB-Buchsen. Man kann

zum Beispiel eine Funktastatur mit dazu gehöriger

drahtloser Maus (das Bild zeigt unter dem Π_1B ein

besonders kleines Exemplar) mit einem einzelnen USB-

Stick (wie im Bild gezeigt) anschließen. Da die

Energieversorgung der USB-Buchsen beim Π schwach

ist, sollten die dort angeschlossenen 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.

Aktiver USB-Hub

Ein aktiver USB-Hub, der weitere USB-Buchsen mit eigener Stromversorgung bereitstellt, ist eine

sinnvolle Ergänzung. Damit können auch externe Geräte, die viel elektrische Leistung benötigen,

zum Beispiel externe Festplatten oder DVD-Laufwerke, angeschlossen werden.

Speicherkarte, LAN und WLAN, Kontroll-LEDs, Drucker und externe Datenträger

Statt einer Festplatte dient beim Π eine kleine Speicherkarte als Datenspeicher für das Betriebs-

system, Programme und Daten. Beim Π_1B nimmt man 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-Kart en 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. Auch hier sollte man sich vorher, zum Beispiel im Internet, darüber infor-

mieren, welche SD- oder SDHC-Kart en vom Π erkannt werden.

Entsprechend wird beim Π_2B und beim Π_3B eine microSD-Karte verwendet. Ich empfehle eine

Kapazität von 16 GB.

Die Verbindung zu einem LAN und damit in der Regel auch zum Internet ist über die RJ-45-Buchse

möglich, in die ein Patchkabel (auch Ethernet-Kabel oder LAN-Kabel genannt) mit 8-poligen RJ-

45-Stecker passt. Das Modell Π_3B verfügt außerdem bereits über WLAN und Blootooth.

Beim Π_1B und beim Π_2B kann eine WLAN-Antenne mit einem USB-Stick angeschlossen

werden. Allerdings sollte man sich vorher, zum Beispiel im Internet, darüber informieren, welche

WLAN-USB-Stic ks vom Π erkannt werden und möglichst wenig Strom brauchen (siehe oben).

Wenn man prüfen will, welche Funknetzwerke über die WLAN-Antenne empfangen werden, kann

6

links

rechts

Masse

Video

links

rechts

Masse

links: Stecker für den 3,5 mm Audio-Ausgang des Π_1B , rechts: Stecker für den 3,5 mm Audio/Video-Ausgang des Π_2B und des Π_3B

man folgendes Shell-Skript (siehe unten) nutzen:

#!/bin/bash# wlanscan (AHG, 2016)sudo iw dev wlan0 scan > scan.tmpe=`grep 'SSID:' scan.tmp | awk 'print $2'`z=`echo $e | wc -w`f=`grep 'freq:' scan.tmp | awk 'print $2'`s=`grep 'signal:' scan.tmp | awk 'print $2'`i=1 ; echoecho "Über wlan0 sind "$z" Funknetzwerke erreichbar:"while [ $i -le $z ]do t1=$i") ESSID: "`echo $e | cut -d " " -f $i` t2=", Frequenz: "`echo $f | cut -d " " -f $i` t3=", Signalstärke: "`echo $s | cut -d " " -f $i\ | cut -d "." -f 1` ; echo $t1$t2" MHz"$t3" dBm" i=`expr $i + 1`doneecho ; rm scan.tmp

Nachdem man es als Datei wlanscan gespeichert und mit chmod a+x wlanscan ausführbar

gemacht hat (siehe unten) kann man es mit ./wlanscan aufrufen.

Die WLAN-Datenübertragung kann oft durch Ausrichtung der Empfangsantenne verbessert werden.

Folgendes Shell-Skript (siehe unten) zeigt die aktuelle Signalstärke einer bestehenden WLAN-

Verbindung an:

#!/bin/bash

echo "Shell-Skript wlansignal (AHG, 2016), Abbruch mit Strg-C"

echo -e "ESSID: `iw dev wlan0 link | sed -n '2 p' | awk 'print $2'`, \c"

echo -e "Frequenz: `iw dev wlan0 link | sed -n '3 p' | awk 'print $2'` MHz, \c"

echo "Signalstärke (dBm):"

while true

do

echo -e "\r`iw dev wlan0 link | sed -n '6 p' | awk 'print $2'` \c"

done

Nachdem man es als Datei wlansignal gespeichert und mit chmod a+x wlansignal aus-

führbar gemacht hat (siehe unten) kann man es mit ./wlansignal aufrufen.

Die Tätigkeit der Hardware wird durch kleine LEDs sichtbar gemacht. Beim Π_1B sind es:

Kontroll-LEDs im Raspberry Pi

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)

Beim Π_3B befinden sich die LEDs ACT und PWR in einer Ecke der Platine und die LEDs LNK und

100 innnerhalb der RJ-45-Buchse. Die LED FDX fehlt beim Π_2B und beim Π_3B .

7

Zur Installation eines lokalen Druckers, zum Beispiel des Modells Samsung ML-1410, wird dieser

am USB-Port des Π angeschlossen und eingeschaltet. Dann gibt man in der Konsole (siehe unten)

folgende Befehle ein:

sudo apt-get updatesudo apt-get upgradesudo apt-get install cupssudo usermod -a -G lpadmin pi

Danach öffnet man im Menu unter Internet den Epiphany Webbrowser (siehe unten) und geht zur

Adresse

http://127.0.0.1:631

Im Browser öffnet sich die CUPS-Seite und im Reiter Verwaltung klicken wir auf Drucker

hinzufügen . Nach Eingabe von Benutzername und Passwort erscheint die Seite Drucker hinzufügen

(Schritt 1/5) , auf der man nach Lokale Drucker: das angeschlossene Modell (hier Samsung ML-

1510_700 genannt) wählt und auf Weiter klickt. Es öffnet sich die Seite Drucker hinzufügen (Schritt

3/5) , auf der man die Felder Name: , Beschreibung: und Ort: ausfüllt, Freigabe: wählt und auf

Weiter klickt. Nun folgt die Seite Drucker hinzufügen (Schritt 5/5) , auf der man einen Drucker-

treiber angeben soll. Falls der Drucker in der gezeigten Liste enthalten ist, wählt man ihn. Falls

nicht, wie im Beispiel des Samsung ML-1410, muss man eine Treiberdatei (mit der Endung .ppd)

bereitstellen. Für den Samsung ML-1410 ist dies die Datei Samsung-ML-1410-gdi.ppd , die man

vorher auf dem Π gespeichert haben muss. Dann wird auf Drucker hinzufügen geklickt. In der

nächsten Seite wählt man nach Page Size: die Option A4 und klickt auf Standardeinstellungen

festlegen . Schließlich zeigt eine neue Seite eine zusammenfassende Beschreibung und man schließt

das Browserfenster. Danach sollte der Drucker sofort einsatzbereit sein.

Die Dateien zur Konfiguration von CUPS stehen im Verzeichnis /etc/cups (und Unterverzeich-

nissen). Eine direkte Änderung dieser Dateien (mit einem Editor) ist in der Regel aber nicht nötig.

Der reguläre Datenträger, die microSD-Karte (beziehungsweise, bei älteren Π-Modellen, die SD-

oder SDHC-Karte) reicht oft nicht aus. Bei ausreichender Stromversorgung des Π (siehe oben) kann

ein (normal formatierter) USB-Stick direkt in eine freie USB-Buchse des Π gesteckt werden. Fest-

platten und DVD-Brenner, welche DVDs und CDs lesen und schreiben, können ebenfalls über USB

mit dem Π verbunden werden. Falls diese Geräte nicht über eine eigene Stromversorgung ver-

fügen, müssen sie aber über einen aktiven USB-Hub (siehe oben) angeschlossen werden. Für die

meisten Modelle stellt das Π-Betriebssystem automatisch einen passenden Treiber zur Verfügung

und fügt sie in das Dateisystem ein ("mounted" sie), so dass (für den Benutzer pi) die Datenträger

dann in einem Unterordner des Verzeichnisses /media/pi erscheinen. Es ist jedoch ratsam, sich

vor der Anschaffung eines externen Datenträgers zu erkundigen, ob der Betrieb am problemlos Π

möglich ist. Allerdings sind entsprechende Daten im Internet unvollständig.

Anschluss und Programme zum Betrieb einer Webcam werden unten, im Abschnitt Editor, Browser

und weitere Programme , beschrieben.

8

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). Es

gibt beim Π keine Anschlusspunkte zur Ein- oder Ausgabe von analogen elektrischen Signalen. Die

GPIO sind sehr empfindlich und können durch Überspannung ( > 3,3 V ) leicht zerstört werden. Ins-

besondere muss man beachten, dass das 5 V-Potential des Π nicht auf GPIOs gelegt werden darf.

Bei den GPIOs entspricht 0 V einer logischen 0 und 3,3 V einer logischen 1. Genauer gesagt wird an

einem als Eingang geschalteten GPIO eine Spannung zwischen 0 V und 0,8 V als logische 0 (low)

gelesen, eine zwischen 2,0 V und 3,3 V als logische 1 (high). Spannungswerte zwischen 0,8 V und

2,0 V sollten nicht verwendet werden, da deren Umsetzung in einen Logikpegel unbestimmt ist.

Zu einem als Eingang geschalteten GPIO kann per Software ein interner Pullup-Widerstand oder

Pulldown-Widerstand zugeschaltet werden. Deren Werte liegen zwischen 50 und 65 kΩ. Eine

Ausnahme bilden GPIOs 2 und 3, die beide (um ihre Nutzung für einen I 2 C Datenbus zu verein-

fachen) einen, nicht abschaltbaren, internen 1,8 kΩ Pullup-Widerstand haben. Dies kann die

Nutzung der GPIOs 2 und 3 beeinflussen. Ein externer Pulldown-Widerstand wird in Abschnitt

Schaltung 3 (Schalter) verwendet.

Die digitalen elektrische Anschlusspunkte

sind als doppelreihige Stift leiste namens P1

ausgeführt (siehe Abbildung rechts).

Beim Π_1B hat die Stiftleiste 26 Pins und

beim Π_2B und beim Π_3B hat sie 40 Pins.

Die 26 Pins des Π_1B stimmen mit den ent-

sprechenden Pins des Π_2B und im wesent-

lichen (siehe unten) mit denen des Π_3B

überein.

Ein Teil der Pins der Stiftleiste P1 sind GPIOs, die einen BCM-Kanalnamen des System-on-a-Chip

haben. Andere Pins sind mit der Signalmasse (GND) oder einem positiven elektrischen Potential

(3,3 V oder 5 V) verbunden. Der Strom durch die GPIOS und 3,3 V Pins darf insgesamt maximal 50

mA betragen. Durch einen einzelnen GPIO sollten höchstens 16 mA fließen (siehe hier).

Die 5 V Pins können zusammen soviel Strom an externe Geräte abgeben, wie das Netzteil liefert,

abzüglich des Stroms, der vom Raspberry gebraucht wird.

9

P1Zweireihige Stiftleiste, P1 genannt, für die Ein- und Ausgabe digitaler Daten über GPIO-Pins (Stifte). Obere Reihe (rot ge zeichnet): geradzahlig bezeichnete Pins, von links (2) nach rechts nummeriert. Untere Reihe (blau gezeichnet): ungerad-zahlig bezeichnete Pins, von links (1) nach rechts nummeriert. Der Abstand der Pins beträgt jeweils 2,54 mm (1/10 Zoll).

Folgende Tabellen zeigen die Zuordnung von Pin-Nummern der Stiftleiste P1 zu den BCM-

Kanalnamen der GPIOs und die Pins mit festem elektrischem Potential:

Pin 2 4 6 8 10 12 14 16 18 20 22 24 26

5 V 5 V GNDGPIO

14GPIO

15GPIO

18GND

GPIO23

GPIO24

GNDGPIO

25GPIO

8GPIO

7

Pin 1 3 5 7 9 11 13 15 17 19 21 23 25

3,3 VGPIO

2GPIO

3GPIO

4GND

GPIO17

GPIO27

GPIO22

3,3 VGPIO

10GPIO

9GPIO

11GND

Pin-Belegung der Stiftleiste P1 beim Π_1B und ebenso im Anfangsteil der Stiftleiste P1 beim

Π_2B und beim Π_3B .

Pin 28 30 32 34 36 38 40

ID_SC GNDGPIO

12GND

GPIO16

GPIO20

GPIO21

Pin 27 29 31 33 35 37 39

ID_SDGPIO

5GPIO

6GPIO

13GPIO

19GPIO

26GND

Pin-Belegung im Endteil der Stiftleiste P1 beim Π_2B und beim Π_3B

Die mit ID_SC und ID_SD bezeichneten Pins des Π_2B ermöglichen den Anschluss eines

EEPROM-Speichers (ID EEPROM), von dem (beim Booten des Raspberry) Konfigurationsdaten

gelesen werden können (zum Beispiel die Belegung von GPIOs), die für das vorliegende Gerät

gelten. Diese beiden Pins dürfen nicht für andere Zwecke benutzt werden.

Einige GPIOs können vom System-on-a-Chip zum Betrieb eines seriellen Datenbusses oder für

andere Sonderfunktionen genutzt werden.

I 2 C : GPIO 2 (SDA) und GPIO 3 (SCL), GPIOs 2 und 3 mit 1,8 kΩ Pullup-Widerstand, siehe oben

1-Wire : GPIO 4 (mit dem Treiber w1-gpio), GPIO 4 kann durch Treiber w1-gpio verändert sein

General purpose Clock : GPIO 4 (GPCLK0)

S PI : GPIO 7 (Chip Select 1), GPIO 8 (Chip Select 0),

GPIO 9 (MISO), GPIO 10 (MOSI) und GPIO 11 (SCLK)

UART : GPIO 14 (TXD), GPIO 15 (RXD) und GPIO 17 (RTS), die Sonderfunktion (alternate

function) ist bei GPIOs 14 und 15 nach dem Start des Betriebssystems eingeschaltet

Pulsweitenmodulation : GPIO 18 (PWM)

Beim Π_1B sind zumindest GPIO 22, GPIO 23, GPIO 24, GPIO 25 und GPIO 27 für benutzer-

definierte digitale Ein- und Ausgaben frei verfügbar, ohne die oben genannten Sonderfunktionen

einzuschränken. GPIO 17 wird in der Regel nicht für die UART Schnittstelle gebraucht und ist dann

auch frei verfügbar. Beim Π_2B und Π_3B beim kommen weitere freie GPIOs auf der Stiftleiste

P1 hinzu.

10

In den unten beschriebenen Experimenten müssen GPIO-Pins mit elektronischen Versuchsauf-

bauten auf einem Steckbrett verbunden werden. Geeignete Steckbrücken mit flexiblem Kabel, an

einem Ende mit Stecker (passend für das Steckbrett) und am anderen Ende mit Buchse (passend für

die GPIO-Pins) sind im Elektronikhandel leicht erhältlich.

In Versuchsaufbauten, bei denen man bis zu drei freien GPIOs ohne Sonderfunktion, sowie even-

tuell 3,3 V und GND braucht (siehe unten, Experimente 1 und 2), kann man folgende fünf zusam-

menhängende Pins auf der Stiftleiste P1 benutzen:

P1 Pin 9 11 13 15 17

Belegung GND GPIO 17 GPIO 27 GPIO 22 3,3 V

Ein 5-poliges Flachkabel kann, an einem Ende, an eine 5-polige Buchsenleiste mit passendem

Rastermaß (2,54 mm) gelötet werden und, am anderen Ende (über angelötete Drähte mit einem

Durchmesser von 0,5 mm oder 0,6 mm) mit einer Steck platine verbunden werden. Die Buchsen-

leiste wird auf die fünf ungeradzahligen Pins 9 bis 17 von P1 aufgesteckt.

11

Software

Boot, Betriebssystem, Konfiguration, Konsole, Paketverwaltung, Cronjobs

Boot

Zunächst soll der Boot-Prozess beschrieben werden, um einen tieferen Einblick in die Funktions-

weise des Π zu gewinnen. Wer schnell zur praktischen Anwendung gelangen möchte, kann den

folgenden Absatz überspringen.

Mit Einschalten der Stromversorgung wird der Boot-Vorgang in der GPU mit Hilfe von drei Start-

programmen, bootloader genannt, eingeleitet. Zunächst lädt die GPU aus dem unveränderlichen

ROM-Speicher im SoC den first-stage bootloader . Dieser erlaubt den Zugriff auf eine Partition der

SD-Karte, die ein FAT32 oder FAT16 Dateisystem enthalten muss, in welchem alle weiteren

Dateien stehen, die für das Booten gebraucht werden. Der first-stage bootloader lädt von dort den

second-stage bootloader (Datei bootcode.bin) in den L2 cache. Der second-stage bootloader wird

ebenfalls in der GPU ausgeführt. Er läd den third-stage bootloader (Datei start.elf) in den Arbeits-

speicher (SDRAM). Der third-stage bootloader, der auch in der GPU ausgeführt wird, enthält

Voreinstellungen für den Betrieb des Π und liest die Datei config.txt (falls sie existiert), in der

Änderungen der Voreinstellungen eingetragen sein können (während der Konfiguration des Π).

Außerdem liest er die Datei cmdline.txt, in der Anweisungen für den Kernel stehen, und den Kernel

des Linux-Betriebssystems (Datei kernel.img) in den Arbeitsspeicher. Schließlich startet der third-

stage bootloader die CPU, welche den Kernel ausführt. Außerdem startet der third-stage bootloader

in der GPU ein eigenes Betriebssystem namens VideoCore OS, welches in der GPU ausgeführt wird

(unabhängg vom Linux-Betriebssystem, welches in der CPU läuft).

Betriebssystem

Verschiedene Linux-Betriebssysteme können auf dem Π laufen. Am einfachsten ist die Installation

über die New Out Of Box Software (oder kurz und liebevoll NOOBS genannt). Dafür muss

NOOBS auf eine SD- oder SDHC-Karte kopiert werden, welche mit dem Dateisystem FAT32

formatiert ist. Neue Speicherkarten mit mehr als 2 GB Speicherkapazität sind in der Regel bereits

mit FAT32 formatiert. Falls eine Neuformatierung notwendig ist, kann dies unter Linux mit dem

Programm GParted geschehen.1 Danach sind alte Daten auf der Speicherkarte nicht mehr ohne

weiteres zugänglich, obwohl sie nicht physikalisch gelöscht werden.

Wenn man die Daten auf einem Speichermedium (hier: eine Speicherkarte) vor einer Neuforma-

tierung vollständig und unumkehrbar löschen will, kann man das Speichermedium mit Nullen

1 Nach dem Einlegen der SD-Karte startet man GParted in einem neuen Fenster. In der Kopfzeile des Fensters sollte etwas wie /dev/mmcblk0 - GParted stehen, wobei mmcblk0, oder ein anderer Name, die SD-Karte bezeichnet. Wir wählen nun Device - Create Partition Table ... In der folgenden Warnung behalten wir die Option msdos und und klicken auf Anwenden . Danach wählen wir Partition - New und setzen, im Fenster mit der Kopfzeile Create new Partition , das File system auf fat 32 . Im Feld Label kann man der neuen Partition einen Namen geben, zum Beispiel pi . Dann klicken wir auf Hinzufügen und danach auf Edit - Apply All Operations und bestätigen mit Anwenden . Dann schließen wir das Fenster namens Applying pending operations, klicken einmal auf die Zeile, welche die neue Partition zeigt, und wählen dann Partition - Manage Flags . Dort machen wir ein Häkchen vor boot , indem wir auf das Kästchen davor klicken, und schließen das Fenster Manage flags ... wieder. Dann verlassenwir das Programm, indem wir GParted - Beenden wählen.

12

überschreiben. In Linux-Betriebssystemen kann man das mit dem Programm dd , erreichen.

Das Programm dd wird im Terminal (siehe unten) mit dem Konsolenbefehl

dd if=/dev/zero of=/dev/mmcblk0 bs=10240 conv=noerror

aufgerufen; dabei ist mmcblk0 der Name des zu löschenden Speichermediums2. Dieser unumkehr-

bare Löschvorgang dauert lange, bei größeren Spreichermedien mehrere Stunden. Während des

Löschens gibt es keine Meldungen über den Fortschritt des Löschvorgangs. Erst wenn dieser

abgeschlossen ist, erhält man eine Meldung über die Größe des gelöschten Speichers. Falls man

wissen will, wie lange der Löschvorgang dauerte, verwendet man folgende Befehlszeile:

time dd if=/dev/zero of=/dev/mmcblk0 bs=10240 conv=noerror

Das Löschen der Festplatte ist für die Installation des Π-Betriebssystems nicht notwendig, erzeugt

aber einen leeren, unformatierten und mit Sicherheit von Schadsoftware freien Speicher.

Auf der Webseite http://www.raspberrypi.org/downloads finden sich der Download-Link für

NOOBS und eine englischsprachige Anleitung für das Kopieren von NOOBS. Die fertige Speicher-

karte mit NOOBS schiebt man in den Π und schließt Monitor, Maus und Tastatur an, gegebenen-

falls noch LAN. Nun startet man den Π durch Anschluss der Energieversorgung. Einen Knopf zum

Ein- und Ausschalten gibt es nicht. Es zeigt sich auf dem Monitor als Startsymbol die vertraute

Himbeere, das Symbol des Π. Anschließend kann man zwischen verschiedenen Betriebs systemen

wählen. Am einfachsten ist die Installation von Raspbian Jessie , 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ädt man von der oben genannten Webseite (wo auch NOOBS angeboten wird), unter

RASPBIAN JESSIE, durch Klicken auf Download ZIP eine komprimierte (gepackte) neue Version

des Betriebssystems und dekomprimiert (entpackt) es. Dann installiert man es unter Linux, wie auf

der Webseite www.raspberrypi.org/documentation/installation/installing-images/linux.md be-

schrieben. Dabei wird die Speicherkarte mit einer Image-Datei überschrieben, welche sowohl eine

Partitionierung (mmcblk0p1 und mmcblk0p2) und in jeder Partition ein Dateisystem (FAT32

beziehungsweise EXT4) enthält, als auch alle Dateien des Betriebssystems Raspbian. (Es ist hier

unerheblich, ob die Speicherkarte vor dem Beschreiben partitioniert und formatiert war.)

Es gibt auch Betriebssysteme, die den Π als "Mediacenter" für das Abspielen von Audio- und

Videodateien, sowie Radio und Fernsehen nutzen, zum Beispiel OpenELEC, OSMC (Nachfolger

von Raspbmc) und XBian. Die drei genannten bauen auf der Abspielsoftware Kodi (Nachfolger von

XBMC) auf. Auf diese Betriebssysteme wird im folgenden nicht weiter eingegangen.

2 Kennt man den Namen des zu löschenden Speichermediums nicht, kann man ihn in Linux-Betriebssystemen mit dem Konsolenbefehl sudo fdisk -l (mit "l" wie in "lallen") ermitteln (siehe unten, Abschnitt Kommandozeile (Konsole) ). Man führt den Befehl vor und nach Einstecken der Speicherkarte aus, um zu erkennen, welcher Gerätename zur Speicherkarte gehört. Zu beachten ist, dass fdisk -l die Partitionen der angeschlossenen Speichermedien unter der Überschrift Device auflistet. Eine Speicherkarte namens mmcblk0 kann zum Beispiel die zwei Partitionen mmcblk0p1 und mmcblk0p2 enthalten. In obiger Befehszeile mit dem Aufruf von dd muss jedoch der Name der Speicherkarte (hier: mmcblk0 ), nicht der Name einer Partition eingesetzt werden.

13

Im Folgenden gehen wir davon aus, dass das Betriebssystem Raspbian Jessie (Full desktop image

based on Debian Jessie, vom 27. Mai 2016) installiert wurde.

Konfiguration

Nach Einsetzen der Speicherkarte und Einschalten der Stromversorgung wird der Boot-Vorgang

eingeleitet, mit dem Raspbian Jessie startet. Nach dem ersten Start des Betriebssystems erscheint

eine graphische Benutzeroberfläche (LXDE Desktop). Oben links lässt sich ein Menü öffnen und

wir wählen unter Preferences (später Einstellungen genannt) den Menüpunkt Raspberry Pi

Configuration . Es öffnet sich ein Fenster, in dem man die Konfiguration des Betriebssystems

vornehmen kann. Die Raspberry Pi Configuration ersetzt das in früheren Versionen von Raspbian

verwendete Konsolenprogramm raspi-config .

Wir beginnen im Reiter (Tab) Localisation; dort setzen wir die deutsche Ländereinstellung fest.

Dazu klicken wir auf Set Locale... , wählen unter Language: die Option de (German) , Country: DE

(Germany) und Character Set: UTF-8 und bestätigen mit Klick auf OK . Dann klicken wir auf Set

Timezone... , wählen Area: Europe und Location: Berlin (deutsche Zeitzone) und bestätigen mit

Klick auf OK . Danach klicken wir auf Set Keyboard... , wählen Germany (Deutschland) German

(Deutsch) und bestätigen mit Klick auf OK. Zum Schluss klicken wir auf Set WiFi Country, wählen

DE Germany und bestätigen. Die Einstellungen werden durch Klick auf OK im Fenster Raspberry

Pi Configuration bestätigt. Auf die Frage Would you like to reboot now? antworten wir Yes und

der Π startet erneut.

Wir öffnen erneut Raspberry Pi Configuration und wählen im Reiter System die Option Expand

Filesystem, um Raspbian den gesamten Speicherkartenplatz zur Verfügung zu stellen. (Nach Instal-

lation über NOOBS ist dies allerdings schon geschehen.) Dann klicken wir auf Change Password...,

ändern das Passwort (voreingestellt: raspberry) für den Benutzer pi und bestätigen mit Klick auf

OK . Das Passwort muss man sich natürlich merken. Hostname (raspberrypi), Boot (To Desktop)

und Auto login (angekreuzt) lassen wir unverändert. Mit Boot (To Desktop) finden wir nach dem

Betriebssystemstart stets den (LXDE Desktop) vor. (Wenn man stattdessen Boot (To CLI) wählt,

startet das Betriebssystem im textbasierten Modus. In letzterem kann mit dem Befehl startx die

graphische Benutzeroberfläche aufgerufen werden.) Die Option Wait for network lassen wir

deaktiviert. Wenn der LXDE Desktop den Bildschirm ausfüllt, belassen wir Overscan auf der

Option Enable ; umschließt den Desktop dagegen ein schwarzer Rand, setzen wir Overscan auf die

Option Disable . Wir klicken nicht auf Add to Rastrack... . Die Einstellungen werden durch Klick auf

OK im Fenster Raspberry Pi Configuration bestätigt. Auf die Frage Would you like to reboot now?

antworten wir Yes und der Π startet erneut.

Wir öffnen erneut Raspberry Pi Configuration und wählen im Reiter Interfaces : Camera: Disable ,

SSH: Enable (ermöglicht den Zugriff auf den Raspberry über ein Netzwerk), SPI: Enable (wird in

Experiment 5 gebraucht), I2C: Enable (wird in Experiment 4 gebraucht), Serial: Enable, 1-Wire:

Disabled, Remote GPIO: Disabled. Die Einstellungen werden durch Klick auf OK im Fenster

Raspberry Pi Configuration bestätigt. Auf die Frage Would you like to reboot now? antworten wir

Yes und der Π startet erneut.

14

Im Reiter Performance des Fensters Raspberry Pi Configuration ändern wir nichts. Beim Punkt

GPU Memory: kann man den Speicheranteil für den Grafikprozessor (GPU) festlegen. Falls man

Videodateien abspielen will, kann eine Erhöhung des voreingestellten Wertes (64) sinnvoll sein.

Alternativ kann statt des Programms Raspberry Pi Configuration auch das (langsam arbeitende)

Konsolenprogramm raspi-config zur Konfiguration verwendet werden. Es muss mit Root-Rechten,

also mit dem Befehl sudo raspi-config , gestartet werden.

Auf dem LXDE Desktop steht ein Terminalemulator namens LXTerminal zur Verfügung (Aufruf

zum Beispiel durch Mausklick auf das Monitorsymbol in der Menüleiste, dem LX Panel). Das

LXTerminal erlaubt in der graphischen Benutzeroberfläche die Eingabe von Befehlstext in einer

Konsole ( auch Kommandozeile oder Terminal genannt) . In die Konsole geschriebene Befehle

werden von einer Shell interpretiert. Raspbian verwendet eine Shell namens Bash .

In das LXDE System ist der Dateimanager PCManFM eingebunden. Damit kann man Dateien und

Ordner des Dateisystems (siehe unten) betrachten und öffnen. Im Dateisystem bekommt jeder

Benutzer ein eigenes Stammverzeichnis; der Benutzer pi zum Beispiel /home/pi . Wenn man den

Dateimanager über das Menü oder die Menüleiste (Klick auf das Aktenschranksymbol) öffnet, wird

zunächst das Stammverzeichnis des Benutzers angezeigt. Wir wollen einen Ordner namens p

erzeugen, in dem später unsere Programme gespeichert werden. Dazu öffnen wir im PCManFM-

Fenster den Reiter Datei und wählen Neu erzeugen... Ordner . Im Eingabefeld überschreiben wir

dann New mit p und schließen die Aktion mit Klick auf OK ab. Mit einem Doppelklick auf das

Ordnersymbol p können wir das Unterverzeichnis p , in dem wir unsere Programme speichern

werden, öffnen. Die unterste Zeile des PCManFM-Fensters, die Statuszeile, gibt rechts den freien

Speicherplatz an, sowie (in Klammern) den Gesamtgröße des (freien und belegten) Speichers auf

der Speicherkarte.

Wen das Himbeer-Symbol in der Mitte des Bildschirms stört, kann es folgendermaßen entfernen:

Im Menü öffnet man Einstellungen - Appearance Settings und wählt (im Bereich Desktop) nach

Layout die Option No Image (statt Centre image on screen).

Später werden wir häufig in der Konsole eigene Programme aufrufen, die als ausführbare Dateien

im Ordner p gespeichert sind. Nachdem man in den Ordner p gewechselt ist, kann man ein

Programm prog , das sich in p befindet, mit dem Befehl ./prog aufrufen. Wem das zu umständlich

erscheint, kann folgendermaßen vorgehen: Man öffnet mit einem Texteditor (zum Beispiel Leafpad )

die (versteckte) Datei /home/pi/.profile und fügt am Ende folgende Zeilen ein:

# set PATH so it includes user's directory p if it exists

if [ -d "$HOME/p" ] ; then

PATH="$PATH:$HOME/p"

fi

Nach einem Neustart des Betriebssystems kann man die im Ordner p befindlichen ausführbaren

Programme mit ihrem Namen (zum Beispiel prog ) aufrufen (ohne vorangestelltes ./ ), auch wenn

man sich nicht im Ordner p befindet. Dieses Verfahren funktioniert so allerdings nur, wenn es im

15

Ordner /home/pi keine Dateien des Namens .bash_profile oder .bash_login gibt (dies ist normaler-

weise der Fall).

Wenn vor dem Systemstart das LAN-Kabel angeschlossen wurde, sollte auch bereits eine Ethernet-

Verbindung (zum Internet) bestehen. Ist dies der Fall und man fährt mit dem Mauszeiger in der

Menüleiste über das Netzwerksymbol, erscheint eine Zeile eth0: Configured ... Mit dem Befehl

ifconfig eth0

wird in der Konsole die aktive Netwerkverbindung gezeigt und man kann nach inet addr: die IP-

Adresse des Π lesen (zum Beispiel 192.168.0.100 oder ähnlich) bzw. beim Π_3B die IPv6-Adresse.

Wenn, wie oben beschrieben, der Zugriff über ein Netzwerk via SSH erlaubt wurde, kann man von

einem anderen Linux-Rechner im Netzwerk auf den Π zugreifen. Dazu gibt man in der Konsole des

anderen Linux-Rechners

ssh pi@IP-Adresse

ein, wobei statt IP-Adresse die aktuelle IP-Adresse des Π eingesetzt werden muss. Für den Zugriff

von einem Windows-Rechner aus kann man das Programm PuTTY benutzen.

Die Konfiguration des WLAN-Empfangs geschieht bei neueren Versionen des Betriebssystems

Raspbian weitgehend automatisch. Über die Benutzerschnittstelle dhcpcd-ui des Programms

dhcpcd , die ein Symbol in der Menüleiste hat, kann man für bekannte WLAN-Netzwerke das

Kennwort (WLAN-Schlüssel) eingeben, welches gepeichert wird.

Zum Auschalten des Π wählt man im Menü Shutdown und kann nach einer halben Minute die

Energieversorgung vom Π trennen.

Das Betriebssystem Raspbian legt bei der Installation eine 100 MB große Auslagerungsdatei ( swap

file ) auf der SD-Karte an. Dort werden Daten kurzzeitig gespeichert, wenn der Arbeitsspeicher ( 512

MB beim Π_1B , 1024 MB beim Π_2B und beim Π_3B) voll ist. Die Größe der Auslagerungsdatei

wird in der Datei /etc/dphys-swapfile festgelegt. Diese Datei kann mit Hilfe eines Texteditors

eingesehen und (als Root) verändert werden.

Die Konfiguration der Bildschirmauflösung und andere Festlegungen werden in einer Datei namens

config.txt im Verzeichnis /boot gespeichert (siehe oben, Abschnitt Boot, Betriebssystem und

Konfiguration), welche in der Konsole mit dem Befehl

sudo nano /boot/config.txt

im Editor (Zum Beispiel Nano , siehe unten) verändert werden kann. Das sollte man aber nur mit

Erfahrung tun.

Der Π speichert Datum und Tageszeit als sogenannte Systemzeit. Wenn eine Internetverbindung

besteht, werden Datum und Uhrzeit nach dem Start des Betriebssystems von einem sogenannten

NTP-Server (NTP = Network Time Protocol) geholt. Danach wird die Zeit mithilfe eines internen

Taktgebers des Π weitergezählt. Die Systemzeit kann man mit dem Konsolenbefehl

date

16

erfragen. Ohne Internetverbindung entspricht die Systemzeit nicht der aktuellen Zeit, da der Π

keine Echt zeituhr (real-time clock) enthält. Man kann in diesem Fall mit einem Konsolenbefehl,

zum Beispiel

sudo date 070813462016

Datum (hier: 8. Juli 2016) und Tageszeit (hier: 13 Uhr 46) manuell setzen.

Wenn man für die Textverarbeitung eigene TrueType Fonts vewenden will, kann man im Verzeich-

nis /home/pi/ ein Unterverzeichnis (Ordner) .fonts (mit Punkt am Anfang) erstellen und da

hinein die entsprechenden Dateien ( *.ttf ) kopieren.

Die Ausgabe des Tonsignals (Audio) kann entweder analog über den blauen 3,5mm-Klinkenstecker

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 in der letzten Zeile 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än-

dert werden, das mit dem Konsolenbefehl

alsamixer

aufgerufen wird. Wurde ein Verstärker am Audioausgang angeschlossen, ist es besser, dort die

Lautstärke einzustellen.

Auf dem Desktop sieht man Bildchen (Piktogr amme ), die Icons genannt werden. Die zugehörigen

Bilddateien (und weitere, die nicht auf dem Desktop dargestellt sind) haben das Format png oder

xpm und werden meistens im Ordner /usr/share/pixmaps abgelegt. Die Icons auf dem Desktop

markieren jeweils einen Desktop Shortcut, mit dem ein Programm gestartet oder ein Ordner

geöffnet werden kann. Dies geschieht, wenn man mit der linken Maustaste doppelt auf das Icon

klickt, welches dem Desktop Shortcut zugeordnet ist. Für jeden Desktop Shortcut gibt es eine

Textdatei im Ordner /home/pi/Desktop, die man mit einem Texteditor erstellen und bearbeiten kann

(siehe unten, im Abschnitt Desktop Shortcut für unser Programm). Unerwünschte Desktop

Shortcuts kann man entfernen, indem man sie mit rechten Maustaste anklickt und dann im Menü

17

auf Löschen klickt. Damit wird die zugehörige Datei aus dem Ordner /home/pi/Desktop gelöscht

und das Icon nicht mehr auf dem Desktop gezeigt. Das Programm, welches vom Shortcut gestartet

wird, bleibt erhalten. Auch die Bilddatei des Icons wird nicht gelöscht und bleibt im Ordner

/usr/share/pixmaps . Für Programme im LX Panel (dem Startmenü von LXDE) erzeugt man einen

Desktop Shortcut, indem man mit der rechten Maustaste auf den Programmnamen klickt und die

Option Dem Desktop hinzufügen wählt. Man kann dies zum Beispiel mit dem oft gebrauchten

Editor Leafpad machen. Dateien für Desktop Shortcuts findet man auch im Ordner

/usr/share/applications ; um eine davon zu benutzen, kopiert man sie in den Ordner

/home/pi/Desktop .

18

Kommandozeile (Konsole)

Die Konsole ( auch Kommandozeile oder Terminal genannt) in Form des LXTerminals erlaubt die

Eingabe von Befehlen, die von der Shell ausgeführt werden sollen. Raspbian Jessie bietet zunächst

standardardmäßig die Shell bash an. Dies kann jedoch geändert werden. Mit dem Befehl

echo $SHELL

wird der Pfad zur aktuell als Standard festgelegten Shell genannt.

Einige besondere Tastendrücke können die Arbeit mit der Shell beschleunigen. In der Shell bash

kann mit der Pfeiltaste ↑ der zuletzt eingegebene Befehl erneut aufgerufen werden. Früher einge-

gebene Befehle erreicht man durch weiteres Drücken von ↑ . Mit den zwei Pfeltasten ↓ und ↑ kann

man in den früher eingegebenen Befehlen blättern. Der Befehl

history -c

löscht die seit dem Start des Betriebssystems gesammelte Befehlsliste.

Kopieren und Einfügen mithilfe der Tastatur geschieht in der Shell bash über die Tastenkombina-

tionen Strg+Shift+C und Strg+Shift+V (aus historischen Gründen nicht mit Strg+C und Strg+V).

Einmaliges Drücken der Tabulator-Taste ermöglicht die automatische Wortergänzung, zum Beispiel

von langen Dateinamen, sofern die Zuordnung bereits eindeutig ist. Leider funktioniert das in der

Shell bash nur für die Ergänzung von alphanumerischen Zeichen im Namen. Wenn die Zuordnung

noch nicht eindeutig ist, zum Beispiel bei zwei Dateinamen mit gleichem Anfang, zeigt erneutes

Drücken die Möglichkeiten an.

In Linux-Betriebssystemen befinden sich die Dateien sind in Verzeichnissen (Ordnern), die

wiederum in übergeordneten Verzeichnissen enthalten sind. Man nennt diese Anordnung

(Dateisystem) eine hierachische Struktur oder mathematisch gesprochen: Baum. Es ist aber ein

umgekehrter Baum, denn die Wurzel (Root) steht in der Anordnung (Hierachie) ganz oben. Ein

interner Zeiger des Betriebssystems zeigt auf ein Verzeichnis im Dateisystem, das sogenannte

Arbeitsverzeichnis. Ohne besondere Angabe eines anderen Verzeichnisses beziehen sich Befehle auf

das Arbeitsverzeichnis.

Man braucht in der Kommandozeile Befehle, die das Arbeitsverzeichnis ändern. Zum Beispiel

wechselt man mit

cd uv

in das Unterverzeichnis uv des aktuellen Arbeitsverzeichnisses und mit

cd ..

in das Verzeichnis, das über dem aktuellen Arbeitsvezeichnis liegt. Mit

cd /

wechselt man in das Wurzelverzeichnis (Root). Der Befehl

pwd

19

gibt den Namen des Arbeitsverzeichnisses am Bildschirm aus.

Der Schrägstrich / allein bedeutet Wurzelverzeichnis (Root), ./ steht für das aktuelle Verzeichnis und

../ steht für das übergeordnete (nächsthöhere) Verzeichnis. Verzeichnisebenen werden in Linux-

Betriebssystemen stets durch einen einfachen Schrägstrich getrennt.

Manche Befehle können nur mit Administratorrechten ausgeführt werden, zum Beispiel für das

Löschen der Datei f eines anderen Benutzers. Dies gelingt, wenn man sudo vor den Befehl setzt:

sudo rm f

Eine Zusammenfassung wichtiger Konsolenbefehle findet man im Anhang (... Wichtige Befehle für

Kommandozeile ...). Im Web gibt es zahlreiche Beschreibungen für die Nutzung der Konsole, zum

Beispiel hier .

In Linuxsystemen, auch in Raspbian, gibt es das Konsolenprogramm fdisk zur Einrichtung und

Darstellung von Partitionen (zusammenhängende Speicherbereiche mit eigenem Namen) auf

Speichermedien (auch Datenträger genannt) mit Master Boot Record , zum Beispiel USB-Sticks,

Speicherkarten und kleinere Festplatten). Es muss mit Administratorrechten ausgeführt werden. Mit

der Option -l zeigt es die Partitionen des nach der Option genannten Datenträgers. Wird kein

Datenträger angegeben, listet der Befehl

sudo fdisk -l

die Partitionen aller Datenträger auf.

Die Partitionen sind beim Raspbian-Betriebssystem in der Datei proc/partitions aufgeführt und

können daher auch mit dem Befehl

cat /proc/partitions

angezeigt werden. Vor der Speicherkarte und ihren Partitionen werden 16 RAM-Disks (ram0 –

ram15) aufgelistet, die vom Raspbian-Betriebssystem erzeugt wurden.

Programme, die in der Konsole laufen, können in der Konsole nur Text und keine Bilder ausgeben.

Allerdings gibt es Konsolenprogramme, die mit Textzeichen einfache Schwarzweiss-Grafiken

erzeugen. Wenn eine Internetverbindung besteht, kann man zum Beispiel mit der Befehlszeile

curl wttr.in/jena

einen anschaulichen (und sehr schnell ladenden) Wetterbericht für Jena erhalten. Statt Jena kann

man natürlich auch eine andere Stadt wählen.

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 nach der Installation und auch

später von Zeit zu Zeit (zum Beispiel einmal im Monat)

20

sudo apt-get update

in die Konsole eingeben. Um die auf dem Rechner verfügbaren ("installierten") Pakete auf den

neuesten Stand zu bringen, gibt man danach noch 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

sudo apt-get install prog

ein. Wenn dieses Programm nicht mehr gebraucht wird, kann man es mit dem Befehl

sudo apt-get purge prog

vollständig (einschließlich der Konfigurationsdateien) wieder entfernen. Weitere Befehle zur

Paketverwaltung finden sich im Anhang (... Wichtige Befehle für Kommandozeile ...) .

Cronjobs

Programme, die periodisch zu bestimmten Zeiten ausgeführt werden sollen, zum Beispiel zu jeder

vollen Stunde, können als sogenannte Cronjobs (griechisch χρόνος , die Zeit) automatisch vom

Cron-Dämon (crond) des Betriebssystems gestartet werden, welcher bei Raspbian Jessie

standardmäßig im Hintergrund läuft. Nachteilig ist, dass die Programme nicht ausgeführt werden,

wenn der Rechner zu den bestimmten Zeiten ausgeschaltet ist. (Dies Problem kann mit dem

Programm Anacron gelöst werden.) Man kann ein Programm auch nicht zu einem bestimmten

Zeitpunkt einmalig ausführen lassen. (Allerdings kann man den Cron-Dämon anweisen,

Programme nach dem Starten des Rechners auszuführen.) Die Information zu Cronjobs wird für

jeden Nutzer (einschließlich root) in einer eigenen Datei, Crontab, genannt, gespeichert. Die

Crontabs der Nutzer stehen im Verzeichnis /var/spool/cron/crontabs . Außerdem gibt es eine

sytemweite Crontab namens crontab im Verzeichnis /etc .

Um die Arbeit des Cron-Dämons nicht zu stören, wird die Crontab eines Nutzers folgendermaßen

bearbeitet. Der Konsolenbefehl

EDITOR=nano crontab -e

erlaubt die Änderung (e für edit) der Crontab des aktuellen Nutzers mit dem Editor nano . Statt

nano kann auch ein anderer Editor gewählt werden. Falls noch keine Crontab existiert, wird sie

angelegt. In der Crontab wird jeder Cronjob in einer Zeile beschrieben, in der eine Zeitangabe und

das auszuführende Programm stehen. Am Ende der Crontab muss eine Leerzeile oder Kommentar-

zeile stehen. Für die auszuführenden Programme müssen die Rechte so gesetzt sein, dass sie nur

vom Nutzer ausgeführt werden können.

Die Zeitangabe besteht bei den Crontabs der Nutzer nomalerweise aus fünf Spalten mit Sternchen

(*) oder Zahlen: Minute (0-59), Stunde (0-23), Tag des Monats (1-31), Monat des Jahres (1-12),

Tag der Woche (0-6, 0 ist Sonntag). Die Spalten werden durch Leerzeichen getrennt. Spalten, die

nicht zur Einschränkung der Zeit gebraucht werden, erhalten ein Sternchen. Zum Beispiel wird mit

21

11 11 11 11 * /home/pi/p/helau.sh

die Shell-Skripte helau.sh im Verzeichnis /home/pi/p am 11. 11. um 11 Uhr 11 ausgeführt. Mehrere

Werte in einer Spalte werden durch Komma (ohne folgendes Leerzeichen) getrennt. Das Zeichen -

gibt Bereiche an und / Intervalle. Mit

*/5 8-10 * * 2,3 /home/pi/p/messung.sh

wird Dienstags und Mittwochs zwischen 8 und 10 Uhr alle 5 Minuten die Shell-Skripte messung.sh

im Verzeichnis /home/pi/p ausgeführt.

Für manche Zeitangaben gibt es eine kürzere Schreibweise:

@reboot nach jedem Start des Betriebssystems

@daily täglich, entspricht 0 0 * * *

@hourly stündlich, entspricht 0 * * * *

Ausgaben eines Cronjobs werden standardmäßig als E-Mail an den Nutzer gesandt, dessen Crontab

den Cronjob gestartet hat (und nicht in einer Konsole auf dem Bildschirm gezeigt). Man kann den

Standardausgabe strom (stdout, Datei-Deskriptor: 1) jedoch in eine Datei umleiten. Wählt man

/dev/null als Datei, wird die Ausgabe verworfen. Der Standardfehler ausgabestrom stderr hat den

Datei-Deskriptor 2. Mit der Zeile

@reboot python3 /home/pi/p/test.py >/dev/null 2>&1

oder, wenn das Pythonprogramm eine Shebang-Zeile enthält (siehe unten), mit

@reboot /home/pi/p/test.py >/dev/null 2>&1

wird das Python-Programm test.py , das im Verzeichnis /home/pi/p steht, nach jedem Systemstart

ausgeführt und die Ausgabe, einschließlich Fehlermeldungen (darum der Zusatz 2>&1) verworfen.

Mit dem Befehl

crontab -l

wird die Crontab des aktuellen Nutzers auf dem Bildschirm angezeigt (l für list) und mit

crontab -r

wird die Crontab des aktuellen Nutzers gelöscht (r für remove).

22

Editor, Browser und weitere Programme

Raspbian enthält die einfachen Texteditoren Leafpad und Nano . Leafpad hat im Gegensatz zu

Nano eine graphische Benutzeroberfläche und erlaubt das Schreiben von Programmen und Texten

ohne anspruchsvolle Formatierungen. Nano wird typischerweise in der Konsole aufgerufen, um

ohne grafische Benutzeroberfläche Konfigurationsdateien zu verändern. Raspbian Jessie enthält

auch das Office-Paket LibreOffice , welches aber, insbesondere beim Π_1B , relativ langsam

arbeitet.

Bilddateien werden standardmäßig mit dem Programm gpicview geöffnet, welches im Menü des

Desktops unter Zubehör mit dem Eintrag Bildbetrachter zur Verfügung steht und auch in der

Konsole aufgerufen werden kann. PDF-Dokumente können mit dem Programm xpdf betrachtet

werden. In der Konsole wird xpdf für eine nicht mit Passwort gesicherte PDF-Datei mit dem Befehl

xpdf pfad/zur/datei.pdf

aufgerufen und für eine passwortgesicherte PDF-Datei mit dem Befehl

xpdf -upw passwort pfad/zur/datei.pdf

Im Menü des Desktops kann xpdf unter Zubehör - PDF Viewer aufgerufen werden.

Das Laden von Webseiten aus dem Internet geschieht aufgrund der schwachen Leistung des Π

langsam. Als Browser ist bei Rasbian Jessie Epiphany bereits installiert. Alternativen wie NetSurf

oder Midori 3 (Paket midori) können über die Paketverwaltung (siehe oben) zusätzlich installiert

werden, aber Epiphany ist leistungsfähiger und kann auch Videos gut abspielen.

Weitere Programme können über die Paketverwaltung installiert werden. Statt LibreOffice kann

man für Textverarbeitung auch a biword benutzen und als Tabellenkalkulationsprogramm steht

gnumeric zur Verfügung. Mit dem Paket fonts-liberation erhält man die oft verwendeten Liberation

Fonts ; sie verbrauchen 2,2 MB Plattenplatz. Wer eine Lizenz für Microsoft Windows besitzt, kann

die entsprechenden Schriftarten auf dem Π mit dem Paket ttf-mscorefonts-installer installieren.

Zum Schreiben chinesischer Schriftzeichen installiert man scim und scim-pinyin , was 48,7 MB an

Speicher belegt.

Zur Speicherung des Bildschirminhalts (oder eines Teil davon) als Bild (Screenshot) dient s hutter .

Dieses Programm besitzt eine grafische Benutzeroberfläche, nimmt allerdings ganze 111 MB

Speicherplatz ein. Eine deutlich kleinere Variante ohne grafische Benutzeroberfläche ist scrot,

welches für Rasbian Jessie schon vorinstaliert ist. Das freie E-Book-Betrachterprogramm FBReader

kann ( unter dem Namen fbreader, Speicherbedarf: 6,4 MB ) installiert werden. Im Menü erscheint

dann unter Büro der Eintrag E-book reader , der auf den FBReader verweist. Zur Darstellung

elektronischer Schaltungen ist fritzing grundsätzlich geeignet (siehe unten, Abschnitt Schaltung 1

(Standard-LED mit Vorwiderstand) ), aber das Programm läuft langsam auf dem Π . Es belegt 142

MB im Speicher.

3 Midori arbeitet schneller, wenn man unter Einstellungen > Verhalten das automatische Laden von Bildern und die Ausführung von Skripten und Netscape-Modulen abstellt und unter Privatsphäre beide Speicher für HTML5-Internet-Daten einschaltet. Es kann auch nützlich sein, unter Programmstart die Option Letzte Reiter zeigen ohne sie zu laden zu wählen und die am häufigsten besuchte Webseite als Startseite festzulegen.

23

Wenn man das Paket youtube-dl installiert hat, kann man, unter Beachtung des Urheberrechts und

soweit vom jeweiligen Anbieter erlaubt, Videos von verschiedenen Anbietern im mp4-Format

herunterladen und anschließend mit dem omxplayer abspielen (siehe unten). Mit der URL url, die

man der Adresszeile des Browsers entnimmt, ergibt der Konsolenbefehl

youtube-dl -F url

eine Liste mit Formaten und Auflösungen, in denen das Video zur Verfügung steht. Um es mit dem

omxplayer abspielen zu können, wählt man das mp4-Format mit möglichst geringer Auflösung. Die

Zahl am Anfang der entsprechenden Zeile, zum Beispiel 18, benötigt man, um mit dem Konsolen-

befehl

youtube-dl -f 18 url

das Video herunterzuladen. Man beachte den erheblichen Speicherbedarf der Videodateien.

Die Textbeschreibungssprache LaTeX wird mit den Konsolenbefehlen

sudo apt-get install texlive texlive-lang-german

sudo apt-get install texlive-generic-extra texlive-latex-extra

installiert, womit 1126 MB auf der Speicherkarte belegt werden (mit texlive-full statt texlive wären

es mehrere GB). LaTeX-Quellcode kann auf einem normalen Texteditor , zum Beispiel Leafpad ,

geschrieben werden, aber besondere LaTeX-Editoren erleichtern die Arbeit. Wir installieren mit

sudo apt-get install gummi

noch den einfachen LaTeX-Editor Gummi , der 19,3 MB auf der Speicherkarte belegt. Er ist im

Menü des Desktops unter Büro zu finden.

Will man Shell-Skripte mit der (früher sehr beliebten) Kornshell (statt mit bash ) schreiben, kann

man das Paket ksh installieren. Für fortgeschrittene Programmierung mit Python3 (siehe unten)

benötigt man python3-dev und python3-pip , aber die sollten bereits vorhanden sein. pip (Pip Installs

Python) ist eine Paketverwaltung für Python, die ab Python Version 3.4 standardmäßig zu Python

gehört. Man kann damit spezielle Pythonmodule installieren, zum Beispiel wifi für das Arbeiten mit

WLAN-Netzen:

sudo pip3 install wifi

Wenn WLAN installiert wurde (siehe oben), kann man mit dem Modul wifi in Pythonprogrammen

WLAN-Netze bearbeiten (scannen, aktivieren usw.). Überdies enthält das Paket wifi auch Befehle

für die Konsole. Zum Beispiel zeigt der Befehl wifi scan eine Liste der empfangbaren Funk-

netzwerke mit Angabe der Signalstärke und ob sie verschlüsselt sind. Man kann diesen Befehl mit

anderen Konsolenbefehlen kombinieren (siehe oben, Abschnitt Kommandozeile (Konsole) und

Paketverwaltung). Zum Beispiel liefert

wifi scan | sort -nr

eine nach absteigender Signalstärke geordnete Liste der Funknetzwerke.

24

Zur übersichtlichen Darstellung von empfangbaren Funknetzwerken kann man auch das Programm

wicd-curses benutzen. Es kann über die normale Paketverwaltung installiert werden ( sudo apt-

get install wicd-curses ) und wird von der Konsole gestartet. Es erzeugt ein Fenster, in dem

die Empfangsstärke, Verschlüsselungsart und Kanalnummer der Funknetzwerke aufgelistet werden.

Eingabe von R über die Tastatur erneuert die Anzeige.

Zum Abspielen von Audio- und Videodateien und -streams ( zum Beispiel Internetradio ) kann man

das Programm omxplayer nutzen, das mit dem Betriebssystem Raspbian bereits installiert ist. Es

wird von der Konsole gestartet. Allerdings kann omxplayer nur wenige Dateiformate abspielen,

darunter MP3 (Audio) und MP4 (Video), jedoch keine Wiedergabeliste n (zum Beispiel M3U). Liegt

beispielsweise eine Audiodatei musik.mp3 im aktuellen Verzeichnis der Konsole, kann sie mit

omxplayer -o local musik.mp3

abgespielt werden, wobei das Audiosignal auf dem analogen Audioausgang erscheint. Mit

omxplayer -o hdmi musik.mp3

wird das Audiosignal auf dem HDMI Audiokanal ausgegeben.

Der omxplayer kann keine Audio-CDs von einem externen Abspielgerät (DVD-Brenner) wieder-

geben. Es gibt jedoch Internetradio mit Streams im MP3-Format, die mittels omxplayer abgespielt

werden können, falls eine Internetverbindung besteht ( Programmbeispie l 1 , Programmbeispie l 2 ).

Eine Liste geeigneter Internetradio-Sender und ihrer URLs findet man im Anhang.

Leider stellen nicht alle Radiosender einen MP3-Stream bereit, den der omxplayer wiedergeben

kann. Mehr Sender kann man hören, wenn man den VLC media player installiert:

sudo apt-get install vlc

Damit steht vlc , in der Version 2.2.0 oder höher, zur Verfügung. Einige weitere Codecs kann man

durch Austausch der Codec-Bibliothek mit dem Konsolenbefehl

sudo apt-get install libavcodec-extra

installieren.

vlc kann nicht ohne weiteres als Root aufgerufen werden, sondern nur von Benutzern ohne Root-

Rechte. Da vlc, insbesondere mit graphische r Benutzero berfläche , mehr Rechenzeit braucht, sollte

man ihn nur einsetzen, wenn der omxplayer ungeeignet ist. Etwas schneller arbeitet vlc, wenn man

ihn mit dem Befehl cvlc von der Kommandozeile aufruft. Da vlc mehr Audioformate, zum Beispiel

das PLS Format verarbeitet, kann man mehr Sender als mit dem omxplayer hören. Listen mit

Radio- und Fernsehsendern, die man über das Internet empfangen kann, finden sich im Anhang.

Leider unterstützt der VLC media player bisher nicht die die Hardwarebeschleunigung des Π .

Daher sollten Videos (in geeigneteten Dateiformaten) mit dem omxplayer abgespielt werden.

vlc kann Audio-CDs von einem externen Abspielgerät (DVD-Brenner) direkt wiedergeben. Um die

Wiedergabe von der Kommandozeile auslösen, gibt man

cvlc cdda://sr0

25

ein. Will man nur einen Track , zum Beispiel Track 10, abspielen, gibt man

cvlc cdda://sr0 --cdda-track 10

ein. Erfolgt die Wiedergabe nicht flüssig, kann man überlegen, ob die gewünschten Tracks zunächst

auf der microSD-Karte (beziehungsweise, bei älteren Π-Modellen,auf der SD- oder SDHC-Karte)

gespeichert werden sollten. Im Rahmen des rechtlich Erlaubten (Privatkopie von CDs ohne Kopier -

schutz) kann man mihilfe des vlc den Inhalt einer Audio-CD in ein anderes Audio-Format, zum

Beispiel MP3 , wandeln (konvertieren) und auf einem Datenträger des Π speichern. Die gespei-

cherte MP3-Datei lässt sich dann problemlos mit dem omxplayer oder dem vlc wiedergeben. Startet

man vlc mit graphischer Bedienoberfläche, lassen sich einzelne Tracks (Spuren) einer Audio-CD

folgendermaßen konvertieren:

Im Reiter Medien des vlc-Menüs wählt man die Option Konvertieren/Speichern ... und klickt

danach, im Reiter Medium , die Option Audio-CD an. Im Feld Laufwerk sollte dann der Pfad zur

Audio-CD erscheinen, zum Beispiel /dev/sr0 . Nach Startposition Titel wählt man die Nummer des

Tracks aus ( > 1 ) , der konvertiert werden soll und klickt auf Konvertieren / Speichern . Nach Profil

wählt man das gewünschte Audio-Format, zum Beispiel Audio - MP3 und in das Feld nach Ziel Ziel-

datei: schreibt man den Pfad zu einer neuen Datei, zum Beispiel /home/pi/Downloads/neu.mp3 , in

welcher der Track gespeichert werden soll. Nach Klick auf den Button Start erfolgt die Konver-

tierung und Speicherung. Die Konvertierung aller Tracks in einem Arbeitsgang ist so jedoch nicht

möglich.

Folgendes Shell-Skript konvertiert eine Audio-CD mit 21 Tracks (siehe Variable n ) in MP3-

Dateien, deren Name datei_??.mp3 ist (siehe Variablen f und d ), wobei statt ?? die zweistellige

Nummer des Tracks (siehe Variable x ), eventuell mit führender Null, eingesetzt wird:

#!/bin/bash

n=21 ; f="datei_" ; i=1

echo ; echo "Audio-CD , $n Tracks -> $n MP3-Dateien"

while [ $i -le $n ]

do

printf -v x "%02g" $i # zweistellige Tracknummer

d="/home/pi/$f$x.mp3" # MP3-Dateinamen erzeugen

cvlc cdda://sr0 --cdda-track $i --sout "#transc\

odeacodec=mp3:stdaccess=file, dst=$d" vlc://quit

i=`expr $i + 1`

done

echo "Konvertierung und Speicherung beendet." ; echo

Nachdem man es als Datei rip gespeichert und mit chmod a+x rip ausführbar gemacht hat

(siehe unten) kann man es mit ./rip aufrufen.

Als Audioplayer für Dateien im MP3-Format kann man auch das Programm mpg123 verwenden,

welches nach der Installation weniger als 400 kB Speicherplatz verbraucht. Es wird von der

Konsole, zum Beispiel mit dem Befehl

mpg123 -vC datei.mp3

26

gestartet. Mit der Option -v werden mehr Informationen angezeigt und mit -C wird die Steuerung

über die Tastatur ermöglicht. Beim Abspiel mit der Option -C werden durch Drücken der H-Taste

die verfügbaren Tastaturbefehle aufgelistet und Q beendet das Abspielen der Datei. Statt einer Datei

kann auch ein (mit seiner URL angegebener) Internet-Radiosender gehört werden. Playlists werden

abgespielt, wenn die Option -@ verwendet wurde. Die Option -b 2048 puffert 2 MB Daten, um

Unterbrechungen (zum Beispiel durch einen zeitweise verlangsamten Internet-Datenstrom oder

kurzzeitig erhöhte CPU-Belastungen) zu vermeiden. Folgender Befehl spielt einen Radiosender

(sofern eine Internetverbindung besteht):

mpg123 -b 2048 -C@ http://stream3.polskieradio.pl:8908/listen.pls

Jeder Π hat eine eigene Seriennummer. Mit dem Befehl

cat /proc/cpuinfo

wird der Inhalt der Datei cpuinfo im Verzeichnis /proc angezeigt und in der mit Serial: beginnenden

Zeile auch die Seriennummer. Mit dieser kann man eine Lizenz erwerben, die das Abspielen von

Videos im MPEG-2 Format ermöglicht.

Speziell für den Π gibt es ein Kameramodul (Camera Module), das an der CSI-2 Buchse ange-

schlossen wird. Alternativ kann man eine Webcam über einen USB-Port mit dem Π verbinden. Für

viele Webcams hat Raspbian bereits einen passenden Treiber installiert; hier eine Liste geprüfter

Webcams. Um Bilder oder Videos mit der Webcam aufnehmen zu können, muss man noch ein

entsprechendes Programm installieren. Zunächst ist fswebcam zu empfehlen, denn es benötigt nur

105 kB im Speicher und wird in der Konsole aufgerufen. Der Befehl

fswebcam -r 640x480 test.jpg

nimmt ein Bild mit der Auflösung 640 x 480 auf und speichert es in der Datei test.jpg (die es noch

nicht geben darf). Die Bildaufnahme mit fswebcam kann durch Verwendung von Optionen noch

verfeinert werden. Auskunft über die Optionen gibt der Konsolenbefehl

man fswebcam

Man kann die gewählten Optionen in einer Konfigurationsdatei, hier /home/pi/p/bild.cfg genannt,

speichern. Ihr Inhalt könnte zum Beispiel so aussehen:

# fswebcam - Konfiguration

device "/dev/video0"

input 0

delay 1

resolution 640x480

set brightness=80%

set contrast=16%

skip 5

frames 1

scale 320x240

banner-colour "#FF000000"

line-colour "#FF000000"

27

text-colour "#000000"

title "Webcam Testbild"

timestamp "%d.%m.%Y %H:%M"

jpeg 90

save "/home/pi/p/bild.jpg"

Um eine Bildaufnahme durchzuführen, gibt man dann den Konsolenbefehl

fswebcam -c /home/pi/p/bild.cfg

ein. Das Bild wird, wie in der Konfigurationsdatei bestimmt, in der Datei /home/pi/p/bild.jpg

gespeichert. Falls eine Datei gleichen Namens bereits existiert, wird diese überschrieben. Wenn man

in einem Python-Programm (siehe unten) ein Bild von der Webcam aufnehmen lassen will, kann

man den obigen Konsolenbefehl mithilfe folgender Python-Programmzeilen ausführen lassen:

from subprocess import call

call(["fswebcam", "-c", "/home/pi/p/bild.cfg"])

Komfortabler als fswebcam ist das Programm camorama (Speicherbedarf: 894 kB), das mit einer

grafischen Benutzer ober fläche gesteuert wird. Nach der Installation findet man camorama im Menü

unter Grafik. Man kann auch cheese (Speicherbedarf: 88,2 MB) benutzen, aber das belastet den

Prozessor sehr und läuft nur mit neueren Π-Modellen (insbesondere: Π_3B ) flüssig.

Anwendungsbeispiel: Das QX3 Computer-Mi k ros kop von Intel Play ist ein altes Lernspielzeug mit

Webcam. Wenn man keine weitere Webcam angeschlossen hat, liefert camorama ohne weiteres das

Bild. Danach kann man mit einem der folgenden beiden Konsolenbefehle

v4l2-ctl --set-ctrl=illuminator_1=1

v4l2-ctl --set-ctrl=illuminator_2=1

die untere, beziehungsweise die obere Lampe einschalten. Entsprechend werden die Lampen mit

v4l2-ctl --set-ctrl=illuminator_1=0

v4l2-ctl --set-ctrl=illuminator_2=0

wieder ausgeschaltet.

Wenn eine Verbindung zum Internet besteht, kann man, mithilfe eines Browsers, Nachrichten auf

der Webseite eines Nachrichtenportals anschauen. Will man nur einen Überblick oder nur kurze,

aber schnell verfügbare Nachrichtentexte, kann man einen Web-Feed mit einem einen Feedreader ,

zum Beispiel Newsbeuter , lesen. Nach der Installation von newsbeuter (Speicherbedarf: 2,2 MB)

kann man das Programm in der Konsole mit dem Befehl

newsbeuter

starten. Zunächst erhält man allerdings eine Fehlermeldung, weil noch keine Web-Feeds einge-

tragen wurden. Man öffnet mit einem Editor (zum Beispiel Leafpad) die Konfigurationsdatei

sudo leafpad /home/pi/.newsbeuter/urls

und trägt zum Beispiel einige Nachrichten-Feeds mit den Zeilen

http://www.tagesschau.de/xml/atom

28

http://www.srf.ch/news/bnf/rss/1922

http://rss.cnn.com/rss/cnn_topstories.rss

https://sputniknews.com/export/rss2/archive/index.xml

ein. Nach dem Schließen der Datei kann man das Programm newsbeuter benutzen.

In manchen Anwendungen möchte man eine E-mail automatisch vom Π versenden lassen. Dafür

benötigt man zunächst ein E-Mail-Konto mit E-Mail-Adresse (zum Beispiel: [email protected]) bei

einem E-Mail-Anbieter (zum Beispiel GMX).

Der Umweg über einen E-Mail-Anbieter ist notwendig, da E-Mails, welche direkt von einem

privaten Rechner gesandt werden, von empfangenden E-Mail-Anbietern oft nicht angenommen

werden (um Spamming zu erschweren).

Dann installiert man die Pakete mailutils und ssmtp . Darauf öffnet man mit einem Editor (zum

Beispiel Leafpad) die Konfigurationsdatei ssmtp.conf ,

sudo leafpad /etc/ssmtp/ssmtp.conf

und ersetzt deren Inhalt, im Beispiel für ein E-Mail-Konto bei GMX, durch folgende Zeilen:

[email protected]

mailhub=mail.gmx.net:465

hostname=gmx.net

UseTLS=YES

[email protected]

AuthPass=PASSWORT

FromLineOverride=NO

wobei PASSWORT das Passwort des E-Mail-Kontos ist. Nach dem Schließen dieser Datei öffnet

man entsprechend die Konfigurationsdatei revaliases ,

sudo leafpad /etc/ssmtp/revaliases

und ersetzt deren Inhalt, im Beispiel für ein E-Mail-Konto bei GMX, durch folgende Zeile:

pi:[email protected]:mail.gmx.net:465

wobei pi der Name des -Benutzers ist, der E-Mails versenden darf. Nach dem Schließen der Datei

kann man mit einem Konsolenbefehl eine E-mail versenden, zum Beispiel

echo "Hallo" | mail -s "Test" -A anl.txt [email protected]

wobei "Hallo" eine Zeichenkette ist, die den zu sendenden Text enthält. Nach der Option -s folgt

eine (kurze) Zeichenkette für die Betreffzeile der E-mail (hier: "Test"). Nach der Option -A

folgt der Name einer Datei (mit vollständigem Pfadnamen), hier anl.txt , die als Anlage mit der

E-Mail versandt werden soll. Am Ende der Zeile steht die E-Mail-Adresse, an die gesendet werden

soll (Empfänger, in obigem Beispiel: [email protected]).

Ein Nachteil des beschriebenen Verfahrens ist jedoch, dass das Passwort des E-Mail-Kontos

unverschlüsselt in der Konfigurationsdatei ssmtp.conf gespeichert wird.

Es gibt auch zahlreiche Spiele für den Π , die mit der Paketverwaltung (siehe oben) geladen werden

können. Beispiele: frozen-bubble (Speicherbedarf: 27 MB) quadrapassel (entspricht Tetris, Spei-

29

cherbedarf: 12,2 MB) und gmchess (chinesisches Schach, Speicherbedarf: 7,5 MB). Zum

Schachspielen kann man knights (Schachbrett) und gnuchess (Schach-"Engine") installieren (Spei-

cherbedarf zusammen: 166 MB), zur Schach-Analyse scid (einschließlich scid-data, Speicherbedarf

zusammen: 40,7 MB).

Steuerung der GPIOs über a) das Betriebssystem oder b) das Programm raspi-gpio

a) Steuerung über das Verzeichnis /sys/class/gpio/

Digitale Ein- und Ausgaben über die GPIOs lassen sich mithilfe des Betriebssystem-Kernel steuern,

der mit Anwenderprogrammen über Dateien im Verzeichnis /sys/class/gpio/ kommunizieren kann.

Lesen und Schreiben dieser Dateien ist mit einer beliebigen Programmiersprache möglich, ohne

dass besondere Hilfsprogramme oder Programmbibliotheken nötig wären. Die Steuerungsmöglich-

keiten erfassen aber nicht alle Eigenschaften der GPIOs.

Im folgenden Beispiel wird GPIO 23 (Pin 16 von P1) über die Shell angesprochen. Eine passende

elektronische Schaltung wird in Experiment 1 beschrieben; zunächst soll hier die Handhabung der

Dateien erläutet werden.

Um GPIO 23 zu nutzen und gleichzeitig für andere Programme zu sperren, legen wir zunächst eine

neue Schnittstelle in Form von Dateien an. In der Shell geht dies über den Befehl

echo 23 > /sys/class/gpio/export

Damit wird ein Verzeichnis namens /sys/class/gpio/gpio23 eingerichtet, das (unter anderem) vier

Textdateien enthält, die jeweils einen Wert (als Zahl oder Wort) enthalten, nämlich (Standardwert in

Klammern, der bei erster Verwendung des GPIOs nach dem Booten gesetzt wird): active_low ( 0 )

direction ( in ), edge ( none ) und value ( 0 ). Nach dem Wert enthält die Datei noch ein

Zeilenvorschub-Zeichen.

Durch Lesen und Schreiben der in diesen Dateien gespeicherten Werte wird der GPIO gesteuert. Ob

der GPIO als Ein- oder Ausgang bertrieben wird, legt der Wert in der Datei direction fest. Mögliche

Werte sind in und out . Der logische Zustand des GPIOs ( 0 oder 1 ) steht in der Datei value .

Wenn der GPIO als Eingang definiert wurde, liest man den Wert in Datei value ; mit GPIO als

Ausgang schreibt man ihn. Die Datei active_low enthält den Wert 0 oder 1, welcher die Spannungs-

werte festlegt, die den logischen Zuständen des GPIO entsprechen. Bei 0 in active_low wird der

logische Zustand 0 der Spannung 0 V und 1 der Spannung 3,3 V zugeordnet; bei 1 in active_low ist

es umgekehrt. Der Wert in active_low muss gesetzt sein, bevor Datei value gelesen oder geschrie-

ben wird. Folgende Befehle definieren GPIO 23 als Ausgang und geben den Spannungswert 3,3 V

(als logischen Zustand 1) aus:

echo 23 > /sys/class/gpio/exportecho out > /sys/class/gpio/gpio23/directionecho 0 >/sys/class/gpio/gpio23/active_lowecho 1 >/sys/class/gpio/gpio23/value

Die erste Zeile scheibt man nur einmal, um GPIO 23 zur weiteren Verwendung zu belegen. Die

30

zweite Zeile ist hier überflüssig, da der Wert in Datei active_low mit 0 vorbelegt ist (siehe oben).

Nach der Verwendung im eigenen Programm sollte man die GPIOs wieder freigeben, so dass

andere Programme darauf zugreifen können. Im Beispiel mit GPIO 23 geschieht dies durch

echo 23 > /sys/class/gpio/unexport

In manchen Anwendungen wird ein GPIO als Eingang geschaltet und ändert zum Beispiel seinen

Wert, wenn ein Taster gedrückt wird. In einem Programm, das auf die Änderung des Eingangs-

signals (Drücken des Tasters) reagiert, könnte man fortlaufend in einer Schleife den Wert des

GPIOs einlesen und prüfen ( Polling ). Aber das ist nicht effektiv, denn der Prozessor wird unnötig

stark belastet. Alternativ kann man den Prozessor beauftragen, die Wertänderung eines GPIOs in

Form eines Interrupts mitzuteilen. Der Prozessor macht dies effektiver als eine Polling-Schleife.

Der Interrupt kann ausgelöst werden, wenn sich der GPIO-Zustand von 0 auf 1 ändert ( rising ), von

1 auf 0 ändert ( falling ) oder eins von beiden ( both ) geschieht. Dafür wird in die Datei edge der

entsprechende Wert ( none , rising , falling oder both ) geschrieben. Das Auffangen und die Ver-

arbeitung eines Interrupts hängt dann allerdings von der Programmiersprache ab. In Python kann

man die Module select oder selectors verwenden.

Wer GPIOs in einem Python-Programm ansteuern will, kann auch das Modul RPi.GPIO benutzen

(siehe Abschnitt Modul RPi.GPIO zur Steuerung der GPIOs ).x

b) Steuerung über das Programm raspi-gpio

Das Programm raspi-gpio kann ohne Root-Rechte in der Konsole ausgeführt werden. Es liefert

Informationen zu normalen und alternativen Funktionen der GPIOs und es ermöglicht Input (Ein-

lesen des digitalen Zustands) und Output (Setzen des Zustands eines GPIOs) über die GPIOs. Das

Programm liest und schreibt direkt in die Register (Speicherzellen der CPU), welche die GPIOs

elektronisch steuern. Es umgeht das Betriebssystem und dessen Treiberprogramme. Dies kann zu

unerwarteten und unerwünschten Wechselwirkungen mit gleichzeitig aktiven Treibern führen, die

ebenfalls auf die GPIOs zugreifen. Man sollte das Programm daher nur einzeln zu Testzwecken

oder zur Fehlersuche einsetzen. Mehr Information zum Programm erhält man mit dem Konsolen-

befehl

raspi-gpio help

Mit dem Programm kann man zum Beispiel GPIO 14 als Ausgang ( op ) schalten und auf logisch 0 =

low ( dl ) oder logisch 1 = high ( dh ) setzen

raspi-gpio set 14 op dl

raspi-gpio set 14 op dh

oder den Zustand von GPIO 14 auslesen,

raspi-gpio get 14

oder die alternativen Funktionen von GPIO 14 abfragen:

raspi-gpio funcs 14

31

Gnuplot und Mathematica (mit Aufgaben 1 und 2)

Gnuplot (dazu: Aufgabe 1)

Zur graphischen Darstellung von Messdaten oder mathematischen Funktionen gibt es das Pro-

gramm gnuplot, das mit Textanweisungen von der Konsole oder aus einem anderen Programm

heraus gesteuert wird. Weitere Information findet man auf der gnuplot homepage .

Wir installieren, wie oben beschrieben, Gnuplot (Paket gnuplot, oder alternativ Paket gnuplot-x11,

Specherbedarf jeweils 4 MB) und starten dann das Programm in der Konsole mit dem Befehl

gnuplot

Variablen können definiert werden,

a = 2.5

ebenso Funktionen. Die üblichen mathematische Funktionen (zum Beispiel sqrt() für die Wurzel-

funktion und exp() für die Exponentialfunktion zur Basis e) und Operatoren (wobei mit ** poten-

ziert wird) können verwendet werden. Als Beispiel für eine Funktionsdefinition schreiben wir

f(x) = a*sin(x)

und mit dem Befehl plot , abgekürzt p , wird damit eine zweidimensionale Graphik erzeugt:

p f(x)

Information zu einem Gnuplot-Befehl erhält man mit help , kurz h , gefolgt vom Befehl; Beispiel:

h plot

Dreidimensionale Graphiken werden mit dem Befehl splot erzeugt, Beispiel:

splot 3*sin(x)*exp(y/30)

Mit der Maus lässt sich die Grafik drehen.

Zum Beenden des Programms dient der Befehl quit oder abgekürzt einfach

q

Wir schauen uns nun einige wichtige Gnuplot-Befehle an:

Die Verwendung des westeuropäischen Zeichensatzes ISO 8859-1 wird mit

set encoding iso_8859_1

festgelegt. Der Titel einer Graphik kann mit

set title "Titel"

bestimmt werden. Für die Klammerung von Zeichenketten kann man in Gnuplot entweder (wie im

vorigen Beispiel) doppelte Anführungszeichen verwenden oder einfache4, wie hier:

set title 'ein "wichtiges" Ereignis'

4 Es gibt Ausnahmen, in denen nur doppelte Anführungszeichen verwendet werden können. Zum Beispiel in dem Befehl set format x "%H : %M\nUhrzeit" , in dem bei der x-Achsenbeschriftung \n für eine neue Zeile sorgen soll.

32

Die doppelten Anführungszeichen ( " ) sind in obigem Beispiel Teil der Zeichenkette ein "wichtiges"

Ereignis , die von einfachen Anführungszeichen ( ' ) begrenzt wird.

Die Beschriftung von x- und y-Achsen erfolgt mit

set xlabel "Zeit [\265s]"

set ylabel "Temperatur [\260C]"

wobei \265 im Zeichensatz ISO 8859-1 für μ und \260 für ° steht. Mit

unset logscale xy

legt man fest, dass x- und y-Achse nicht logarithmisch, sondern linear sein sollen. Mit

set logscale x

wird die x-Achse dagegen logarithmisch geteilt (und Entsprechendes gilt für die y-Achse). Anfang

und Ende der Achsen werden automatisch bestimmt, wenn nicht, zum Beispiel mit

set xrange [0:pi]

ein Intervall für die x-Achse (und entsprechend für die y-Achse) festgelegt wird. Dabei bedeutet pi

die mathematische Konstante π (≈ 3,14). Mit

set pointsize 3

kann man die Größe der gezeichneten Punkte ändern (hier auf den dreifachen Standardwert). Mit

set time

werden Datum und Zeit am linken unteren Rand der Graphik vermerkt (Zeitstempel).

In einer Datei f.dat gespeicherte Daten können ebenfalls mit plot dargestellt werden, wobei die Da-

tenspalten (für x- und y-Werte) durch Leerzeichen, nicht Kommata, getrennt sein sollen. Beispiel:

plot "f.dat" with linespoints title "Messwerte"

Wenn die Datei in einer dritten Spalte Fehlerbalken enthält, kann man die Darstellung der (durch

eine Linie verbundenen) Messwerte mit einer Zeichnung der Fehlerbalken überlagern. Beispiel:

plot "f.dat" w l title "", "f.dat" w err t "MW \261 StA"

Hier steht w abgekürzt für with , l für lines, err für errorbars , t für title und \261 im Zeichensatz

ISO 8859-1 für ± . (Die Abkürzung StA könnte hier Standardabweichung bedeuten, wenn die in der

dritten Spalte gespeicherten Werte die Fehlerbalken als Standardabweichung enthalten.)

Erzeugte Graphiken können auch in Bilddateien exportiert werden. Zum Beispiel wird mit

set terminal pngcairo mono

set output "m.png"

eine Ausgabe im png-Bidformat vorbereitet und der Name der Bilddatei festgelegt. Die Option

mono bewirkt, dass die Graphik schwarz/weiß (ohne Farben) gezeichnet wird. Mit

33

replot

wird eine zuvor erzeugte Graphik nochmals gezeichnet, diesmal aber (wie vorher festgelegt) als

png-Bild, das in der Datei m.png gespeichert wird.

Befehlsfolgen können auch in einer Textdatei batch.txt gespeichert werden. In Gnuplot wird mit

load "/home/pi/p/batch.txt"

die in der Datei batch.txt , welche im Verzeichnis /home/pi/p liegt, gespeicherte Befehlsfolge

ausgeführt. Wenn batch.txt im aktuellen Verzeichnis ist, braucht man /home/pi/p/ vor batch.txt nicht.

Wenn Gnuplot mit

gnuplot -e "dateiname='m.png'" batch.txt

gestartet wird, arbeitet Gnuplot zunächst den nach -e in Anführungszeichen gesetzten Befehl (hier

die Zuweisung dateiname='m.png' ) ab, danach die Befehlsfolge in batch.txt und endet schließlich.

Gnuplot kann auch Zeitangaben verarbeiten. Als Beispiel

nehmen wir den nebenstehenden Inhalt einer Datei namens

bsp.dat . In der linken (1.) Spalte sind Datum und Uhrzeit

in einem bestimmten Format angegeben, in der rechten (2.)

Spalte irgendwelche Messdaten als Dezimalzahlen. Die

beiden Spalten werden durch ein Leerzeichen getrennt. Das Format der Zeitangaben beinhaltet

jeweils zweistellige Angaben für Tag, Monat, Jahr, Stunde, Minute und Sekunde. Zwischen diesen

Angaben stehen verschiedene Trennzeichen ( . / : ). Leerzeichen sollte man nicht als Trenn-

zeichen zwischen Zeitangaben verwenden, da Leerzeichen zur Trennung von Datenspalten dienen.

Um die Messdaten der zweiten Spalte als Funktion der Zeitangaben in der ersten Spalte als Graphik

darzustellen gehen wir folgendermaßen vor. Der Gnuplot-Befehl

set xdata time

teilt Gnuplot mit, dass für die x-Achse Zeitangaben erwartet werden. Mit set timefmt wird

dann ein Format für die Zeitangaben bestimmt, zum Beispiel so:

set timefmt '%d.%m.%y/%H:%M:%S'

Dabei repräsentiert %d den Tag (01 ... 31), %m den Monat (01 ... 12), %y das Jahr (mit zwei

Ziffern), %H die Stunde (00 ... 23), %M die Minute (00 ... 59) und %S die Sekunde (00 ... 59). Die

Trennzeichen ( . / : ) müssen genau so zwischen den Zeitangaben stehen, wie im Format

angegeben. Die Darstellung der Zeit auf der x-Achse wird beispielsweise mit einem Befehl

set format x "%H:%M\n %S s"

bestimmt, so dass Stunde und Minute, getrennt von einem Doppelpunkt, angegeben werden und in

einer neuen Zeile darunter, nach einem Leerzeichen, die Sekunden, gefolgt einem Leerzeichen und

dem Buchstaben s . Das Zeichenpaar \ n ist eine sogenannte Escape-Sequenz, welche einen Zeilen -

vorschub (neue Zeile) bewirkt. Mit

34

11.02.14/14:58:53 23.45

11.02.14/14:59:23 24.90

11.02.14/14:59:53 25.19

11.02.14/15:60:23 23.82

plot "bsp.dat" using 1:2 with lines title ""

werden die Messdaten (2. Spalte) als Funktion der Zeit (1. Spalte) gezeichnet. Wenn Zeitangaben in

einer Datei stehen, muss (bei einigen Gnuplot-Versionen) explizit festgelegt werden, welche Spalte

der Datei für die x-Werte und welche für die y-Werte verwendet werden soll. Hier wird mit using

1:2 festgelegt, dass die erste Spalte (mit den Zeitangabe) für die x-Achse und die zweite Spalte für

die y-Achse verwendet werden soll.

Gnuplot kann vorgegebene Funktionen durch Veränderung von Parametern optimal an eine Mess-

punktmenge anpassen (fitten). Gehen wir von einer linearen Funktion (Geraden)

f(x) = a*x+b

aus, die an Daten in der Datei f.dat (mit x- und y-Werten) angepasst werden soll, schreiben wir

fit f(x) "f.dat" via a,b

um den Fit durchzuführen und zeichnen das Ergebnis mit

plot "f.dat" with points title "", f(x) with l title "fit"

Wenn man aktuelle Werte von Variablen in eine Zeichenkette einfügen will, kann man die Funktion

sprintf() benutzen. So zum Beispiel:

set title sprintf("Fit mit f(x) = %.3f x + %.3f", a, b)

Damit werden die aktuellen Werte der Variablen a und b als Gleitkommazahlen mit drei Nach-

kommastellen in den Text des Titels eingefügt, was zum Beispiel nach einem Fit sinnvoll sein kann.

Aufgabe 1

Schreiben Sie die Messpunkte aus nebenstehender Tabelle in eine

Textdatei namens m, wobei die x-Werte in der ersten und die y-Werte

in der zweiten Spalte stehen sollen. In jeder Zeile sollen x- und y-Wert

durch ein Leerzeichen getrennt sein.

Mit Gnuplot soll eine Funktion f(x) = a · e b · x + c an die Daten ange-

passt (gefittet) und die Parameter a, b und c bestimmt werden. Die

Messwerte und die angepasste Funktion sollen in einer Graphik

gezeichnet werden, die als Bilddatei (Format png) gepeichert wird.

35

x y

0,5 0,5

3 5

5,5 10

7 20

9,5 50

Mathematica (dazu: Aufgabe 2)

Mit dem Betriebssystem Raspbian wird Mathematica kostenlos bereitgestellt, ein mächtiges Werk-

zeug für computergestütztes wissenschaftliches Rechnen (Scientific Computing). Version 1 wurde

1988 von Stephen Wolfram und seiner Firma Wolfram Research veröffentlicht. Es wird seitdem

ständig erweitert, so dass es heute für viele natur- und ingenieurwissenschaftliche Bereiche

besondere Unterprogrammpakete (packages) gibt. Nachteilig sind hohe Lizenzkosten und die

gewöhnungsbedürftige Art des Programmierens. Andererseits verfügt Mathematica über sehr starke

Befehle, mit denen schwierige Probleme schnell gelöst und graphisch dargestellt werden können.

Allerdings ist die Ausführung vom des umfangreichen Programms auf dem Raspberry langsam.

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. Um das Notebook leicht lesbar zu halten, kann der Inhalt von Cells,

die zum Beispiel eine Zwischenrechnung enthalten, ausgeblendet werden. Die Dokumentenstruktur,

das heisst der Aufbau aus Cells, wird am rechten Rand des Dokuments gezeigt. Ausgeblendete Cells

können bei Bedarf eingeblendet werden. Es ist auch möglich Hyperlinks einzubauen, die den

Sprung von einer Cell zu einer anderen im gleichen oder einem anderen Dokument ermöglichen.

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.

Nach Starten von Mathematica geben wir in eine Eingabe-Zelle die Zeile

4.5*(2^2-2)/(3+7.4/Pi)

ein und drücken Shift-Enter. Das Ergebnis (1.68052) erscheint in einer Ausgabe-Zelle. Übliche

arithmetische Operatoren ^ * / + - ( ) werden verwendet und Ganzzahlen (zum Beispiel 2 oder 3)

von Fließkommazahlen (zum Beispiel 4.5 oder 7.4) unterschieden. ^ steht für "hoch" (Exponent)

und Pi für die mathematische Konstante π . Ein Leerzeichen kann, wie in der mathematischen

Schreibweise üblich, den Multiplikationsoperator * ersetzen. Funktionen erhalten ihre Argumente in

eckigen Klammern. Die Wurzel von x schreibt man in Mathematica als Sqrt[x] und die Quadrat-

wurzel aus 2 ist daher

Sqrt[2]

Wird dies in eine Eingabe-Zelle geschrieben und Shift-Enter gedrückt, erhält man als Ausgabe-Zelle

√2

Da keine numerische Näherung verlangt wurde, gibt Mathematica das Ergebnis symbolisch aus.

36

Eine numerische Näherung ( 1.41421 ) wird ausgegeben, wenn der Ausdruck in der Eingabe-Zelle

mit //N abgeschlossen wird

Sqrt[2]//N

und damit Argument der Funktion N ist ( N[ Sqrt[ 2 ] ] ) . Wir schreiben nun in eine Eingabe-Zelle

x = E Log[10,1000]

und erhalten, nach Drücken von Shift-Enter, in einer Ausgabe-Zelle

3

Das Zeichen E in der Eingabe-Zelle ( in der Ausgabe-Zelle) steht für die Eulersche Zahl. Die

Funktion Log[a,b] bildet den Logarithmus von b zur Basis a. Das Gleichheitszeichen weist der

Variablen x einen Wert zu (Zuweisungsoperator).

Als Beispiel für die Programmierung der graphischen Ausgabe einer Funktion tippen wir 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, Joined -> 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 Punkte. Die fünfte Zeile zeichnet beide Einzelgraphiken in einer

neuen Graphik (g3), siehe Abbildung unten rechts, wobei der Bereich der x-Achse von der erst-

genannten 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 2

Tabellieren und zeichnen Sie mit

Mathematica die Funktion √(n!), das heißt: Wurzel aus n Fakultät, im Definitionsbereich [1,10] !

37

Programmieren mit Python

Erstes Programm: "Hallo!", Beispielprogramm (Zeit, Rundung, formatierte Ausgabe)

Python ist die Programmiersprache, welcher der Π seinen Namen verdankt. Sie ist mit dem

Betriebssystem Raspbian Jessie in zwei Versionen installiert, nämlich 2.7.9 und 3.4.2 . Wir

verwenden grundsätzlich Python 3, aber die meisten Programme laufen auch mit Python 2 .

Verfügbar ist auch die integrierte Entwicklungsumgebung IDLE . Sie hat jedoch einige Schwächen

und wird in den später beschriebenen Projekten nicht benutzt. Man kann jedoch mit IDLE leicht

einzelne Pythonbefehle ausprobieren oder kurze Programme testen und sollte das Programm dafür

beim Lernen der Programmiersprache verwenden. Daher wollen wir es uns kurz ansehen:

Im Menü, unter Entwicklung , klicken wir auf Python 3 (IDLE) und es öffnet sich ein Fenster für

IDLE3 mit dem Namen Python Shell . Nach dem Prompt >>> blinkt ein Cursor an der Stelle, wo

wir einen Python-Befehl eingeben können. Wir schreiben

print("Hallo Welt!")

und drücken die Eingabetaste. In der Zeile darunter erscheint das Ergebnis. In diesem Fall wurde

der Text, welcher der Funktion print übergeben wurde, auf dem Bildschirm angezeigt. Die Bestand-

teile eines Befehls und das Ergebnis werden durch verschiedene Farben (zum Beispiel grün für

Zeichenketten) gekennzeichnet. Man kann IDLE wieder verlassen, indem man im Reiter File auf

die Option Exit klickt. Eine (englische) Dokumentation für IDLE findet man hier .

In der Konsole kann mit dem Befehl

sudo idle3

IDLE (für Python 3) mit Root-Rechten gestartet werden.

Erstes Programm: "Hallo!"

Wir schreiben im Folgenden alle Programme mit dem einfachen Texteditor Leafpad, welcher Teil

der LXDE Desktop-Umgebung ist. Unser erstes Programm ist:

#!/usr/bin/python3

print("Hallo!")

Es ist hilfreich, wenn die Zeilennummern angezeigt werden. Dazu klickt man im Leafpad-Menü, im

Reiter Optionen, auf Zeilennummern .

Die erste Zeile des Programms, Shebang genannt, weist das Betriebssystem an, die Datei, die

unseren Python-Code enthält, mit dem Programm python3 auszuführen, welches im Ordner /usr/bin

liegt.5

5 Allgemein gilt: Beim Aufruf einer auszuführenden Datei (die zum Beispiel Python-Code oder ein Shell-Skript enthalten kann) in der Konsole wird der Aufrufbefehl zunächst von der Standard-Shell analysiert. Wird das Programm, mit dem die Datei ausgeführt werden soll, zum Beispiel Python3 oder ein bestimmter Shell-Typ, im Aufrufbefehl genannt, dann wird es gestartet und die auszuführende Datei als Argument übergeben. Wenn das Programm, mit dem die Datei ausgeführt werden soll, nicht im Aufrufbefehl genannt wird, liest die Shell die erste Zeile der auszuführenden Datei (also die Shebang-Zeile). Steht am Zeilenanfang #! , dann wird das danach

38

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.6 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 Python-

Version installiert ist. Dies ist bedeutsam, weil die Syntax mit neuen Versionen verändert wird.

#!/usr/bin/python3

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 Funk-

tionen arbeiten will, muss man entsprechend das Modul math einbinden.

# leitet einen einzeiligen Kommentar in Python ein (entspricht // in der Programmiersprache C).

Mit dem Zeichenpaar \ 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 Quell -

text eines Computerprogramms mit einem Backslash ( \ ) eingeleitet werden. Will man verhindern,

dass ein Zeichenpaar \ n in einer Zeichenkette als Steuerzeichen gedeutet wird, muss man den Back-

slash mit einem zweiten Backslash maskieren. Man schreibt dann also \ \ n .

Beispielprogramm (Zeit, Rundung, formatierte Ausgabe)

Führen Sie folgendes Pytho n-Programm in gewohnter Weise aus.

#!/usr/bin/python3

# -*-coding: utf-8 -*-

import time

s = time.time()

genannte Programm gestartet und diesem die auszuführende Datei als Argument übergeben.6 Dem Befehl chmod folgt eine Zeichenkette, in der zunächst Benutzertypen einbuchstabig angegeben werden (u =

Besitzer der Datei, g = Gruppe, o = andere, a = alle Benutzer), dann mit + oder - bestimmt wird, ob Rechte erteilt oder entzogen werden sollen, und schließlich die betreffenden Rechte einbuchstabig benannt werden (r = lesen, w =schreiben, x = ausführen). chmod a+x erteilt allen Benutzern das Ausführungsrecht.

39

print(s)

time.sleep(3)

s = time.time()

print(s)

text1 = time.strftime("%d.%m.%y/%H%:M:%S")

a=round(3.453,2)

b=round(13.001,2)

print(a)

print(b)

text1 = "Es sind %.0f Sekunden seit dem 1. 1. 1970 vergangen." % s

text2 = "a = %5.2f °C" % a

text3 = "b = %5.2f °C" % b

print(text1)

print(text2)

print(text3)

Mit der Zeile # -*- coding: utf-8 -*- gibt man einen Zeichensatz vor, so dass (nicht nur Ascii-

Zeichen, sondern unter anderem auch) das Grad-Zeichen ° verwendet werden kann.

Mit import time wird das Modul time eingebunden. Damit stehen unter anderem die Funktionen

time() , strftime() und sleep() zur Verfügung. Die Funktion time() des Moduls time liefert die Anzahl

der Sekunden, die seit dem 1. Januar 1970 (ein willkürlich gesetzter Nullpunkt) vergangen sind, als

Gleitkommazahl. Mit time.sleep(3) wird die Ausführung des Programms für 3 s angehalten. Statt

einer 3 kann eine andere ganze Zahl oder eine Gleitkommazahl eingesetzt werden.

Die Funktion strftime(format) liefert das aktuelle Datum und die aktuelle Uhrzeit in der von der

Zeichenkette format bestimmten Weise (ähnlich wie bei Gnuplot, siehe oben). Dabei steht %H für

die Stunde (00 ... 23), %M die Minute (00 ... 59), %S die Sekunde (00 ... 59), %d für den Tag (01 ...

31), %m den Monat (01 ... 12), %y das Jahr mit zwei Ziffern (00 ... 99) und %Y das Jahr mit vier

Ziffern (0000 ... 9999). Übrigens kann die Funktion strftime(format) auch mit einem zweiten

Argument aufgerufen werden, welches einen Zeitstempel enthält, der dann (statt der aktuellen Zeit)

formatiert ausgegeben wird.

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 von Zahlen

mittels print zu erreicht. Jede auszugebende Zahl wird in der Zeichenkette durch %format ersetzt,

wobei format die Formatierung angibt. Nach der Zeichenkette folgen, nach dem %-Zeichen, die

Variablen, welche die zu formatierenden Zahlen enthalten.

In format kann vor dem Punkt die Anzahl der Zeichen zur Darstellung der Zahl, nach dem Punkt die

Anzahl der Nachkommastellen angegeben werden. Der Buchstabe am Ende von format bestimmt

die Darstellungsart: d oder i zeigen nur den ganzzahligen Teil, f zeigt eine Dezimalzahl (Gleit-

kommazahl ohne Exponent) und e oder E zeigt eine Gleitkommazahl in Exponentialschreibweise.

40

Als Dezimalzeichen dient bei Python ein Punkt (wie bei anderen Programmiersprachen) statt eines

Kommas (wie bei deutscher Darstellung). Mit einer solchen Formatierung können Zahlen in einer

Spalte untereinander ausgegeben werden.

.0f bedeutet, dass eine Gleitkommazahl (float) ohne (0) Nachkommastellenausgegeben wird. 5.2f

bedeutet, dass 5 Zeichen zur Darstellung einer Gleitkommazahl ausgeben werden, einschließlich

Dezimalpunkt und zweier Nachkommastellen. Vor dem Dezimalpunkt können also höchstens noch

zwei Stellen stehen.

GUI mit Python, Modul tkinter

In der Programmiersprache Python 2 ist das Modul Tkinter, in Python 3 entsprechend tkinter (klein-

geschrieben) 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/python3

# -*- coding: utf-8 -*-

# Datei gui.py (oder gui_py.txt) mit einem Python-Programm, das

# eine grafische Benutzeroberfläche mithilfe von tkinter erzeugt

#

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)

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

41

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 (ä, ö, ü) verwen-

det 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

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 (hier zum Beispiel

ivory , tan , gold und pink ). Die beim Π verfügbaren Farbnamen sind in der Datei

/usr/share/x11/rgb.txt aufgelistet.

In tkinter gibt es für widgets (zum Beispiel Label) die Methode after , welche nach einer bestimm-

ten Zeit die Ausführung einer Prozedur (oder Funktion) veranlasst. Wenn die Methode after inner-

halb dieser Prozedur steht, entsteht ein wiederholter Aufruf der Prozedur. Damit lassen sich perio-

disch ablaufende Prozeduren erstellen, ohne dass die Abarbeitung der mainloop unterbrochen wird.

Als Beispiel führen Sie bitte folgendes Python-P rogramm in gewohnter Weise aus.

#!/usr/bin/python3

# Datei zaehler.py (oder zaehler_py.txt) mit einem Python-

# Programm, das die Verwendung der tkinter-Methode after zeigt

#

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 die Methode sleep (siehe unten) nicht verwendet werden, da damit die Abarbeitung

der mainloop unterbrochen wird. Das Programm reagiert dann nicht mehr auf Ereignisse und nicht

einmal die Größe des Fensters kann verändert werden.

42

Modul RPi.GPIO zur Steuerung der GPIOs

Die GPIOs können von einem Pythonprogramm (unter anderem) über das Modul RPi.GPIO

angesprochen werden, das mit dem Betriebssystem Raspbian bereits installiert ist. Es ist üblich,

dem Modul beim Einbinden im Programm den Namen GPIO zu geben:

import RPi.GPIO as GPIO

und wir werden es im folgenden auch so halten. In früheren Versionen des Betriebssystems

Raspbian mussten einige Methoden des Moduls mit Root-Rechten ausgeführt werden. Das ist mit

Raspbian Jessie nicht mehr nötig. Die Version des benutzen Moduls ist in der Konstanten

GPIO.VERSION gespeichert und kann mit der print-Funktion angezeigt werden:

print("GPIO-Version: "+GPIO.VERSION)

Für die GPIOs gibt es verschiedene Namensschemata: GPIOs können über die Nummer des Pins

auf der Stiftleiste P1 angesprochen werden oder über die BCM-Kanalnamen des System-on-a-Chip .

Festgelegt wird dies mit der Methode setmode , welche die Konstante GPIO.BOARD (mit dem Wert

10) oder GPIO.BCM (mit dem Wert 11) als Argument bekommen kann. Wir werden im Folgenden

stets die BCM-Kanalnamen verwenden:

GPIO.setmode(GPIO.BCM)

Es ist bei den Methoden des Moduls üblich, die Namen der Konstanten (zum Beispiel GPIO.BCM)

und nicht direkt deren Wert (zum Beispiel 11) zu übergeben, da dadurch der Programmcode für den

Nutzer leichter lesbar ist.

Bei der Nutzung des Moduls RPi.GPIO gibt der Python Interpreter möglicherweise Warnhinweise

aus, die beim Testen nützlich, im fertigen Programm aber stören können. Mit dem Befehl

GPIO.setwarnings(False)

kann man Warnhinweise des Interpreters (nicht aber RuntimeWarnings) unterdrücken.

Jeder GPIO kann entweder zur digitalen Eingabe (input) oder Ausgabe (output) benutzt werden. Die

Methode setup legt für einen GPIO (erstes Argument der Methode) den Modus (zweites Argument

der Methode) fest. Der Modus Eingabe wird durch die Konstante GPIO.IN (Wert 1), der Modus

Ausgabe durch GPIO.OUT (Wert 0) festgelegt. Folgende Befehle bestimmen GPIO 22 zur Eingabe

und GPIO 23 zur Ausgabe:

GPIO.setup(22, GPIO.IN)

GPIO.setup(23, GPIO.OUT)

Man sollte nicht unnötig GPIOs mit Sonderfunktion benutzen. GPIOs 2 und 3 können (zusammen)

für einen I 2 C Datenbus verwendet werden und haben jeweils einen, nicht abschaltbaren, internen

1,8 kΩ Pullup-Widerstand (siehe oben, Abschnitt Digitale Anschlusspunkte: GPIOs). Wenn GPIO 4

für einen Eindraht-Bus konfiguriert wurde, ist seine Nutzung für einfache Ein- oder Ausgabe-

funktionen eingeschränkt (siehe Fußnote im Abschnitt Experiment 3: Temperatursensor am

Eindraht-Bus).

Digitale Ausgabe bedeutet, dass eine logische 0 (0 V) oder 1 (3,3 V) an den GPIO gegeben wird.

43

Der Ausgabewert kann durch eine Konstante GPIO.LOW (oder 0 oder False) oder GPIO.HIGH

(oder 1 oder True) angeben werden. Folgendes setzt GPIO 23 auf logisch 1 (high):

GPIO.output(23, GPIO.HIGH)

Es ist auch möglich, mit einem output-Befehl mehrere GPIO-Ausgänge zu schalten, indem im

ersten Argument eine Liste von GPIOs und im zweiten Argument ein Tupel mit denzugehörigen

Ausgabewerten übergeben wird. Zum Beispiel schaltet der Befehl

GPIO.output( [23,24], (0,1) )

GPIO 23 auf logisch 0 (low) und GPIO 24 logisch 1 (high).

Ein anfänglicher Ausgabewert kann auch schon mit der Methode setup bestimmt werden, indem

nach den zwei oben beschriebenen Parametern noch der Schlüsselwortparameter initial mit einem

Wert (GPIO.LOW oder GPIO.HIGH) als Argument übergeben wird. Beispiel:

GPIO.setup(23, GPIO.OUT, initial=GPIO.LOW)

Bei der digitalen Eingabe wird das Potential am GPIO (siehe oben, Abschnitt Digitale Anschluss-

punkte: GPIOs) in die Zahl 0 oder 1 übersetzt. In Python wird die Zahl 0 dem logischen Wert False

und 1 dem dem logischen Wert True zugeordnet. In folgendem Beispiel erfolgt eine Ausgabe in

Abhängigkeit vom Wert des, als Eingang geschalteten, GPIO 22 :

if GPIO.input(22):

print("GPIO 22 ist high")

Für digitale Eingänge kann ein interner Pullup- oder Pulldown-Widerstand sinnvoll sein. Ein

Pullup- oder Pulldown-Widerstand wird beim Aufruf der Methode setup angefordert, indem nach

den beiden ersten Parametern noch der Schlüsselwortparameter pull_up_down mit einem Wert

(GPIO.PUD_OFF, GPIO.PUD_UP oder GPIO.PUD_DOWN) als Argument übergeben wird. Zum

Beispiel wird mit dem Befehl

GPIO.setup(22, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

GPIO 22 in den Modus Eingabe gesetzt und ein Pulldown-Widerstand (mit einem Wert zwischen 50

und 65 kΩ, siehe Abschnitt Digitale Anschlusspunkte: GPIOs) zugeschaltet. Wenn der Schlüssel-

wertparameter pull_up_down nicht benutzt wird, ist kein Pullup- oder Pulldown-Widerstand

zugeschaltet (GPIO.PUD_OFF).

Am Ende eines Programms, das GPIOs ansteuert, sollten die GPIOs in den Standardzustand

(Eingabe-Modus ohne Pullup- oder Pulldown-Widerstand) zurückgesetzt werden, in dem die

irrtümliche Verbindung eines GPIOs mit Masse (GND), 3,3 V oder einem anderen GPIO

ungefährlich ist. Außerdem sollte dem Betriebssystem mitgeteilt werden, dass die GPIOs nicht mehr

benutzt (freigegeben) werden. Dies alles geschieht mit der Methode cleanup :

GPIO.cleanup()

Es ist aber meistens unschädlich, wenn der Aufruf von cleanup unterbleibt.

GPIOs werden oft verwendet, um die Ausführung eines Programms durch einen Schalter (oder

44

Taster) zu beeinflussen. Dafür muss der Zustand eines GPIOs im Eingabe-Modus abgefragt werden.

Um schnell auf eine Zustandsänderungen des Schalters reagieren zu können, kann man die input

Methode in kurzen Zeitabständen periodisch aufrufen und das Ergebnis auswerten. Dieses, Polling

genannte Verfahren, wird im Abschnitt Daten eingeben mit Python-Programm verwendet.

Nachteilig ist dabei die starke Belastung des Prozessors, so dass sich dieser wenig um andere

Prozesse kümmern kann, die gleichzeitig (parallel) ablaufen.

Als Alternative, die den Prozessor nur wenig belastet, kann man im Programm den Prozessor

beauftragen, selbst auf bestimmte Ereignisse zu achten. Ein Ereignis (event) bedeutet in diesem

Zusammenhang, dass ein bestimmter GPIO seinen Zustand von low auf high wechselt (rising edge)

oder von high auf low wechselt (falling edge). Den entsprechenden Methoden, welche Ereignisse

erkennen sollen, wird als Argument entweder GPIO.RISING , GPIO.FALLING oder GPIO.BOTH

übergeben. Das letzte bedeutet, dass die Methode sowohl auf eine rising edge als auch auf eine

falling edge reagieren soll. Wenn das Ereignis eintritt, wird der gerade laufende Prozess unter-

brochen (Interrupt) und die Information über das Ereignis gespeichert (und danach der Programm-

ablauf fortgesetzt) oder sofort eine Funktion aufgerufen, die auf das Ereignis reagiert.

Wenn die Ausführung eines Programms solange unterbrochen werden soll, bis ein Ereignis eintritt,

kann man die Methode wait_for_edge verwenden.7 Während der Wartezeit des Programms können

andere Prozesse vom Betriebssystem weitergeführt werden. Im folgenden Beispiel wartet ein

Programm auf das Einschalten von GPIO 22 :

GPIO.setmode(GPIO.BCM)

GPIO.setup(22, GPIO.IN)

GPIO.wait_for_edge(22, GPIO.RISING)

print("GPIO 22 hat von low auf high gewechselt.")

Wenn ein Programm in einer Schleife verschiedene Dinge tut und dabei auch auf ein vergangenes

Ereignis reagieren soll, kann man folgendermaßen vorgehen:

GPIO.setmode(GPIO.BCM)

GPIO.setup(22, GPIO.IN)

GPIO.add_event_detect(22, GPIO.RISING)

while True:

print("Immer wieder wird dieser langweilige Satz ausgegeben.")

if GPIO.event_detected(22)

print("GPIO 22 hat von low auf high gewechselt.")

In obigem Beispiel legt die Methode add_event_detect fest, auf welches Ereignis reagiert werden

soll. Die Methode event_detected prüft, ob das Ereignis in der Vergangenheit, aber nach der letzten

Prüfung (sofern es bereits eine gab), eingetreten ist.

Mit der Zeile while True: wird eine Endlos schleife eingeleitet. Normalerweise enthält der

7 Die Ereignisverarbeitungsmethoden (zum Beispiel wait_for_edge) können bei GPIOs mit Sonderfunktion (zum Beispiel GPIO 4, nachdem der Ein draht-Bus aktiviert wurde, siehe Abschnitt Temperaturmessung von der Konsole)zu einer Fehlermeldung führen. Am einfachsten vermeidet man diese durch Nutzung anderer GPIOs.

45

Schleifenkörper von Enlosschleifen eine Abbruchbedingung, aber in obigem Beispiel wurde, der

Kürze halber, darauf verzichtet. In der Schleife wird wiederholt der "langweilige Satz" ausge-

geben. Nachdem GPIO 22 eingeschaltet wurde, wird zusätzlich (einmal) der Satz "GPIO 22 hat von

low auf high gewechselt." ausgegeben. Anders als bei einer Umsetzung mit Polling sorgt der

Prozessor hier dafür, dass das Einschalten von GPIO 22 nicht verpasst wird.

Wenn der Zustand eines GPIO Eingangs mit einem Taster oder Schalter verändert wird, kann das

Prellen Probleme bereiten. Dagegen hilft das Festlegen einer Zeitdauer bouncetime , die bestimmt

wie lange nach einem Ereignis gewartet wird, bis ein gleichartiges Ereignis erneut registriert wird.

In obigem Beispiel kann der Aufruf der Methode add_event_detect so abgeändert werden :

GPIO.add_event_detect(22, GPIO.RISING, bouncetime=100)

Damit wird die bouncetime auf 100 ms festgelegt.

In obigem Beispiel reagiert das Programm auf das Ereignis erst beim Aufruf der Methode

event_detected und das kann, abhängig von den anderen Anweisungen in der Schleife, lange nach

dem Ereignis geschehen. Will man dagegen schnell auf ein Ereignis reagieren, kann mit den

Methoden add_event_detect und add_event_callback auch ein eigener Thread gestartet werden, in

welchem eine Rückruffunktion (callback function) sofort auf das Ereignis reagiert.

Die Methode remove_event_detect erlaubt es, die Ereignisverarbeitung wieder abzuschalten. Zum

Beispiel für GPIO 22 mit folgendem Befehl :

GPIO.remove_event_detect(22)

Die Ereignisverarbeitung mit dem Modul RPi.GPIO funktioniert oft gut, aber in manchen Program-

men treten Laufzeitfehler auf, die von Fehlern des Moduls herrühren. Man sollte daher die Funktio-

nalität der Ereignisverarbeitung bei der Programmentwicklung schrittweise prüfen.

46

Noch mehr Python

In diesem Abschnitt werden Python-Module vorgestellt, die nicht bei der Durchführung der unten

beschriebenen Experimente gebraucht werden, aber trotzdem nützlich sein können: feedparser,

matplotlib.pyplot, shutil, statistics, urllib.request, vlc und webbrowser. Man sollte darauf achten,

dass sich der Dateiname eines Pythonprogramms vom Modulnamen unterscheidet.

Feedreader im Pythonprogramm: feedparser

Wenn man das Modul Universal Feed Parser ( feedparser ) mittels

sudo pip3 install feedparser

installiert hat, kann man es für einen Feedreader in einem Pythonprogramm nutzen:

#!/usr/bin/python3

# -*- coding: utf-8 -*-

# Python verarbeitet und zeigt WebFeeds

import feedparser

import time

url = "http://www.welt.de/?service=Rss"

f = feedparser.parse(url) # WebFeed holen

t = f['feed']['title'] # Titel des WebFeeds

print("\n" + t + "\n") # Feedtitel anzeigen

for i in f.entries:

print(i.title) # Eintrags-Title

dp = i.published_parsed # Datumsobjekt

d = time.strftime("%d. %B %Y", dp) # Datum

d = d.replace(' 0',' ') # ohne führende 0

print(d) # Datum (Format Tag, Monat, Jahr)

print(i.summary) # Eintrags-Text

print(i.link) # Eintrags-Verweis

print() # Leerzeile nach Eintrag

Damit wird ein Webfeed der Tageszeitung Die Welt in der Konsole ausgegeben.

Wissenschaftliche Grafiken: matplotlib.pyplot

Daten und mathematische Funktionen kann man mithilfe des Moduls matplotlib.pyplot darstellen,

nachdem dieses mit

sudo apt-get install python3-matplotlib

installiert wurde. Im Python-Programm importiert man das Modul üblicherweise unter dem Namen

plt :

import matplotlib.pyplot as plt

Das folgende Beispiel ist ein Python-Programm zur Darstellung eines zweidimensionalen Linien -

diagramms. Die Daten zweier Funktionen, y1(x1) und y2(x2) , werden hier als Listen vorgegeben.

(Stattdessen könnte man auch eine mathematische Funktion mit dem Modul numpy numerisch

bestimmen und die Werte in Form eines Arrays angeben.) Im Beispiel wird gezeigt, wie die Einzel-

heiten der grafischen Darstellung (zum Beispiel Liniendicken und Beschriftungen) gesteuert werden

können. Gegen Ende wird ein Dateiname erzeugt, der das aktuelle Datum enthält, und die Grafik

47

darin gespeichert. Die Punktdichte wird dabei auf 300 dpi (statt des Standardwerts von 100 dpi)

gesetzt. Schließlich wird die Grafik mit dem Programm gpicview angezeigt, welches Teil des

Raspbian-Betriebssystems ist.

#!/usr/bin/python3

# -*- coding: utf-8 -*-

# Modul matplot.pyplot als plt (üblicher Name) importieren

import matplotlib.pyplot as plt

from time import strftime

from subprocess import call

# Daten: Listen der x1-Werte, y1-Werte, x2-Werte, y2-Werte

x1 = [-2, -1, 0, 2, 3] # Liste der x1-Werte

y1 = [11.2, -2.8, -0.5, 2.5, 2.3] # Liste der y1-Werte

x2 = [-1.5, -0.5, 0.5, 1.5, 2.5] # Liste der x2-Werte

y2 = [-2.5, 4.0, 10.2, 8.8, 5.1] # Liste der y2-Werte

# Plot-Parameter und einige ihre möglichen Werte

# color c: b blau, g grün, k schwarz, r rot, y gelb, w white

# linewidth lw, linestyle ls

# linestyle ls: '-' oder '--' oder ':' oder '-.' oder 'steps'

# marker: 'o' oder 's' oder 'v' oder '*' oder 'x' oder '+'

# markersize ms, markeredgewidth mew, markerfacecolor mfc

# Grafikfenster, Breite x Höhe) 8 Zoll x 6 Zoll, Auflösung 100 dpi

fig = plt.figure(figsize=(8, 6), dpi=100, facecolor='w')

# Überschrift ( Parameter y positioniert die Überschrift vertikal )

plt.title(r'Titel: Zwei Funktionen', color='k', size=22, y=1.05)

# Erzeugung einer xy-Grafik der Funktion y1(x1)

l1 = r'$\mathdefaulty_1(x_1)$' # Text mit tiefgestellten 1en

p1 = plt.plot( x1, y1, label=l1 ) # mit label l1 für Legende (s.u.)

# Formatierung der Linie (line) für y1(x1)

plt.setp( p1, color='r', lw=2.0, ls='-' ) # 'r' = rot

# Formatierung der Datenpunkte (marker) für y1(x1)

plt.setp(p1, marker='o', ms=10, mew=2, mfc='r' )

# Erzeugung einer xy-Grafik der Funktion y2(x2)

l2 = r'$\mathdefaulty_2(x_2)$' # Text mit tiefgestellten 2en

p2 = plt.plot( x2, y2, label=l2 ) # mit label l2 für Legende (s.u.)

# Formatierung der Linie (line) für y2(x2)

plt.setp( p2, color='g', lw=2.0, ls='-' ) # 'g' = grün

# Formatierung der Datenpunkte (marker) für y2(x2)

plt.setp(p2, marker='s', ms=9, mew=2, mfc='g' )

# Legende (Erklärung der Bedeutung der Daten-Linien)

# plt.legend( loc='best', frameon=1, borderaxespad=1.5 )

plt.legend( loc='best', frameon=1, borderaxespad=1.5, fontsize=16 )

# loc: 'best','upper left','upper right','lower left','lower right'

# frameon: 0 (kein Rahmen um Legende) oder 1 (Rahmen um Legende)

# borderaxespad: Abstand des Legendenrahmens von den Achsenlinien

# Bereich und Formatierung der Achsen:

xmin = -2.5 ; xmax = 3.5 # untere und obere Grenze der x-Achse

48

ymin = -4.0 ; ymax = 12 # untere und obere Grenze der y-Achse

plt.axis( [xmin, xmax, ymin, ymax] ) # Achsenbereiche setzen

plt.xlabel(u'Temp. (\u00B0C)', color='k', size=18) # x-Achsentitel

plt.ylabel(u'Länge (\u00B5m)', color='k', size=18) # y-Achsentitel

# u (Unicode-Symbole): ° \u00B0, micro = \u00B5, Delta = \u0394

plt.xticks(color='k', size=16) # Format der x-Achsen-Tick-Werte

plt.yticks(color='k', size=16) # Format der y-Achsen-Tick-Werte

plt.tick_params('both', width=2, length=10, color='k') # Tick-Striche

# Achsenformatierung: Dicke und Farbe der Achsenlinien (spines)

ax= plt.gca() # gca bedeutet 'get current axes' (ax = Achsenobjekt)

ax.spines['left'].set_color('k') # 'k' = schwarz

ax.spines['left'].set_linewidth(2)

ax.spines['right'].set_color('k') # 'k' = schwarz

ax.spines['right'].set_linewidth(2)

ax.spines['top'].set_color('k') # 'k' = schwarz

ax.spines['top'].set_linewidth(2)

ax.spines['bottom'].set_color('k') # 'k' = schwarz

ax.spines['bottom'].set_linewidth(2)

# Rand der Grafik automatisch optimieren

plt.tight_layout()

# Grafik speichern (Dateiname mit Datum) und anschliessend zeigen

datei = 'plt_' + strftime("%y%m%d") + '.png' # erzeuge Dateinamen

plt.savefig(datei, dpi=300) # Speicherung mit 300 dpi (statt 100 dpi)

plt.close() # schließe aktuelle Instanz von plt (matplotlib.pyplot)

call( [ "gpicview", datei ] ) # Anzeige der Grafik

Man kann dieses Beispielprogramm als Vorlage für eigene Liniendiagramme verwenden.

Zugriff auf das Dateisystem: shutil

Das Modul shutil erlaubt Operationen mit Dateien und Verzeichnissen. Im folgenden Beispiel wird

die bestehende Datei /home/pi/p/altdatei kopiert. Der Name (einschießlich Pfad) der neuen Datei ist

/home/pi/p/neudatei. Falls eine Datei diesen Namens existiert, wird sie überschrieben.

#!/usr/bin/python3

# -*- coding: utf-8 -*-

from shutil import copy

copy("/home/pi/p/altdatei", "/home/pi/p/neudatei")

Man kann auch prüfen, ob ein Programm (ausführbare Datei) existiert und gegebenenfalls den Pfad

zum Programm erfahren. Im folgenden Beispiel wird geprüft, ob es Programme mit dem Namen

mplayer beziehungsweise mplaxer gibt und, wenn ja, der Pfad zum Programm angezeigt.

#!/usr/bin/python3

# -*- coding: utf-8 -*-

from shutil import which

l = ["mplayer", "mplaxer"]

for i in l:

s = which(i)

if s is None:

print("Programm "+i+" gibt es nicht!")

49

else:

print("Pfad zum Programm "+i+": "+s)

Wenn mplayer installiert wurde, wird hier der Pfad /usr/bin/mplayer ausgegeben.

Einfache Statistik: statistics

Einige einfache Parameter der beschreibenden Statistik (zum Beispiel Mittelwert und Standard-

abweichung) kann man mit dem Modul statistics berechnen:

#!/usr/bin/python3

# -*- coding: utf-8 -*-

# Python berechnet

import math, statistics

dat = [11.25, 4.75, 7.0, 5.25, 12.5, 7.75]

mwt = str( round( statistics.mean(dat), 1) )

med = str( round( statistics.median(dat), 1) )

ssd = str( round( statistics.stdev(dat), 1) )

sem = str( round( statistics.stdev(dat)/math.sqrt(len(dat)), 1) )

print('\nGegeben sei ein Stichprobe mit den')

print("Daten: " + ", ".join(map(str,dat)))

print("als Teilmenge einer unbekannten Grundgesamtheit." + "\n")

print("Die Stichprobe enthält " + str(len(dat)) + " Datenpunkte.")

print("\nWir schätzen für die Grundgesamtheit:")

print("Arithmetischer Mittelwert = " + mwt)

print("Median (Zentralwert) = " + med)

print("Standardabweichung (aus der Probe) = " + ssd + "\n")

print("Standardfehler des (geschätzten) Mittelwerts = " + sem + "\n")

Mehr Module für statistische Berechnungen bietet die Python-Erweiterung Numpy.

URL (Quellcode einer Webseite) ohne Browser öffnen: urllib.request

Das Modul urllib.request ermöglicht den Zugriff auf Dateien im Internet, zum Beispiel den

Quellcode einer Webseite anhand der URL. Die URL bezeichnet den Ort der Datei im Internet und

das Netzwerkprotokoll (Übertragungsformat), mit dem auf die Datein zugegriffen werden kann

(zum Beispiel HTTP). Für die Datei im Internet wird vom Modul urllib.request ein dateiähnliches

Objekt (englisch: file-like object) erzeugt. Es ist keine echte Datei, da Schreiboperationen ausge-

schlossen sind. Das Lesen ist aber auf die gleiche Weise möglich wie bei einer echten Datei.

Das folgende Python-Programm öffnet eine Webseite (deren URL in der Variablen url gespeichert

ist), genauer gesagt: die Datei mit dem Quellcode, und bildet sie in der Instanz fl als dateiähnliches

Objekt ab. Der Inhalt (Quellcode) wird gelesen und in der Variablen b gespeichert. Da der Inhalt der

Variablen b vom Datentyp bytes ist, wird decodiert und in der Variablen s als Zeichenkette

(Datentyp string) gespeichert. Die Instanz fl wird danach nicht mehr gebraucht und (wie eine Datei)

geschlossen. Die entsprechenden Befehle befinden sich im Programmteil, der mit # Zugriff auf

Quelltext einer Webseite mit URL url überschrieben ist.

#!/usr/bin/python3

# -*- coding: utf-8 -*-

import urllib.request, re

50

# Zugriff auf Quelltext einer Webseite mit URL url

url = "http://kurse.boerse.ard.de/ard/indizes_einzel\

kurs_uebersicht.htn?i=159096" # url mit Aktien-Kursen

fl = urllib.request.urlopen(url) # öffne Webseite url

b = fl.read() # b : Webseite als bytes-String

s = b.decode("utf-8") # s : Webseite als Zeichenkette

fl.close() # file-like object fl schließen

# Listen bilden der Aktiennamen (l1) und Aktien-Kurse (l2)

s = s[ s.find("Alle Aktien") : s.find("Performance DAX") ]

r1 = re.compile(r"<strong>([^<>]3,)</strong></td>")

r2 = re.compile(r"(\d1,4,\d2)&nbsp;&euro;&nbsp;")

l1 = re.findall(r1,s) ; l2 = re.findall(r2,s)

# Ergbnisse der 30 DAX-Aktien in der Konsole ausgeben

if len(l1) == 30 and len(l1) == 30:

for a, k in zip(l1, l2): print(a, k)

else:

print("Fehler bei der Auswertung der Webseite.")

In den weiteren Programmteilen wird die gesuchte Information aus der in s gespeicherten

Zeichenkette entnommen und in der Konsole als Text ausgegeben. Die im Beispielprogramm

durchgeführten Operationen mit Zeichenketten und Regulären Ausdrücken sollen an dieser Stelle

nicht erläutert werden.

Die Ausgabe in der Konsole listet die aktuellen Kurse der 30 Dax-Aktien auf (sofern eine

Internetverbindung besteht).

Mit dem urllib.request kann man auch prüfen, ob auf eine URL im Internet erreichbar ist. Folgen-

den Programm prüft, ob auf einen bestimmten Internetradiosender zugegriffen werden kann.

#!/usr/bin/python3

# -*- coding: utf-8 -*-

from urllib import request

try:

url = "http://kulturradio.de/livemp3"

fl = request.urlopen(url, timeout=2)

fl.close()

print("Verbindung OK zur URL "+url)

except request.URLError:

print("Keine Verbindung zur URL "+url)

Abhängig vom Ergebnis der Prüfung könnte man dann den Sender mit einem Mediaplayer spielen.

Mediaplayer VLC im Pythonprogramm: vlc

Wenn man das Modul vlc mittels

sudo pip3 install python-vlc

installiert hat, kann man den Mediaplayer VLC in einem Pythonprogramm steuern:

#!/usr/bin/python3

51

# -*- coding: utf-8 -*-

import vlc

import time

radio1 = "http://inforadio.de/livemp3"

radio2 = "http://1940sradio1.co.uk:8100/1"

i = vlc.Instance() # vlc-Instanz

mp = i.media_player_new() # Mediaplayer

m = i.media_new(radio1) # Medium: Webradio

mp.audio_output_set('alsa') # Audioausgabe

mp.audio_output_device_set('alsa', 'hw:0,0')

mp.audio_set_volume(100) # Lautstärke 100%

mp.set_media(m) # Medium -> Mediaplayer

mp.play() # Wiedergabe mit Mediaplayer

print("20 s Pause, um Radio 1 zu hören")

time.sleep(20) # Programm-Pause (20 s)

mp.stop() # Wiedergabe ausschalten

m = i.media_new(radio2) # Medium: Webradio

mp.set_media(m) # Medium -> Mediaplayer

mp.play() # Wiedergabe mit Mediaplayer

print("20 s Pause, um Radio 2 zu hören")

time.sleep(20) # Programm-Pause (20 s)

mp.stop() # Wiedergabe ausschalten

Obiges Programm spielt (mit Internetverbindung) zwei Webradiosender jeweils 20 s lang ab.

Webseite im Browser öffnen: webbrowser

Mit dem Modul webbrowser kann man aus einem Pythonprogramm den Webbrowser aufrufen und

eine Webseite (oder allgemein eine URL) darstellen lassen:

#!/usr/bin/python3

# -*- coding: utf-8 -*-

# Python öffnet Webseite im Browser

import webbrowser

u = "https://de.wikipedia.org/wiki/Jena"

webbrowser.open(u)

print("Programm läuft weiter. Ende")

Das Pythonprogramm läuft dabei weiter.

52

Experiment 1: LED ein- und ausschalten

Schaltung 1 (LED) und Steuerung der GPIOs von der Konsole

Um mit einem GPIO eine Leucht -

diode an- und auszuschalten, kann

man folgender Weise vorgehen. Der

Leuchtdiodenschaltkreis besteht aus

der Reihenschaltung einer Leucht -

diode (Standard-LED) und eines

passenden Vor wider stands R (zum

Beispiel 330 Ω oder 470 Ω). Die

Anode der Leucht diode (siehe Bild rechts, A , langes Beinchen) wird mit GPIO 23

(Pin 16 der Stiftleiste P1) verbunden, die Kathode ( B , kurzes Beinchen) mit einem

Ende des Widerstands. Das andere Ende des Wider stands wird mit GND (Pin 9 von

P1) verbunden.

Widerstände können mit einem Farbcode versehen sein. Beim Farbcode aus vier farbigen Ringen

zeigen die ersten drei Ringe den nominellen Widerstandswert (Sollwert) und der vierte die Tole-

ranzklasse. Letztere gibt die erlaubte Abweichung des tatsächlichen Widerstandswerts vom nomi-

nellen Wert an. Bei oben gezeigten Widerständen beträgt die Toleranz 5 % (goldener vierter Ring).

Man sollte den gewünschten Widerstand anhand

des Farbcodes heraussuchen, aber vor der

Verwendung des Widerstands seinen Wert mit

einem Multimeter auch einmal messen.

Der Leuchtdiodenschaltkreis wird auf einer

Steck platine aufgebaut (siehe Bild rechts).

53

Bauteil-Liste

Steckbrett, Kabel, Drahtbrücken

2 Standard-LEDs, rot und grün

Widerstände: 100 Ω, 330 Ω, 1 kΩ, 10 kΩ

Multimeter (zur Messung von Span-

nung und Widerstand in Aufgabe 3)

A K(+ ‒)

220 Ω

330 Ω

470 Ω

100 Ω

1 k Ω

10 k Ω

330 Ω

Pin 16von P1

GPIO 23

Pin 9von P1GND

Schematisch kann man den experimentellen Aufbau

auch mithilfe des Programms Fritzing darstellen

(siehe Bild rechts), das man auf der Webseite des

Fritzing Projekts für verschiedene Betriebssysteme

kostenlos erhalten kann. Einige Linux-Distribu -

tionen (zum Beispiel Raspbian und openSUSE)

bieten Fritzing über die Paketverwaltung an.

Mit einem Computerprogramm kann GPIO 23 als

Datenausgang geschaltet werden. Wenn das Pro -

gramm eine logische 0 ausgibt, liegt 0 V an GPIO

23; wenn es eine logische 1 ausgibt, liegt 3,3 V an

GPIO 23 und die Leuchtdiode leuchtet.

Am einfachsten kann man die Steuerbefehle von

einer Konsole ( auch Kommandozeile oder Terminal

genannt) aus geben.

Mit Raspbian Jessie können GPIOs ohne Root-Zugriffsrechte angesteuert werden (siehe oben,

Abschnitt Steuerung der GPIOs über das Betriebssystem). Der früher angewandte Befehl sudo su

zur Erlangung von Root-Rechten entfällt. Zunächst wechselt man in der Konsole mit dem Befehl cd

in das Verzeichnis gpio

cd /sys/class/gpio

und schreibt 23 (die Nummer des GPIO, den wir benutzen wollen) in die Datei export .

echo 23 > export

Der Befehl echo schreibt die nachfolgende Zeichenkette (hier 23) auf den Monitor (Standard-

ausgabe), wenn keine Umleitung erfolgt. Die Zeichenkette kann, muss aber nicht in einfachen (')

oder doppelten Anführungszeichen ( " ) eingefasst werden. Automatisch wird ein Zeilenumbruch

angefügt (sofern er nicht mit der Option ­n unterdrückt wird). In obigem Befehl 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 gpio23 (das automatisch angelegt wurde),

cd gpio23

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

54

Damit GPIO 23 wieder von anderen Programmen angesprochen werden kann, gehen wir in das

übergeordnete Verzeichnis ( /sys/class/gpio ) zurück und geben GPIO 23 frei mit den Befehlen

cd ..

echo "23" > /sys/class/gpio/unexport

Weiteres zu diesem Thema findet man im WWW zum Beispiel hier .

Alternativ könnte man statt einer einfachen Standard-LED auch eine zwei-

farbige Duo-LED verwenden. Sie besteht aus zwei, in einem Gehäuse

zusammengefassten, LED-Teilen verschiedener Farbe, zum Beispiel rot und

grün. Eine solche Duo-LED kann rot, grün oder gelb leuchten; letzteres wenn

roter und grüner Teil gleichzeitig leuchten. Die Ansteuerung erfolgt meist über

drei Anschlüsse, mit gemeinsamer Kathode oder gemeinsamer Anode. Im Bild

oben rechts wird eine Duo-LED mit gemeinsamer Kathode ( K ) und je einer

Anode für grün ( AG ) und rot ( AR ) gezeigt.

Für beide LED-Teile wird ein Vorwiderstand (zum Beispiel 330 Ω) benötigt,

also je einer vor AG und vor AR . Die beiden Teile werden dann (wie zwei

einzelne LEDs) mit zwei GPIOs (zum Beispiel GPIO 23 und GPIO 24) an- und

ausgeschaltet.

Blinken und Dimmen mit Python-Programmen

Wir benutzen den gleichen Leuchtdiodenschaltkreis und schreiben folgendes Pytho n-Programm .

#!/usr/bin/python3

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 = 23 # 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"

55

AG K AR

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

./blink.py

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

./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.8 Der Zusatz as GPIO bewirkt, dass der Name des

Moduls von RPi.GPIO in (das kürzere) GPIO geändert wird, um im Folgenden Schreibarbeit

einzusparen. Die Methoden des Moduls RPi.GPIO wurden oben, im Abschnitt Modul RPi.GPIO

zur Steuerung der GPIOs beschrieben.

Die Ausführung des Programms soll durch Drücken der Tastenkombination STRG und C abge-

brochen werden. Der Programmteil nach try: wird ausgeführt, solange keine "Exception geworfen"

wird, also kein Fehler und kein Abbruchbefehl (allgemein: Ausnahme, englisch exception) auftritt.

Die Tastenkombination STRG und C bewirkt eine Exception, die ohne weitere Maßnahme zum

sofortigen Programmabruch führen würde. Hier jedoch wird eine geworfene Exception mit der

Zeile except KeyboardInterrupt: except "gefangen". Das Programm läuft dann mit dem

Anweisungsblock nach der Zeile except KeyboardInterrupt: weiter. Ohne Exception wird dieser

Anweisungsblock nicht durchlaufen.

Ohne Vorgabe eines Zeichensatzes (siehe oben, Abschnitt Erstes Programm: "Hallo!", Beispiel-

programm (Zeit, Rundung, formatierte Ausgabe) ) sollte man keine deutschen Sonderzeichen, wie

zum den Umlaut ü, verwenden. Daher wird im Kommentar der letzten Programmzeile zurueck statt

zurück geschrieben.

8 In ähnlicher Weise kann man mit Hilfe des Programms WiringPi die Ein- und Ausgabe von Daten über die GPIOs in C und C++-Programmen steuern.

56

Wir wollen nun die Helligkeit der LED vom Programm verändern lassen (Dimmen). Dies kann

nicht durch Veränderung des Durchlassstroms der Diode geschehen, da der GPIO eine feste

Ausgangsspannung von 3,3 V liefert und der Wert des Vorwiderstands sich auch nicht vom

Programm verändern lässt. Die mittlere Helligkeit der LED kann man aber verringern, indem man

sie abwechselnd ein- und ausschaltet. Das Schalten soll nun so schnell erfolgen, dass unser Auge es

nicht bemerkt. Diese Methode heißt Dimmen durch Pulsweitenmodulation.

Wir benutzen wieder den gleichen LED-Schaltkreis und schreiben folgendes Pytho n-Programm .

#!/usr/bin/python3

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 = 23

f = 10

GPIO.setmode(GPIO.BCM)

GPIO.setup(g, GPIO.OUT)

po = GPIO.PWM(g, f)

po.start(0)

leuchte()

#

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

./pwm.py

Die LED wird nun mit einem pulsbreitenmodulierte n (PWM) periodischen Rechteck- Signal be-

trieben, 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 beziehungs-

weise tein . Die Periodendauer des Signals ist T = ( tein + taus ) und die Grundfrequenz f ergibt sich

57

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 Vorwider-

stand 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 23) 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 5 s

angehalten. Währenddessen leuchtet die LED mit dem eingestellten PWM Signal. Bei einer

Frequenz von 10 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 auf-

gerufen. Man erkennt, dass 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 Modula-

tion. 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.

58

Schaltung 2 (LED und Transistor)

Der Laststrom, den die GPIOs liefern können, ist (wie

oben beschrieben) beschränkt und daher ist es besser, sie

nur zum Steuern (Ein- und Ausschalten) zu benutzen.

Die elektrische Leistung für die Last (hier: eine LED)

sollte von der Energieversorgung abgenommen werden.

Eine entsprechende Schaltung wird rechts gezeigt.

GPIO 24 liefert im

high Zustand ( logi-

sche 1 = 3,3 V ) einen

kleinen Steuerstrom

IBE zur Basis B des

Transistors, welcher

zur Signalmasse am

Emitter E abfließt.

Damit wird ein

großer Laststrom ICE

zwischen Collector

C und Emitter E

eingeschaltet, der

von der 5 V

Spannung der

Energieversorgung

gespeist wird.

Wir verwenden den einen Transistor vom Typ BC547 oder (falls dieser nicht vorhanden ist, einen

anderen npn - Kleinsignaltransistor). Es gibt ihn in unterschiedlichen Subtypen (BC547A, BC547B

und BC547C), die sich in der Stromverstärkung unterscheiden. Da es keinen nennenswerten

Preisunterschied bei den Subtypen gibt und hier, wie meistens, eine höhere Stromverstärkung

vorteilhaft ist, wählen wir (sofern wir die Wahl haben) den Subtyp BC547C9 mit der höchsten

Stromverstärkung. Um den Transistor in die Steckplatine einstecken können, wählen wir eine

Ausführung im Kunststoffgehäuse TO-92 und nicht im SMD Gehäuse. Der BC547 besteht aus

Silizium (erkennbar am ersten Buchstaben B der Bezeichnung) und wird meistens bei Signalen

kleiner Leistung und niedriger Frequenzen verwendet (erkennbar am zweiten Buchstaben C der

Bezeichnung).

Ausgehend vom BC547C wollen wir mithilfe des Datenblatts sicherstellen, dass der Transistor in

unserer Schaltung nicht überfordert wird: Im Datenblatt finden wir unter absolute maximum ratings

(Ta10 = 25 °C) die maximal zulässige Spannung zwischen Kollektor und Emitter (collector emitter

9 Statt mit BC547C kann der Transistot auch (kürzer) mit C547C beschriftet sein.10 Ta steht für ambient temperature, zu Deutsch Umgebungstemperatur. Für diese gelten die Angaben im Datenblatt.

59

Bauteil-Liste

Steckbrett, Kabel, Drahtbrücken

1 npn - Kleinsignaltransistor ( BC547 )

1 Standard-LEDs, rot oder grün

Widerstände: ≈ 330 Ω , ≈ 10 k Ω

Multimeter ( zur Strommessung )

330 Ω

Pin 6von P1GND

Pin 4von P1

5 V

10 k

Ω

Pin 18von P1

GPIO 24

C E

B

voltage) VCE von 45 V. Da wir in unserer Transistorschaltung nur eine Spannung von 5 V schalten,

ist VCE ≤ 5 V und damit deutlich unter der maximal zulässigen VCE . Der maximal zulässige fort-

dauernde (nicht nur kurzzeitg anliegende) Kollektorstrom (continuous collector current) IC beträgt

100 mA. Dies liegt deutlich unter den höchstens IC = 20 mA, mit denen wir eine LED im Kollektor-

stromkreis betreiben. Beim vollständig leitenden (gesättigten) Transistor beträgt, mit IC = 20 mA ,

der Spannungsabfall zwischen Kollektor und Emitter (collector emitter saturation voltage), VCE (sat)

, 0,3 V oder weniger. Das ergibt eine (den Transistor erwärmende) Verlustleistung von höchstens

VCE (sat) · IC = 0,3 V · 20 mA = 6 mW. Da dies der Hauptbeitrag zur gesamten Verlustleistung des

Transistors (power dissipation) ist, bleibt man deutlich unter der maximal zulässigen Verlustleistung

von 0,5 W.

Schaut man auf die flache (beschriftete) Seite eines BC47 im Kunststoffgehäuse TO-92, so ist der

linke Anschluss der Kollektor C, rechts der Emitter E und in der Mitte die Basis B. Hier wird eine

Emitterschaltung des Transistors verwendet.

Um die LED über den Transistor blinken zu lassen, nehmen wir das gleiche Python-Programm wie

bei Schaltung 1, mit dem einzigen Unterschied, dass GPIO 24 statt GPIO 23 verwendet wird. Wir

müssen also die Zuweisung g = 23 durch g = 24 ersetzen.

Aufgabe 3

a) Wir verwenden nun vier verschiedene Vorwiderstände, um Punkte der Kennlinie einer roten und

einer grünen Standard-LED aufzunehmen. Die Vorwiderstände sollen nach Herstellerangabe

folgende Werte aufweisen (RSoll): 100 Ω, 330 Ω, 1 k Ω, 10 k Ω (oder, falls nicht vorhanden, ähnliche

Werte). Zunächst messen wir mit einem Widerstandsmessgerät (oder einem Multimeter) die

tatsächlichen Widerstandswerte, RIst .

Danach ergänzen wir die Schaltung 1, indem wir zwischen Leuchtdiode und Vorwiderstand R ein

Amperemeter einfügen (Messbereich zwischen 0,1 mA und 20 mA). Wenn ein Multimeter ver-

wendet 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 messen Irot für alle vier Vorwiderstände.

Dann ersetzen wir die rote durch eine grüne Standard-LED und messen wieder den Strom, Igrün , der

durch die eingeschaltete LED fließt für alle vier Vorwiderstände.

Die Ströme liegen deutlich unterhalb von 16 mA, dem maximalen Strom, der durch einen GPIO

fließen darf. Die Ströme liegen erst recht unter dem Strom von 20 mA, für den Standard-LEDs

ausgelegt sind.

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 .

Die Durchlassspannung Uf steigt mit dem Strom I .

60

Tragen Sie die gemessenen Ströme und berechneten Spannungen in folgende Tabelle ein.

Vorwiderstand rote LED grüne LED

RSoll (Ω) RIst (Ω) Irot (mA) Uf,rot (V) Igrün (mA) Uf,grün (V)

100

330

1 k

10 k

Verschiedenfarbige LEDs enthalten unterschiedliches Halbleitermaterial. Daher hängt die Durch-

lassspannung LEDs von deren Farbe ab. Je kurzwelliger das abgegebene Licht ist, desto größer ist

die Energie der Photonen und dies erfordert eine größere Energiedifferenz (Bandabstand) im Halb-

leiter. Außerdem ist die Kennlinie von LEDs temperaturabhängig.

b) Lassen Sie mit Schaltung 2 die LED über den Transistor blinken. Verlängern Sie die Leucht-

dauer, indem Sie die Zeile

time.sleep(0.2) # warte 0,2 Sekunden

durch

time.sleep(10) # warte 10 Sekunden

ersetzen.

Messen Sie den Steuerstrom IBE in die Transistorbasis,

indem Sie ein Amperemeter zwischen GPIO 24 und dem

10 k Ω Widerstand einfügen. Messen Sie den Laststrom

ICE durch die LED, indem Sie ein Amperemeter zwischen

Pin 4 von P1 (5 V) und dem 330 Ω Widerstand einfügen.

61

Ergebnis:

IBE =

ICE =

ICE / IBE =

Experiment 2: Schalter auslesen

Schaltung 3 (Schalter)

Als erstes Beispiel für digitale Dateneingabe über die GPIOs

soll die Stellung eines Schalters ( ein oder aus ) in einem

Programm bestimmt werden. Wir benutzen die neben-

stehende Schaltung. Der Schalter soll die Spannung UGPIO an

einem GPIO (hier: GPIO 22, Pin 15 von P1) verändern. Im

offenen Zustand soll UGPIO bei 0 V liegen (logische 0) und im

geschlossenen Zustand bei 3,3 V (logische 1).

Der GPIO muss auf die Betriebsart (Modus)

Eingabe gesetzt werden. Dann ist die Spannung

am Eingang des GPIO unbestimmt, solange

von außen keine Spannung zugeführt wird.

Um bei offenem Schalter die Spannung am

GPIO-Eingang auf 0 V zu ziehen, verbinden

wir diesen über einen Widerstand (hier 10 kΩ

und 1 kΩ in Serie) mit der Signalmasse, (GND,

Pin 20 von P1).

Bei geschlossenem Schalter wird eine Span-

nungsquelle (3,3 V, Pin 17 von P1) über den

1 kΩ-Widerstand mit dem GPIO-Eingang

verbunden.

So liegt bei beiden Schalterstellungen (aus oder

ein) jeweils eine bestimmte Spannung ( 0 V

oder 3,3 V ) am GPIO-Eingang.

Den 10 kΩ-Widerstand, über den bei geöffne-

tem Schalter den GPIO-Eingang auf 0 V

heruntergezogen wird, nennt man Pulldown-

Widerstand. Entsprechend hiesse ein

Widerstand, der die Signalleitung auf ein

höhere Spannung zieht, ein Pullup-Widerstand.

Bei geschlossenem Schalter fließt ein Strom von der Spannungsquelle (3,3 V) nach GND. Aufgrund

des großen Werts des Pulldown-Widerstands beträgt dieser Strom nur 3,3 V / 10 kΩ = 330 μA . Der

GPIO hat, in der Betriebsart Eingabe, einen so hohen Eingangswiderstand, so dass kein bedeut-

samer Strom in oder aus dem GPIO fließt.

Der Widerstand vor dem Eingang (1 kΩ) ist bei richtigem Betrieb des GPIO nicht nötig. Er soll den

GPIO vor Überlastung schützen, für den Fall, dass der GPIO fälschlich auf die Betriebsart Ausgabe

62

Bauteil-Liste

Steckbrett, Kabel, Drahtbrücken

Schalter (einpolig Ein-Aus)

Standard-LED, rot oder grün

Widerstände: 330 Ω, 1 kΩ, 10 kΩ

Pin 15von P1

GPIO 22

Pin 17von P13,3 V

1 k Ω

10 k

Ω

Pin 20von P1GND

gesetzt wurde. (In diesem Fall würde die GPIO-Ausgabe einer logischen 0 bei geschlossenem

Schalter zu einem Kurzschluss zwischen 3,3 V und Signalmasse führen.) Der 1 kΩ-Widerstand ist

also ein strombegrenzender Schutzwiderstand.

Daten eingeben mit Python-Programm

Nach dem Aufbau der Schaltung mit dem Schalter schreiben wir folgendes Pytho n-Programm .

#!/usr/bin/python3

import RPi.GPIO as GPIO # importiere RPi.GPIO und nenne es GPIO

from time import sleep # importiere sleep-Funktion vom Modul time

g1 = 22 # speichere die Nummer des GPIO-Eingangs in Variable g1

GPIO.setmode(GPIO.BCM) # benutze GPIO-Namen (statt Pin-Nummern)

GPIO.setup(g1, GPIO.IN) # setze GPIO g1 als Eingang (IN)

#

try: # Folgendes normalerweise, ohne Druecken von Ctrl-C

while True: # Endlosschleife

ein = GPIO.input(g1) # weist ein entweder 0 oder 1 zu

if ein: # wenn ein = 1 ist, True / wenn ein = 0, False

print("Schalter EIN")

else:

print("Schalter AUS")

sleep(0.5) # warte 0,5 Sekunden

except KeyboardInterrupt: # Folgendes nach Druecken von Ctrl-C

print("\nAbbruch durch Ctrl-C.\n")

GPIO.cleanup() # setzt GPIOs in den Standard-Zustand zurueck

Nach dem Speichern im Ordner p , unter dem Namen schalter.py , öffnen wir eine Konsole, bewegen

uns in den Ordner p und starten die Programmausführung mit den Konsolenbefehlen

chmod a+x schalter.py

./schalter.py

Je nach Schalterstellung wird fortlaufend (in Abständen von etwas mehr als ½ s) entweder Schalter

AUS oder Schalter EIN in eine Zeile der Konsole gesschrieben. 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

./schalter.py

Beim Einschalten kann es zum Prellen kommen, das heißt, der Schalter schwingt mehrfach zwi-

schen Ein und Aus, bevor er im Ein-Zustand bleibt (beziehungsweise umgekehrt beim Ausschalten).

Da jedoch die Schalterstellung in Zeitabständen von etwas mehr als ½ s abgefragt wird, fällt das

Prellen, welches typischerweise nur wenige ms dauert, bei der Programmausführung nicht auf.

63

Desktop Shortcut für unser Programm

Das Programm schalter.py soll, einschließlich Konsole, auch mit einem Desktop Shortcut (siehe

oben, Abschnitt Boot, Betriebssystem und Konfiguration) gestartet werden können. Dazu schreiben

wir folgende Zeilen im Editor Leafpad:

[Desktop Entry]

Name = SOS

Comment = LED blinkt (mit Schalter)

Icon = /usr/share/pixmaps/openbox.xpm

Exec = lxterminal -e "/home/pi/p/schalter.py"

Type = Application

Encoding = UTF-8

Wir speichern dies im Ordner /home/pi/Desktop unter dem Namen blinker.desktop .

Nun kann das Programm mit einem Doppelklick auf ein Icon auf dem Desktop gestartet werden.

Ein Desktop Shortcut enthält nach der Kopfzeile ( [Desktop Entry] ) noch mehrere Zeilen, die

jeweils mit einem Schlüsselwort ( key ) beginnen. Nach dem key folgen ein Gleichheitszeichen

(davor und danach darf ein Leerzeichen stehen) und der Wert ( value ). Mit Name= bestimmt man

den Text, der unter dem Icon auf dem Desktop steht. Comment= erlaubt es, eine Erklärung zum

diesem Desktop Shortcut anzugeben. Mit Icon= gibt man den Pfad zu einer Bilddatei für das Icon

an. Nach Exec= folgt der Pfad zu einer ausführbaren Datei (hier: lxterminal für das LXTerminal),

die mit dem Desktop Shortcut gestartet werden kann. Man kann der Datei auch Optionen und

Parameter übergeben. Mit Type= wird der Typ der auszuführenden Datei angegeben; im

allgemeinen Application (oder Link für einen Verweis auf eine Webseite oder Directory

für einen Verweis auf einen Ordner).

Optionen zum Befehl lxterminal werden erklärt, wenn man man in der Konsole

man lxterminal

eingibt. Der Konsolenbefehl man gibt eine Beschreibung für einen Befehl aus.

Statt der Zeile

Exec = lxterminal -e "/home/pi/p/schalter.py"

kann man auch die beiden Zeilen

Exec = /home/pi/p/schalter.py

Terminal = true

schreiben. Mit Terminal = true wird angegeben, dass das nach Exec= genannte ausführbare

Programm in einer Konsole (hier: LXTerminal) laufen soll.

64

Aufgabe 4

a) Vereinen Sie Schaltung 1 und 3 in einem Aufbau und verändern Sie das Programm schalter.py so,

dass der Schalter nicht eine unterschiedliche Textausgabe in der Konsole bewirkt, sondern die LED

ein- und ausschaltet.

b) Verändern Sie das Programm so, dass die LED bei geschlossenem Schalter blinkt, so wie oben

im Abschnitt Blinken und Dimmen mit Python-Programmen beschrieben.

c) Verändern Sie das Programm so, dass die LED bei geschlossenem Schalter fortlaufend das Not-

zeichen SOS blinkt (SOS-Anruf dreimal: ...|||... ...|||... ...|||... , Pause, dann wieder vorne beginnen).

65

Experiment 3: Temperatursensor am Eindraht-Bus

Schaltung 4 (Temperatursensor DS18S20)

GPIOs können auch Daten -

ströme senden oder empfan-

gen. 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) 11 gesendet werden können. Der experimentelle Aufbau

kann in ähnlicher Weise wie in Experiment 1 (siehe oben)

erfolgen.

Da der Sensor auf einer Steck platine

aufgebaut werden soll, wird die Bauform

TO-92 mit drei Anschlussbeinchen (Pins)

benutzt. Der TO-92-DS18S20 ist von

vielen Elektronikbauteilehändlern erhältlich

(Preis: 2 – 5 €) und das zugehörige

Datenblatt findet man auch leicht im

Internet.

Pin 1 des DS18S20 wird mit GND (Pin 9

der Stiftleiste P1) verbunden, Pin 2 des TO-

92-DS18S20 mit GPIO 4 (Pin 7 von P1)

und Pin 3 des TO-92-DS18S20 mit einer

Spannungs quelle (hier 3,3 V von Pin 1 der

Stiftleiste P1) .

11 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.

66

DS18S20

1 2 3

DS18S20Temperatur-sensor, Ge-

häuse TO-92

( digitaler Ausgang )

die ebene Seite ist uns zu-

gewandt

Pin 1 GND (Masse)Pin 2 DQ (Daten)Pin 3 VDD (Power)

DS18S20

1 2 3

4,7 kΩ

Pin 1von P13,3 V

Pin 7von P1GPIO 4

Pin 9von P1GND

Bauteil-Liste

Steckbrett, Kabel, Drahtbrücken

Temperatursensor DS18S20

Widerstand: 4,7 kΩ

Ü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) ver-

mittelt. Ein 4,7 kΩ Widerstand wird zwischen Pin 2 und Pin 3 des TO-92-DS18S20 gesteckt.12

Der Treiber w1-gpio (siehe unten) verwendet GPIO 4 für den 1wire-Bus, wenn bei der Konfigu-

ration des Gerätebaums (siehe unten) dem 1wire-Bus kein anderer GPIO zugeordnet wurde.

Temperaturmessung von der Konsole mit DS18S20

Für die Temperaturabfrage vom Sensor kann man Steuerbefehle für die Konsole in ähnlicher Weise

wie in Experiment 1 benutzen. Das Betriebssystem Raspbian Jessie spricht den Ein draht-Bus (1-

Wire) über einen sogenannten Gerätebaum (device tree) an, nachdem der Eindraht-Bus im Geräte-

baum aktiviert wurde. (Ältere Beschreibungen des Eindraht-Busses, die von Betriebssystem-

varianten vor Raspbian Wheezy ausgehen, funktionieren daher nicht ohne weiteres.13)

Dazu wird die Datei config.txt im Verzeichnis boot ergänzt. Zunächst wird diese Datei mit dem

Editor nano geöffnet

sudo nano /boot/config.txt

und dann werden folgende Zeilen am Ende der Datei angefügt, gespeichert und die Datei wieder

geschlossen. Der Befehl sudo wird vorgesetzt, weil die Bearbeitung der Datei nur als Root möglich

ist. Statt nano kann man natürlich auch den Editor leafpad benutzen.

# activate 1-wire and debugging

dtoverlay=w1-gpio,gpiopin=4

dtdebug=on

Die Änderung wird erst nach erneutem Booten des Rechners wirksam. Mit dtoverlay=w1-gpio

sollten nun die Treiber für den Eindraht-Bus (w1-gpio und w1-therm) zur Verfügung stehen.14 Die

Zeile dtdebug=on bewirkt, dass die Konfiguration des Gerätebaums (und Störungen) protokolliert

und, nach Neustart des Rechners, mit dem Befehl sudo vcdbg log msg angezeigt werden.

12 Der Transistorausgang von Pin 2 des DS18S20 hat eine Open-Drain-Schaltung (so genannt bei Feldeffekttransis-toren, bei Bipolartransistoren entspricht dies einer Open-Collector-Schaltung) und nimmt daher die Zustände 0 V 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 durch-schaltet, 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.

13 In früheren Betriebssystemvarianten wurden die Treiber für den Eindraht-Bus mit dem Befehl modprobe zur Verfügung gestellt (also durch sudo modprobe w1-gpio und sudo modprobe w1-therm).

14 Dadurch ist allerdings die Nutzung von GPIO 4 eingeschränkt und zum Beispiel die Ansteuerung einer LED (siehe Experiment 1) an GPIO 4 vielleicht nicht mehr möglich. Will man GPIO 4 wieder für einfache Ein- oder Ausgabe-funktionen nutzen, muss man die Einbindung des Eindraht-Busses im Gerätebaum rückgängig machen. Dafür löscht man in der Datei config.txt die vorher eingefügten Zeilen oder kommentiert sie aus, indem ein Doppel kreuz - zeichen vorangestellt wird:

# activate 1-wire and debugging# dtoverlay=w1-gpio,gpiopin=4# dtdebug=on

67

Um zu prüfen, ob die Treiber geladen wurden, kann man folgenden Befehl ausführen:

lsmod

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

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.

Python-Programm zur Temperaturmessung mit DS18S20 (mit Aufgabe 5)

Wir benutzen den gleichen Temperatursensor-Schaltkreis und schreiben folgendes Python-P ro -

gramm. Dabei muss, in der vierten Zeile, für Name der Name des verwendeten Temperatursensors

eingesetzt werden, welcher oben (Abschnitt Temperaturmessung von der Konsole mit DS18S20)

gefunden wurde.

#!/usr/bin/python3

import sys

import time

sensor= "Name" # Name des Temperatursensors

pfad = "/sys/bus/w1/devices/"+sensor+"/w1_slave"

print("\nPython Version "+sys.version)

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

68

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

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

./temp.py

ein. Das Programm kann (mit dem Betriebssystem Raspbian Jessie) ohne Root-Rechte ausgeführt

werden. Die Ausführung kann durch Ctrl-C angehalten und durch ./temp.py erneut gestartet

werden.

Aufgabe 5

a) Ändern Sie das oben angegebene Python-Programm zur Temperaturmessung so, dass der gerun-

dete Temperaturwert mit einer Nachkommastelle ausgegeben wird (siehe oben, Abschnitt Beispiel-

programm (Zeit, Rundung, formatierte Ausgabe) ).

b) Außerdem soll statt des Wortes Grad das Symbol ° erscheinen. Dafür muss, wie oben beschrie-

ben, ein Zeichensatz vorgegeben werden.

c) Schreiben Sie ein neues Programm zur Temperatur-

messung, 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än-

ken wir uns zunächst auf Einzelmessungen, die mit einem

Klick auf den Button b1 (measure) ausgelöst werden. Das

Messergebnis soll im Textfeld (label) angezeigt werden.

Ein Klick auf den zweiten Button, b2 (-> °F), soll die Anzeige von °C auf °F umstellen (und b2

69

erhält dann die Aufschrift -> °C); ein weiterer Klick soll die Anzeige von °F auf °C zurückstellen.

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() # beende das GUI-Programm, schliesse Fenster

geschehen. Damit verschwindet das window und das Programm wird beendet.

d) Ergänzen Sie das neue 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 Temperaturmessung

ausgelöst werden. Die vorher festgelegten Ereignisse für Button b2 (-> °F / -> °C) und Button b3

(quit) sollen wie zuvor wirken.

e) Fügen Sie dem neuen Temperaturmessprogramm die Speicherung in einer Datei hinzu.

Um jede Messung in einer neuen Datei mit eigenem Namen zu speichern, soll der Dateiname vom

Programm erzeugt werden und das aktuelle Datum und die aktuelle Uhrzeit enthalten. Dies kann

mit Hilfe der Funktion strftime() des Moduls time geschehen. Zum Beispiel könnte eine am 30. 11.

2014 um 12:01:05 Uhr erzeugte Datei den Namen T_141130120105.dat tragen. Wenn die größeren

Zeiteinheiten vor den kleineren stehen (Jahr > Monat > Tag > Stunde > Minute > Sekunde) werden

die Dateien bei einer alphabetischen Sortierung auch chronologisch geordnet. Der Dateiname soll in

einer Variablen namens dat_name gespeichert werden. Die Datei muss am Programmbeginn ge-

öffnet werden, zum Beispiel so:

td = open(dat_name,'w') # oeffne Datei, td enthält Dateiobjekt

Nach jeder Messung soll eine Zeichenkette

time.strftime("%d.%m.%y/%H:%M:%S")+' '+'%6.2f' % round(T,1) + '\n'

in die Datei geschrieben werden, wobei die Variable T den Temperaturwert in °C enthält. Diese

Zeichenkette enthält eine formatierte Zeitangabe, eine Lücke als Trennzeichen und den Temperatur-

wert als Dezimalzahl mit zwei Nachkommastellen.

Am Ende des Programms, vor w.destroy() , soll die Datei geschlossen werden, zum Beispiel so:

def qt():

global td # mache Variable td (Dateiobjekt) bekannt

td.close() # schliesse Temperatur-Datei

w.destroy() # beende das GUI-Programm, schliesse Fenster

f) Ergänzen Sie das neue Temperaturmessprogramm um die Erzeugung, Speicherung und Anzeige

einer Temperaturverlaufsgraphik mit Hilfe von Gnuplot, zum Beispiel durch Erweiterung der

Funktion qt() in folgender Weise:

def qt():

global dat_name, sensor, td, z # mache Variablen bekannt

td.close() # schliesse Temperatur-Datei

70

pd = "T_"+z+".png" # Name der Graphikdatei (png-Format)

td = open("batch.txt",'w') # oeffne Gnuplot-Datei

aus = "# Gnuplotbefehle ..." # Hier müssen Sie etwas ergänzen!

td.write(aus) # schreibe in Gnuplot-Datei

td.close() # schliesse Gnuplot-Datei

os.system('gnuplot batch.txt') # fuehre die Gnuplot-Datei aus

os.system('display '+pd) # zeige die Graphik-Datei an

w.destroy() # beende das GUI-Programm, schliesse Fenster

Den Inhalt der Variablen aus (eine Zeichenkette) müssen Sie ergänzen! Das Modul os muss

natürlich (in üblicher Weise) am Anfang des Programms eingebunden werden.

71

Experiment 4: Temperatursensor am I2C Bus

Schaltung 5 (Temperatursensor LM75)

Wir wollen nun einen weiteren Datenbus kennenlernen, den

I 2 C Bus , mit dem viele verschiedenene Geräte an den Π ange-

schlossen werden können. Hier soll ein Temperatursensor vom

Typ LM75, und zwar der Subtyp mit 3,3V Betriebsspannung

angeschlossen werden. Er wandelt (ähnlich wie der in

Experiment 3 verwendete DS18S20) Temperatur zunächst

in eine analoge elektrische Spannung und dann mithilfe

eines AD-Wandlers in digitale Signale, die über einen

seriellen Datenbus zum Π gesendet werden. Der Schaltplan

oben rechts zeigt, dass im einfachsten Fall neben dem

LM75 keine weiteren elektronischen Bauteile benötigt

werden.

Nachteilig ist jedoch, dass der LM75 in der Regel nur in der SMD Bauform angeboten wird. Die

acht Anschlussbeine (Pins) sind kurz, eng benachbart und brechen leicht ab. Daher ist es schwierig,

ihn direkt mit Anschlussleitungen zu versehen oder ihn mit einer Steck platine zu verbinden. Am

einfachsten ist es wohl, den LM75 auf eine SO-8 Adapterplatine zu löten. Mit Geschick kann man

den L75 auch auf eine normale Lochrasterplatine (oder eine andere Leiterplatte) kleben und

Anschlussleitungen zugentlastet (über Lötaugen) zum Π führen.

Vier der LM75 Pins (SDA, SCL, GND, +VS) führen zu Pins der Stiftleiste P1 des Π. Drei Pins des

LM75 (A0, A1 und A2) werden im einfachsten Fall direkt mit Masse (GND) verbunden; der achte

Pin (OS) wird hier nicht verwendet. Der Π stellt für den I2C Bus die GPIOs 2 und 3 bereit, welche

(im Gegensatz zu anderen GPIOs) mit einem internen 1,8 kΩ Pullup-Widerstand versehen sind, um

die Beschaltung des I2C Busses zu vereinfachen. Die Verbindung von LM75 und Π erfolgt gemäß

dem obigem Schaltplan und nachfolgender Tabelle.

LM75Pin 1SDA

Pin 2SCL

Pin 3OS

Pin 4GND

Pin 5+VS

Pin 6A0

Pin 7A1

Pin 8A2

ΠP1, Pin 3GPIO 2

P1, Pin 5GPIO 3

P1, Pin 9GND

P1, Pin 13,3 V

P1, Pin 9GND

P1, Pin 9GND

P1, Pin 9GND

Temperaturmessung von der Konsole mit LM75

Um den I2C Bus nutzen zu können, müssen entsprechende Module im Gerätebaum zur Verfügung

gestellt werden. Dies geschieht am einfachsten, indem bei der Konfiguration des Π mit Raspberry

Pi Configuration oder raspi-config die Option I2C: Enabled gewählt wurde (siehe oben, Abschnitt

Boot, Betriebssystem und Konfiguration). Man kann dies prüfen, indem man in der Konsole den

Befehl

72

Bauteil-Liste

Temperatursensor LM75, auf

einer Leiterplatte befestigt, mit

vier Anschlussleitungen zum Π

3-poliger DIP-Schalter

Widerstände: 3 Stück à 10 kΩ

1

2

3

4 5

6

7

8+VS

A0

A1

A2GND

OS

SCL

SDA

L M

7 5GPIO 3

AHG

GPIO 23,3 V

GNDTemperatursensor

lsmod | grep i2c

eingibt. Der Befehl lsmod gibt eine Liste aller geladenen Module aus. Der Ausgabedatenstrom wird

mit dem |-Zeichens (das eine Pipe erzeugt; es ist meistens auf der Tastatur vorhanden) als Eingabe

des Befehls grep i2c verwendet, der alle Zeilen ausgibt, welche die Zeichenkette i2c enthalten. Im

Ergebnis sollten zwei Zeilen am Bildschirm erscheinen, die mit i2c beginnen. Geschieht dies nicht,

müssen die Module noch in den Gerätebaum eingefügt werden, indem man Raspberry Pi Configu-

ration nochmals startet und nun die Option I2C: Enabled wählt (siehe oben, Abschnitt Boot,

Betriebssystem und Konfiguration).

Bei Raspbian Jessie steht in der Datei /etc/modules bereits die Zeile i2c­dev . (Im früheren

Betriebssystem Raspbian Wheezy musste man, mit Root-Rechten, diese Zeile noch selbst ergänzen

und den Rechner dann erneut booten.) Mit

sudo apt-get update

führen wir ein Update durch (siehe oben, Abschnitt Kommandozeile (Konsole) und Paketverwal-

tung) und installieren ein Paket mit Hilfsprogrammen sowie ein Python3-Modul für den I2C Bus:

sudo apt-get install i2c-tools python3-smbus

Mit i2ctools kann man den I2C Bus von der Konsole ansprechen und das Modul smbus stellt eine

Klasse bereit, mit der man den I2C Bus aus einem Python-Programm ansprechen kann.

Um den I2C Bus als normaler Benutzer ohne Root-Zugriffsrechte aufrufen zu können, fügen wir uns

(den aktuellen Benutzer $USER ) der Gruppe i2c hinzu, welche den I2C Bus benutzen darf:

sudo adduser $USER i2c

Möglicherweise ist der aktuelle Benutzer ( pi ) allerdings schon Mitglied der Guppe i2c . Damit

obige Änderungen wirksam werden, starten wir den Π neu.

Danach lassen wir uns mit dem Befehl

lsmod

die geladenen Module anzeigen. Darunter sollte auch i2c_bcm2708 für den I2C Bus sein. Den oder

die I2C-Kanäle bekommen wir mit dem Befehl

ls -l /dev/i2c*

genannt. Hier sollte /dev/i2c-1 erscheinen. Nun wollen wir sehen, welche Geräte am I2C-Kanal 1

angeschlossen sind. Dies geschieht mit dem Befehl

i2cdetect -y 1

Die Option -y dient zur Unterdrückung eines Warnhinweises und einer Rückfrage, die 1 steht für die

Kanalnummer des I2C Busses. Wenn der LM75 mit dem I2C Bus verbunden wurde, sollte jetzt in

der mehrzeiligen Antwort des Programms eine 48 in einer mit 40 beginnenden Zeile enthalten sein.

Die 48 bedeutet, dass der LM75 am die Adresse 0x48 hat. Die Adresse wird als Hexadezimalzahl

angegeben, erkennbar am Präfix 0x . Hexadezimal 48 entspricht dezimal 4 · 16 + 8 = 72 .

73

An einem I2C Bus gibt es ein Kontrollgerät, Master genannt, an dem mehrere, davon kontrollierte

Geräte, die Slaves, angeschlossen werden können. Der Master kommuniziert mit einem bestimmten

Slave, indem er ihn über die Adresse anspricht. Die Adresse des LM75 können wir, innerhalb eines

vorgegebenen Wertebereichs, mit Hilfe der Pins 6 (A0), 7 (A1) und 8 (A2) des LM75 festlegen. Da

wir diese Pins mit Masse (GND) verbunden haben, ist die Adresse 0x48.

Eine Abfrage von Rohdaten (codierte Daten, wie sie vom LM75 geliefert werden) geschieht mit

i2cget -y 1 0x48 0x00 w

und wir erhalten eine Antwort, welche in codierter Form den Temperaturwert angibt, zum Beispiel

0xf718 . Diese Antwort besteht aus einer vierstelligen hexadezimalen Zahl (Präfix 0x). Die beiden

letzten Stellen, hier 18 , ergeben dezimal den ganzzahligen Anteil (ohne Nachkommastelle) des

Temperaturwerts, hier 1 · 16 + 8 = 24 . Für die aktuelle Temperatur T gilt also 24 °C ≤ T < 25 °C .

Eine vollständige Auswertung der Rohdaten vom LM75 wollen wir mit einem Python-Programm

vornehmen.

Python-Programm zur Temperaturmessung mit LM75

Für die Temperaturmessung mit oben gezeigtem Schaltkreis schreiben wir folgendes Python-P ro -

gramm :

#!/usr/bin/python3

from subprocess import Popen, PIPE

from time import sleep

#

def T(wert): # Funktion T wandelt Rohdaten in Temperaturwert und gibt ihn aus

grad = wert & 0xFF # grad wird unteres Byte des Rohdatenwerts zugewiesen

gradnachkomma = wert >> 15 # gradnachkomma wird oberes Byte zugewiesen

if (grad & 0x80) == 0x80: # (hoechstwertiges Bit = 1) => (grad ist negativ)

grad = -((~grad & 0xFF) + 1) # bilde negatives Zweierkomplement von grad

temp = grad + gradnachkomma * 0.5 # addiere Vor- und Nachkommatemperaturzahl

print(str(temp)+' Grad C') # schreibe Ausgabetext (Temperatur, 0.5 Grad genau)

#

print("\nTemperatur am LM75 Sensor, Abbruch durch Ctrl-C")

print("***********************************************")

#

try: # Folgendes vor Druecken von Ctrl-C

while True: # eine Endlosschleife liest Rohdaten ein und ruft Funktion T auf

p = Popen([ 'i2cget' , '-y' , '1' , '0x48' , '0x00' , 'w' ] , stdout=PIPE)

# Methode Popen fuehrt Shell-Befehl i2cget aus und speichert die Antwort (String)

T( int(p.stdout.read(), 16) ) # ruft Funktion T mit Rohdaten-Ganzzahl auf

sleep(1) # warte 1 Sekunde (Intervall zwischen zwei Temperatur-Ausgaben)

except KeyboardInterrupt: # Folgendes nach Druecken von Ctrl-C (Programm-Abbruch)

print ("\n- Messung beendet -\n") # Ende des Programms

74

Das Programm wird im Ordner p unter dem Namen lm75.py gespeichert. Wir öffnen eine Konsole,

bewegen uns in den Ordner p und geben folgende Konsolenbefehle ein:

chmod a+x lm75.py

./lm75.py

Die Ausführung kann durch Ctrl-C angehalten und durch ./lm75.py erneut gestartet werden.

Obiges Programm benutzt den Konsolenbefehl i2cget , um über den I2C Bus vom Temperatursensor

ein Datenwort (2 Byte) auszulesen. Im folgenden Programm wird die Klasse smbus verwendet:

#!/usr/bin/python3

import smbus

from time import sleep

#

def T(wert): # Funktion T wandelt Rohdaten in Temperaturwert und gibt ihn aus

grad = wert & 0xFF # grad wird unteres Byte des Rohdatenwerts zugewiesen

gradnachkomma = wert >> 15 # gradnachkomma wird oberes Byte zugewiesen

if (grad & 0x80) == 0x80: # (hoechstwertiges Bit = 1) => (grad ist negativ)

grad = -((~grad & 0xFF) + 1) # bilde negatives Zweierkomplement von grad

temp = grad + gradnachkomma * 0.5 # addiere Vor- und Nachkommatemperaturzahl

print(str(temp)+' Grad C') # schreibe Ausgabetext (Temperatur, 0.5 Grad genau)

#

i2cbus=smbus.SMBus(1) # Instanz i2cbus fuer den I2c Bus 1 bilden

#

print("\nTemperatur am LM75 Sensor, Abbruch durch Ctrl-C")

print("***********************************************")

#

try: # Folgendes vor Druecken von Ctrl-C

while True: # eine Endlosschleife liest Rohdaten ein und ruft Funktion T auf

daten = i2cbus.read_word_data(0x48, 0x00) # hole Wort (2 Byte) vom Sensor

T(daten) # ruft Funktion T mit Datenwort (= Rohdaten-Ganzzahl) auf

sleep(1) # warte 1 Sekunde (Intervall zwischen zwei Temperatur-Ausgaben)

except KeyboardInterrupt: # Folgendes nach Druecken von Ctrl-C (Programm-Abbruch)

print ("\n- Messung beendet -\n") # Ende des Programms

Werden mehrere Geräte am I2C Bus angeschlossen, müssen sie unterschiedliche Adressen haben.

75

Aufgabe 6

Über Pins 6 bis 8 des LM75 kann man die

Bus-Adresse des Temperatursensors im

Wertebereich 0x48 (Pins 6 bis 8 alle auf

low) bis 0x4F (Pins 6 bis 8 auf high) ein-

stellen. Erweitern Sie die Schaltung für

den LM75 um einen DIP-Schal ter und drei

Pulldown-Widerstände (jeweils 10 kΩ)

gemäß des nebenstehenden Schaltplans.

Stellen Sie die Adresse 0x4A mit Hilfe des

DIP-Schalters ein und ändern Sie das

Programm entsprechend.

76

1

2

3

4 5

6

7

8+VS

A0

A1

A2GND

OS

SCL

SDA

L M

7 5GPIO 3

AHG

GPIO 23,3 V

GNDDIP-Schalter

1

2

3

10 k

Ω

10 k

Ω

10 k

Ω

Temperatursensor

Pulldown-Widerstände

Experiment 5: A/D-Wandler am SPI Bus

Schaltung 6 (A/D-Wandler MCP3208) und das Treibermodul für den SPI Bus

Und noch einen Datenbus können wir mit dem Π kennen-

lernen, nämlich das Serial Peripheral Interface ( SPI) . Auch

hier gibt es ein Kontrollgerät (Master) und einen oder mehrere

davon kontrollierte Geräte (Slaves).

Die Auswahl des Slaves geschieht beim SPI Bus, indem eine

besondere Datenleitung zu einem Slave, chip select oder kurz

CS (machmal auch slave select = SS genannt), durch den

Master von high (inaktiv) auf low (aktiv) gesetzt wird. Da

low, nicht high, einen Slave aktiviert, wird CS oft auch mit einem Überstrich (als Zeichen der

Negation) geschrieben.

Der Datenaustausch zwischen Master und Slave vollzieht sich Bit für Bit im Takt, der auf der SCLK

Signalleitung vom Master als Rechteckschwingung vorgegeben wird, also synchron.

Es werden, gleichzeitig auf zwei Leitungen, Daten vom Master zum Slave (MOSI, Master Out

Slave In) und Daten vom Slave zum Master gesendet (MISO, Master In Slave Out). Diese

Betriebsart nennt man Vollduplex (full-duplex).

Außerdem braucht der MCP3208 (Slave)

vom Π (Master) zumindest eine

Masseverbindung (GND) und eine

Versorgungsspannung VDD, die

allgemein typischerweise zwischen 2,7

und 5,5 V liegen könnte, in unserer

Schaltung (siehe Bild rechts) aber

aufgrund der Vorgabe des GPIO-

Signalpegels 3,3 V betragen muss.

Insgesamt hat der MCP3208 sechzehn

Pins. Pins 1 bis 8 stellen die Eingänge

für die messenden Analogspannungen

dar und werden mit CH0 bis CH7

bezeichnet. Die Verbindung von MCP3208 und Π erfolgt gemäß Schaltplan und folgender Tabelle.

MCP3208

Pin 9DGND

Pin 10CS

Pin 11DIN

Pin 12DOUT

Pin 13CLK

Pin 14AGND

Pin 15VREF

Pin 16VDD

ΠP1, Pin 20

GNDP1, Pin 24GPIO 8

P1, Pin 19GPIO 10

P1, Pin 21GPIO 9

P1, Pin 23GPIO 11

P1, Pin 20GND

P1, Pin 173,3 V

P1, Pin 173,3 V

SPI CS MOSI MISO SCLK

Pin 9 des MCP3208 heißt DGND (digital ground) und erhält die Masseverbindung vom Π (GND).

77

Potentiometer

1

2

3

4

5

6

7

8

16

15

14

13

12

11

10

9

CH0

CH1

CH2

CH3

CH4

CH5

CH6

CH7 DGNDCS

DIN

DOUT

CLK

VREF

VDD

AGND

M C

P 3

2 0

8AHG

10 k

Ω

GPIO 9

GND

GPIO 10GPIO 8

GPIO 113,3 V

Bauteil-Liste

Steckbrett, Kabel, Drahtbrücken

A/D-Wandler MCP3208,

Potentiometer: ≈ 10 kΩ

sowie, falls vorhanden:

Voltmeter ( Bereich 0 - 3,3 V )

Keramikkondensator: 0,1 - 1 μF

Die analogen Eingangsspannungen werden bezüglich Pin 14 des MCP3208 (AGND, analog

ground) gemessen, den wir in unserer Schaltung mit Pin 9 (DGND) verbunden haben. Die obere

Grenze des Messbereichs wird durch Pin 15 des MCP3208 (VREF) festgelegt, den wir mit Pin 16

(VDD) verbunden haben. Diese Pins (15 und 16) erhalten die Versorgungsspannung vom Π (3,3 V).

Pins 10 (CS mit Überstrich) und 13 des MCP3208 (CLK) werden mit GPIO 8, welcher das CS

Signal ausgibt, und GPIO 11 des Π, welcher das SCLK Signal ausgibt, verbunden. Pins 11 (DIN)

und 12 des MCP3208 (DOUT) werden mit GPIO 10 des Π, welcher das MOSI Signal ausgibt,

beziehungsweise GPIO 9, welcher das MISO Signal ausgibt, verbunden.

Um Störungen und Rauschen der Versorgungspannung VDD zu minimieren, sollte zwischen Pins 14

(AGND) und 16 (VDD) des MCP3208 ein Abblockkondensator von 1 µF gesetzt werden (im mini-

malistischen Schaltplan oben nicht eingezeichnet, denn es geht - mit mehr Rauschen - auch ohne

ihn). Er wird möglichst nah an den Pins platziert. Geeignet sind insbesondere Keramikkondensa-

toren, während zum Beispiel gewickelte Kondensatoren wegen ihrer Induktivität weniger geeignet

sind. Da 1 µF Keramikkondensatoren selten sind, kann man einen 100 nF Keramikkondensator nah

an den Pins, und parallel dazu einen 1 bis 10 µF (wenn möglich, flachen, nicht gewickelten) Folien-

kondensator, setzen (keinen Elektrolytkondensator).

Zur Erzeugung einer veränderlichen analogen Eingangsspannung

wird ein Potentiometer (etwa 10 kΩ) als Spannungsteiler zwischen

Masse (GND) und 3,3 V geschaltet und die Teilspannung vom

Mittelabgriff des Potentiometers auf einen Eingang des MCP3208

gelegt. Hierfür wurde willkürlich Pin 3 des MCP3208 (CH2) ge-

wählt. Die Analogspannung kann mit einem Voltmeter angezeigt

werden. Da die Schaltung nur die Funktionsweise des AD-Wandlers

und seine Steuerung über den SPI Bus zeigen soll, können wir hier

auf weitere Bauelemente verzichten.

Für den SPI Bus braucht man das Treibermodul (spi_bcm2835 oder ähnlich), das über den

Gerätebaum zur Verfügung gestellt wird, wenn bei der Konfiguration des Π mit Raspberry Pi

Configuration oder raspi-config die Option zur Aktivierung und Laden des SPI interface gewählt

wurde (siehe oben, Abschnitt Boot, Betriebssystem und Konfiguration). Man kann dies prüfen,

indem man in der Konsole den Befehl

lsmod | grep spi

eingibt. Der Befehl lsmod gibt eine Liste aller geladenen Module aus. Der Ausgabedatenstrom kann

mithilfe des |-Zeichens (das eine Pipe erzeugt; es ist meistens auf der Tastatur vorhanden) als

Eingabe für den Befehl grep spi verwendet werden, der alle Zeilen ausgibt, welche die Zeichenkette

spi enthalten. Im Ergebnis sollte eine Zeile am Bildschirm ausgegeben werden, die mit spi_bcm

beginnt. Geschieht dies nicht, muss das Modul noch in den Gerätebaum eingefügt werden, indem

man Raspberry Pi Configuration nochmals startet und nun die Option SPI: Enabled wählt (siehe

oben, Abschnitt Boot, Betriebssystem und Konfiguration).

78

Mit

sudo apt-get update

führen wir ein Update durch (siehe oben, Abschnitt Kommandozeile (Konsole) und Paketverwal-

tung). Wir wollen nun das Pythonmodul spidev installieren. Dafür wird das Paket python3-dev

gebraucht; falls es fehlt, wird es jetzt installiert (siehe oben, Abschnitt Editor, Browser und weitere

Programme).

In einer Konsole führen wir dann folgende Befehle aus:

git clone git://github.com/doceme/py-spidev

cd py-spidev

sudo python3 setup.py install

Damit sollte das Modul spidev in Python3 zur Verfügung stehen.

Python-Programm zur Spannungsmessung mit MCP3208 (mit Aufgabe 7)

Zur Demonstration der Funktionsfähigkeit unserer Schaltung messen wir mit folgendem Python-

Programm die Spannung am Eingang CH2 und geben das Ergebnis einmal pro Sekunde auf dem

Bildschim aus. Das Programm kann ohne Root-Rechte ausgeführt werden. Drücken von Ctrl-C

beendet das Programm.

#!/usr/bin/python3

import spidev

from time import sleep

# Variablendeklaration und Oeffung des SPI-Busses

SPI_Bus = 0 # Auswahl des SPI_Busses, hier nur 0 moeglich

CS = 0 # Slave, der mit CS-Signal angesprochen wird

f = 20000 # Frequenz in Hz fuer das SCLK-Signal (clock)

Uref = 3.3 # Referenzspannung in V an Pin 15 des MCP3208

Uiv = Uref / 4096 # Spannungsintervall digitaler Wert-Einheiten

Kanal = 2 # Kanalnummer (Bereich 0 - 7) des AD-Wandlers

Pausendauer = 1 # Pausendauer zwischen Messsungen in Sekunden

spi = spidev.SpiDev() # Erzeugung eines SpiDev-Objekts namens spi

spi.open(SPI_Bus, CS) # Oeffnung von SPI-Bus SPI_Bus fuer Slave CS

spi.max_speed_hz = f # Vorgabe der maximalen SPI-Bus-Taktfrequenz

try: # Folgendes normalerweise, ohne Druecken von Ctrl-C

# Schleife zur Spannungsmessung und Ausgabe des Wertes

while True: # Endlosschleife

adc = spi.xfer2([6 + (Kanal >> 2), Kanal << 6, 0]) # Messung

# gleichzeitig je 3 Bytes senden (MOSI) und empfangen (MISO)

Wert = ((adc[1]&15) << 8) + adc[2] # 12 Bit zur Zahl wandeln

U = Uiv * Wert + Uiv/2 # digitaler Wert -> analoge Spannung

print("Kanal 0:1d: Spannung = 1:4.2f V".format(Kanal,U))

sleep(Pausendauer) # Pause zwischen zwei Messungen

except KeyboardInterrupt: # Folgendes nach Druecken von Ctrl-C

spi.close() # trennt das SpiDev-Objekt spi vom SPI-Bus

print("\n- Messung beendet -\n") # Ende des Programms

79

Schauen wir uns den Programmcode der Reihe nach an: Nach Einbindung der notwendigen Module

(spidev, time) werden zunächst einige Werte in Variablen gespeichert, auf die wir später zurück-

greifen. Grundsätzlich wäre es möglich, mehrere SPI Busse am Π zu betreiben, die (beginnend mit

0) durchnummeriert werden. Hier gibt es nur den SPI Bus mit der Nummer 0, dessen Nutzung in

der Zeile SPI_Bus = 0 festgelegt wird.

Der SPI Bus 0 könnte verschiedene Slaves über jeweils eine CS Datenleitung ansprechen. Hier wird

nur der Slave MCP3208 über die erste CS Datenleitung mit der Nummer 0 angesprochen, was in

der Zeile CS = 0 festgelegt wird.

Der SPI Bus kann mit unterschiedlichen Taktfrequenzen betrieben werden und die meisten der

angeschlossenen Geräte (Slaves) können mit unterschiedlichen, auch wechselnden Taktfrequenzen

(und sogar Änderungen im Tastgrad) arbeiten. Bei dem hier betrachteten AD-Wandler wird der

Frequenzbereich beschränkt durch die Wandlungdauer, die 12 Takte umfasst. Die höchste mögliche

Frequenz liegt unter optimalen Bedingungen bei 2 MHz, so dass maximal 100 000 Messwerte / s

erfasst werden können, wenn der Master dies auch schafft. Es gibt aber auch eine Höchstdauer für

die sichere Zwischenspeicherung des analogen Spannungswerts in einem internen Kondensator

während der Wandlung von etwa 1,2 ms unter ungünstigen Bedingungen. Aus letzterem ergibt sich

eine Frequenz von mindestens 10 kHz. Da in obigem Programm keine besonders schnelle

Datenerfassung notwendig ist, wird die maximale Taktfrequenz in Hz (siehe unten) mit f =

20000 vorgegeben. Man kann die Taktfrequenz auf der SCLK Signalleitung mit Hilfe eines

Oszilloskops sichtbar machen.

Der Spannungsbereich, in dem vom MCP3208 gemessen und gewandelt wird, liegt zwischen 0V

und VREF. Die Referenzspannung VREF kann höchstens so groß wie die Versorgungsspannung VDD

sein und beträgt in obiger Schaltung 3,3 V. Dies wird mit der Zeile Uref = 3.3 angegeben.

Der MCP3208 ist ein 12-Bit Wandler. Der Messspannungsbereich wird in 2 12 = 4096 gleich lange

Einzelintervalle zerlegt, die von 0 bis 4095 durchnummeriert werden. Die Länge eines Einzel-

intervalls beträgt VREF / 4096 . Dieser Wert wird mit der Zeile Uiv = Uref / 4096 in der

Variablen Uiv gespeichert.

Die acht Eingangskanäle sind von 0 bis 7 nummeriert. Mit der Zeile Kanal = 2 wird der

Eingangskanal 2 oder CH2 festgelegt.

Da wir eine Messung pro Sekunde durchführen wollen, wird mit der Zeile Pausendauer = 1

ein Wert von 1 für die Dauer zwischen Messungen in Sekunden, festgelegt.

Das Modul spidev enthält eine Klasse SpiDev und mit der Zeile spi = spidev.SpiDev()

wird eine Instanz namens spi erzeugt, mit der man einen SPI Bus ansteuern kann.

In der Zeile spi.open(SPI_Bus, CS) wird mit der Methode open für die Instanz spi ein

bestimmter SPI Bus geöffnet und der anzusprechende Slave angegeben.

Die gewünschte maximale Taktfrequenz wird in der Zeile spi.max_speed_hz = f festge-

legt. Die tatsächliche Taktfrequenz liegt nicht über dem angegebenen Wert, kann aber darunter

80

liegen, weil a) der SPI Bus die Frequenz nur schrittweise ändern kann und b) der Prozessor zu

langsam für die gewünschte maximale Taktfrequenz sein könnte.

Um das Programm mit Ctrl-C abbrechen und dann noch einige "Aufräumarbeiten" durchführen zu

können, werden die Zeilen try: und except KeyboardInterrupt: verwendet, ähnlich

wie in früheren Pythonprogrammen (siehe oben).

Messung und Anzeige der Analogspannung geschehen im Anweisungsblock einer Endlosschleife,

die mit der Zeile while True: eingeleitet wird.

In der Zeile adc = spi.xfer2([6 + (Kanal >> 2), Kanal << 6, 0]) wird die

Methode xfer2 des spi Objekts mit einem Argument aufgerufen, das aus einer dreiteiligen Liste

besteht, und der Rückgabewert, der ebenfalls aus einer dreiteiligen Liste besteht, wird in der

Variablen adc gespeichert.

xfer2 sorgt für die Datenübertragung zwischen Master und Slave. Sie kann nur ganzzahlige Viel-

fache eines Bytes vom Master zum Slave (MOSI) senden und liest gleichzeitig dieselbe Anzahl von

Bytes von der anderen Datenleitung (MISO). Da für einen Messwert mindestens 19 zusammen-

hängende Bitpaare (Paar bedeutet: 1 Bit auf MOSI und 1 Bit auf MISO) übertragen werden müssen

(siehe unten), sind drei Byte-Paare (24 Bitpaare) notwendig, denn zwei Byte-Paare (16 Bitpaare)

wären zu wenig. Daher enthalten beide Listen der Methode xfer (Argument und Rückgabewert)

jeweils drei Byte.

19 Bitpaare für eine Messwertabfrage 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 15 17 18 19

Befehl vom Master an den Slave S U K K K

MOSI, 1. Byte 0 0 0 0 0 1 1 0

MOSI, 2. Byte 1 0 0 0 0 0 0 0

MOSI, 3. Byte 0 0 0 0 0 0 0 0

MISO, 1. Byte

MISO 2. Byte 1 1 1 1

MISO, 3. Byte 1 1 1 1 1 1 1 1

Datenwort, das den Messwert darstellt 1 1 1 1 1 1 1 1 1 1 1 1

19 Bitpaare für eine Messwertabfrage 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 15 17 18 19

Die 19 Bitpaare für eine Messwertabfrage bestehen aus einem Befehl vom Master an den Slave (5

Bits auf der MOSI / DIN Leitung), einer Pause zum Einlesen eines Messwerts (2 Bits) und dem

Datenwort, das den Messwert darstellt, welches vom Slave zum Master gesendet wird (12 Bits auf

der DOUT / MISO Leitung). Die 5 Bits des Befehls bestehen aus einem Startbit, S (1 = high), einem

81

Bit zur Festlegung der Messart, U (1 = high für unipolar oder 0 = low für bipolar, hier: 1) und drei

Bits zur Angabe des Messkanals, K K K (hier: binär 010 = dezimal 2).Zur Auffüllung auf 3 Byte-

Paare werden bei der Messwertabfrage den 19 Bits auf der MOSI Leitung fünf Bits vorangestellt,

die nur low = 0 enthalten. Die Abfolge der Bits auf den MOSI und MISO Leitungen wird in obigem

Diagramm veranschaulicht.

Die ersten 12 Bits auf der MISO Leitung (welche dem 12 Bit-Datenwort vorausgehen) sind

unwichtig (werden nicht ausgewertet) und wurden daher im Diagramm nicht angegeben. Das

Datenwort besteht in diesem Beispiel aus der Bitfolge 111111111111 , was dezimal der Zahl

4095 entspricht.

Die Methode xfer2 erwartet als Argument eine Liste von drei Bytes.

Das erste Byte (8 Bits) bekommt an der 8. Stelle (LSB) das höchstwertige Bit der Kanalnummer.

Dies geschieht, indem von den drei Bits, welche die Kanalnummer (dezimal zwischen 0 und 7)

repräsentieren (hier: 010), mit der Operation Kanal >> 2 die beiden letzten Bits entfernt

werden und das erste Bit (hier: 0) an die niederwertwertigste Stelle rückt. Dann werden durch

Addition von 6 = 4 + 2 die 6. Stelle (dezimal 4) und die 7. Stelle (dezimal 2) jeweis mit einer 1

besetzt, so dass hier das Byte 00000110 entsteht.

Das zweite Byte bekommt an der 1. Stelle (M SB ) und der 2. Stelle das zweite (hier: 1) beziehungs-

weise dritte Bit der Kanalnummer (hier: 0). Dies geschieht, indem von den drei Bits, welche die

Kanalnummer repräsentieren (hier: 010), mit der Operation Kanal << 6 das erste Bit entfernt

wird , das zweite Bit um sechs Stellen nach links an die 1. Stelle des Bytes, und das dritte Bit der

Kanalnummer um sechs Stellen nach links an die 2. Stelle des Bytes gerückt werden. So wird hier

das Byte 10000000 gebildet.

Das dritte Byte wird Null gesetzt, dies entspricht 00000000 .

Mit dem oben beschriebenen (durch drei Bytes repräsentierten) Befehl gibt die Methode xfer2 als

Rückgabewert eine Liste von drei Bytes (namens adc), die den Messwert enthalten.

In der Zeile Wert = ((adc[1]&15) << 8) + adc[2] wird aus der Liste adc die Variable

Wert gebildet, welche das Einzelintervall des Messspannungsbereichs des 12-Bit Wandlers bezeich-

net (siehe oben). Es gilt daher 0 ≤ Wert ≤ 4095 .

Das erste Byte der zurückgegebenen Liste ( adc[0] ) wird verworfen.

Vom zweiten Byte ( adc[1] ) werden, mithilfe der Operation adc[1]&15 , die 4 niederwertigsten

Bits genommen (dezimal 15 entspricht binär 00001111 und der Operator & erzeugt eine bitweise

UND-Verknüpfung). Diese werden mithilfe der Operation << 8 , um 8 Stellen nach links

verschoben, so dass sie die ersten 4 Stellen einer zwölfstelligen Binärzahl darstellen.

Zu den ersten 4 Stellen der zwölfstelligen Binärzahl wird das dritte Byte ( adc[2] ) addiert (letzte 8

Stellen der zwölfstelligen Binärzahl), so dass die zwölfstelligen Binärzahl fertig ist und ihr Wert der

Variablen Wert zugewiesen werden kann.

82

In der Zeile U = Uiv * Wert + Uiv/2 wird aus der Variablen Wert ein analoger Spannungs-

wert (Messwert in V) berechnet.

Der zu einem Einzelintervall Wert gehörige analoge Spannungswert liegt zwischen Wert · (VREF /

4096) und ( Wert + 1 ) · (VREF / 4096) und wir ordnen dem Einzelintervall Wert daher den Mittel-

wert ( Wert + Wert + 1 ) · (VREF / 4096) / 2 = Wert · (VREF / 4096) + (VREF / 4096) / 2 zu. Dies ge-

schieht in der Zeile U = Uiv * Wert + Uiv/2 und der so gefundene analoge Spannungs-

wert (in V) wird in der Variablen U gespeichert.

Mit print("Kanal 0:1d: Spannung = 1:4.2f V".format(Kanal,U))

werden die Werte der Variablen Kanal (einstellige Ganzzahl, d) und U (vierstellige Gleitkomma-

zahl, f, mit zwei Nachkommastellen) formatiert als Teils einer Zeichenkette auf dem Bildschirm

ausgegeben. Formatnummer 0 gibt eine Ganzzahl (d) einstellig aus; Formatnummer 1 gibt eine

Gleitkommazahl (rationale Zahl, f) mit vier Zeichen aus, wovon das erste Zeichen die Vor-

kommazahl, das zweite den Dezimalpunkt und das dritte und vierte Zeichen zwei Nachkomma-

stellen zeigen.

Die Zeile sleep(Pausendauer) ruft die Methode sleep der Klasse time auf, um (zwischen

zwei Messungen) die Programmausführung für Pausendauer Sekunden anzuhalten.

Nach Drücken von Ctrl-C wird mit der Zeile spi.close() der, bisher von der Instanz spi be-

legte, SPI Bus freigegeben.

In der letzten Zeile print("\n- Messung beendet -\n") wird eine Meldung an den

Nutzer ausgegeben.

Aufgabe 7

Ergänzen Sie das oben angegebene Python-Programm zur Spannungsmessung mit einer graphi -

schen Benutzeroberfläche (GUI). Als Layout-Vorlage kann wieder das oben (im Abschnitt GUI mit

Python, Modul Tkinter) beschriebene GUI dienen. Kleine Anpassungen sind natürlich notwendig.

Das Messergebnis soll im Textfeld (label) in folgendem Format angezeigt werden: x: y.yy V ,

wobei x die einstellige Kanalnummer des Wandlers angibt und y.yy den Spannungswert (in Volt)

als Gleitkommazahl mit einer Stelle vor und zwei Stellen nach dem Dezimaltrennzeichen. Die drei

Buttons (Schaltflächen) b1, b2 und b3 sollen mit den Zeichenketten "Kanal +", "Kanal -" und

"Ende" beschriftet werden.

Nach Programmstart soll die Nummer des Eingangskanals aus einer Datei namens mcp3208.dat

gelesen werden. (Falls die Datei noch nicht existiert, wird sie erzeugt und eine 0 hineinge-

schrieben.) Dann soll, automatisch fortlaufend, jede Sekunde ein Messwert genommen werden.

Nach Mausklick auf den Button b1 ("Kanal +") soll die Kanalnummer um 1 erhöht werden, wenn

sie 7 nicht überschreitet. Nach Klick auf den Button b2 ("Kanal -") soll die Kanalnummer um 1

erniedrigt werden, wenn sie 0 nicht unterschreitet. Nach Klick auf Button b3 ("Ende") soll das

Programm ordentlich (mit Freigabe des SPI Busses, siehe oben) beendet werden.

83

Experiment 6: Textausgabe auf LCD-Anzeigemodul

Schaltung 7 (LCD-Modul C0802-04)

Über die GPIOs ist auch eine Datenausgabe in Form von

Zeichenketten auf einen kleinen Bildschirm (LC-Display)

möglich. Die Daten werden an einen zum Display gehörigen

elektronischen Schaltkreis, den Controller, übergeben, der die

Darstellung steuert. Das Datenformat, in dem die Zeichen

übertragen werden müssen, wird vom verwendeten Controller

bestimmt.

Hier wird das LCD-Modul C0802-04 mit einem Controller vom Typ HD47780 verwendet (siehe

Bild rechts), weil es einfach und billig (< 1 € pro Stück) erhältlich war. Es kann auf einer Anzeige-

fläche von 44 mm · 23 mm zwei Zeilen mit jeweils 8 Zeichen (5 mm · 3 mm) anzeigen. Bei der An-

steuerung muss ein 4-Bit-Datenbus verwendet werden (obwohl der Controller auch 8-Bit-Worte

verarbeiten könnte), weil nur vier Datenleitungen herausgeführt sind.

Nachteilig ist beim LCD-Modul C0802-04 der für Bastler schwierige

Anschluss über das 10-polige Folien-Flachbandkabel des Displays,

welches ein enges Rastermaß von 1 mm aufweist. Man kann mit einem

scharfen Messer das Kabelende auftrennen und die einzelnen, am Ende

versilberten Leiter mit einem zweiten Kabel verbinden, das zu einer

Steck platine führt (und dort, wie bei Experiment 1 beschrieben, ange-

schlossen wird).15 Die Verbindung von den GPIOs zur Steck platine er-

folgt über ein Flachbandkabel; ein Ende hat eine Pfostenbuchse

(2x13polig beim Π_1B, 2x20polig beim Π_2B) für die Stiftleiste P1;

das andere Ende führt zur Steck platine (siehe Bild rechts).

Ein Problem beim Anschluss von Displays, deren Controller mit einer Versorgungsspannung VDD

von 5 V betrieben wird, ist die kleine Signalspannung der GPIOs, die ja nur 0 V (Signal low) oder

3,3 V (Signal high) abgeben können. Das Datenblatt des Controllers vom Typ HD47780 fordert eine

Spannung (Logikpegel) zwischen 0,7 · VDD und VDD für das Signal high und die 3,3 V = 0,66 · VDD

der GPIOs sind daher eigentlich zu wenig. Glücklicherweise funktionieren jedoch die meisten 5 V-

CMOS-Logikschaltungen auch noch mit einer Eingangssignalhöhe von nur 3,3 V und wir gehen im

folgenden davon aus, das dies auch hier der Fall ist.

Im ungünstigen Fall, wenn die 3,3 V nicht reichen, muss man die Spannung für das Signal high mit

einer Schaltung (für jede Leitung) von 3,3 V auf 5 V anheben. Das ist mit einem IC (74HCT241,

Alternative: 2 ICs 74HCT125) möglich, soll hier aber nicht näher behandelt werden. Beschreibun-

gen verschiedener Transistor-Anpassschaltungen findet man im Internet.

15 Zu diesem Flachkabel passende FFC/FPC-Steckverbinder (Buchsen) sind nicht bei jedem Bauteilehändler erhält-lich, können aber eventuell aus verschrotteten Geräten (zum Beispiel Videorekorder) ausgebaut werden. Leider haben sie oft eine Stiftleiste im engen Rastermaß von 1 mm, so dass es schwierig bleibt, ein Kabel anzulöten.

84

Das LCD-Modul C0802-04 wird mit insgesamt zehn Leitungen angeschlossen, davon je eine zur

Masse, (GND) zur Spannungsversorgung (VDD) und zu einer Hilfsspannung (VKontrast , die soge-

nannte Kontrastspannung); hinzu kommen drei Steuerleitungen (RS, RW und E) und vier Daten-

leitungen (D4, D5, D6 und D7). Jede Leitung geht von einem Pin auf der Platine aus. Die Reihen-

folge der 10 Pins ist auf der Platine des Displays angegeben. Die Pins sind wie folgt belegt:

Pin 1 2 3 4 5 6 7 8 9 10

GND VDD VKontrast RS RW E D4 D5 D6 D7

Pin 1 des Displays (GND) wird mit einem Masse-Pin von P1 verbunden, also mit Pin 6, 9, 14, 20

oder 25 (die Pin-Belegung der Stiftleiste P1 wurde oben im Abschnitt Digitale Anschlusspunkte:

GPIOs beschrieben).

Pin 2 des Displays (VDD) erhält die Versorgungsspannung für das Display, 5 V, und wird mit Pin 2

oder 4 von P1 verbunden. Es sei daran erinnert, dass die GPIOs als Eingänge eine Spannung von 5

V nicht verkraften.

Pin 3 des Displays (VKontrast) steuert den

Kontrast der Anzeige über eine

geeignete Spannung, die zwischen 0

und 5 V liegt. Diese Spannung kann mit

einem 10 kΩ - Potentiometer, eingestellt

werden, dessen äußere Anschlüsse mit

0 V (GND) und 5 V verbunden sind,

und dessen Mittelabgriff an Pin 3 des

Displays liegt. (Da die beste Kontrast-

spannung meistens näher bei 0 V als bei

5 V liegt, kann ein Potentiometer-

anschluss statt an 5 V auch an 3,3 V

angeschlossen werden.)

Pin 4 des Displays (RS) teilt dem

Display mit, ob Daten (Signal high)

oder ein Befehl (Signal low) gesendet

wird. Er wird mit einem GPIO, der als

Ausgang benutzt wird, zum Beispiel

GPIO 22 (Pin 15 von P1), verbunden.

Pin 5 des Displays (RW) teilt dem

Display mit, ob Daten gelesen (R,

Signal high) oder geschrieben (W,

Signal low) werden sollen. Da die

85

LC-Display-Modul C0802-04 GND V

DD V

Ktr RS RW E D4 D5 D6 D7

1 2 3 4 5 6 7 8 9 10

10kΩ

Pin 4von P1

5 V

Pin 6von P1GND

Pin 15von P1

GPIO 22

Pin 18von P1

GPIO 24

Pin 16von P1

GPIO 23

Pin 22von P1

GPIO 25

Pin 11von P1

GPIO 17

Pin 13von P1

GPIO 27

GPIOs keine 5 V erhalten dürfen (siehe oben), wird hier nur geschrieben und Pin 5 des Displays

daher mit einem Masse-Pin von P1 verbunden.

Pin 6 des Displays (E) wird genau dann von low auf high gesetzt, wenn an den anderen Anschlüssen

die Signalpegel anliegen und ausgelesen und verarbeitet werden sollen. Er wird auch mit einem

GPIO, der als Ausgang benutzt wird, zum Beispiel GPIO 23 (Pin 16 von P1), verbunden. Vor dem

Anlegen neuer Signale an die Pins des Displays muss E wieder auf low gesetzt werden.

Pin 7 - 10 des Displays (D4, D5, D6, D7) sind die Anschlüsse, welche die Daten (oder Befehle)

übergeben. Sie werden ebenfalls mit jeweils einem GPIO, der als Ausgang benutzt wird, verbunden,

zum Beispiel mit GPIO 24 (Pin 18 von P1), GPIO 17 (Pin 11 von P1), GPIO 25 (Pin 22 von P1)

und GPIO 27 (Pin 13 von P1).

Mit den oben genannten Zuordnungen müssen vom Programm folgende sechs GPIOs im

Schreibmodus angesprochen werden, um die Anschlüsse des Displays anzusteuern:

Anschlüsse RS E D4 D5 D6 D7

GPIOs GPIO 22 GPIO 23 GPIO 24 GPIO 17 GPIO 25 GPIO 27

86

Controller vom Typ HD47780

Controller vom Typ HD47780 können auf zwei Arten (Modi) arbeiten, nämlich im 8-Bit-Modus

oder im 4-Bit-Modus. Im 8-Bit-Modus werden Daten über 8 digitale Leitungen ein- und ausge-

geben, im 4-Bit-Modus über 4 digitale Leitungen. Hinzu kommen in beiden Modi drei digitale

Steuerleitungen, nämlich RS (Register Select), R/W (Read/Write) und E (Enable), sowie je eine

Leitung für Signalmasse, Versorgungsspannung ( 5 V ) und die Kontrastspannung (siehe oben).

Die digitalen Datenleitungen haben einen der beiden Zustände low (0) oder high (1). Über die

Leitungen kann man grundsätzlich entweder Daten zum Display senden (schreiben) oder vom

Display holen (lesen). Da wir jedoch die Steuerleitung R/W auf Masse (low) gelegt haben, können

wir nur zum Display senden, also schreiben.

Daten werden über alle Steuer- und Datenleitungen (parallel) gleichzeitig (synchron) während eines

bestimmten Zeitraums (Takt) übertragen. Vor der Übertragung von Daten an den Controller wird die

Steuerleitung E auf low gesetzt, dann werden die anderen Steuerleitungen (hier: RS) und

Datenleitungen (D0 - D7 im 8-Bit-Modus, D4 - D7 im 4-Bit-Modus) entsprechend der Daten

(Befehle oder Zeichen) auf low oder high gesetzt, und danach wird die Steuerleitung E auf high

gesetzt. Sobald E auf high liegt, beginnt der Controller mit der Verarbeitung der Daten. Nach dem

Takt wird die Steuerleitung E wieder auf low gesetzt, bevor – im nächsten Takt – an die anderen

Steuer- und Datenleitungen neue Daten gesandt werden.

Im 8-Bit-Modus wird in einem Takt ein Byte (8 Bits) übertragen. Im 4-Bit-Modus wird in einem

Takt ein halbes Byte oder Nibble (4 Bits) übertragen. Um im 4-Bit-Modus die gleiche Datenmenge

wie im 8-Bit-Modus zu übertragen, werden für ein Byte zwei Nibbles übertragen und dafür braucht

man zwei Takte. Im ersten Takt wird das höherwertige Nibble (die vier oberen Bits), im zweiten

Takt das niederwertige Nibble (die vier unteren Bits) übertragen. Die Übertragung im 4-Bit-Modus

ist daher langsamer als im 8-Bit-Modus, aber man spart vier Leitungen ein.

Der Controller des Displays braucht einige Zeit, um einen eingegangenen Befehl zu verarbeiten und

auszuführen. Bevor die Ausführung abgeschlossen ist, darf kein neuer Befehl gegeben werden. Ob

eine Befehl abgeschlossen wurde, könnte man vom Controller abfragen. Da wir aber keine Daten

vom Controller lesen wollen, sondern nur Daten schreiben, müssen wir so lange warten, bis die

Befehle spätestens abgearbeitet sind. Für die meisten Befehle braucht der Controller höchstens 40

μs. Die Befehle "Clear Display" und "Display & Cursor Home" brauchen aber länger, bis zu 1,7

ms. Im 4-Bit-Modus muss man auch nach Übertragung des höherwertigen Nibbles (im ersten Takt)

einige μs warten, bevor das niederwertige Nibble (im zweiten Takt) gesendet werden darf. Da wir es

beim Beschreiben des Displays nicht eilig haben, warten wir einfach stets 3 ms nach der Über-

tragung eines Nibbles. Wird können dann sicher sein, dass die Ausführung auch der langsameren

Befehle abgeschlossen wurde, bevor ein neuer gesendet wird.

87

Die Funktionsweise von Controller und Display wird durch binäre Variablen, sogenannte Steuerbits,

festgelegt, welche in einem internen Speicher des Controllers abgelegt sind und vom Benutzer über

Steuerbefehle verändert werden können.

Nach dem Einschalten des Displays durch Anlegen der 5 V Versorgungsspannung setzt der Con-

troller Startwerte für die Steuerbits (Ist-Werte in unten stehender Tabelle). Dies dauert etwa 15 m s.

Da der Controller verschiedene Displays steuern könnte, passen einige dieser Startwerte oft nicht

zum Display, mit dem er verbaut ist, insbesondere nicht zum hier verwendeten des LCD-Moduls

C0802-04. Daher müssen müssen einige Startwerte des Controllers neu und richtig gesetzt werden.

Da wir zum Zeitpunkt der Nutzung des Displays nicht sicher sein können, ob die Startwerte noch

gelten (oder durch Signale auf den GPIOs verändert wurden), setzen wir vorsichtshalber alle

Steuerbits auf die richtigen Werte (Soll-Werte in unten stehender Tabelle). Dies ist Aufgabe der

Initialisierung, bevor Zeichen in das Display geschrieben werden.

Binäre Variable ( Bit ) zurSteuerung des Displays

Name desSteuerbits

Startwert Bedeutung desSollwertsIst Soll

4- oder 8-Bit Interface DL high low 4-Bit Interface

1- oder 2/4-zeilige Anzeige N low high 2/4-zeilige Anzeige

5×8- oder 5x10-Zeichenmatrix F low low 5x8-Zeichenmatrix

Anzeige sichtbar oder nicht D low high Anzeige sichtbar

Cursor sichtbar oder nicht C low low Cursor nicht sichtbar

Cursor als Unterstrich oder Block B low low Cursor als Unterstrich

Cursor nach links oder rechts I / D high high Cursor nach rechts

Zeichenanzeige fest oder nicht S low low Zeichenanzeige fest

Bevor wir die Steuerbefehle für das Schreiben einer Zeichenkette kennenlernen, betrachten wir die

Codierung der Zeichen. Der Controller kann eine bestimmte Zeichenmenge darstellen. Jedes

Zeichen wird mit einem Byte (zwei Nibbles) codiert. Die folgende Tabelle zeigt eine Teilmenge, bei

der die Codierung dem 8-Bit ASCII Zeichensatz entspricht.

88

Zei-chen

Codierung vier obere Bits vier untere Bits

Dez. Hex. DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0

32 0x20 low low high low low low low low

! 33 0x21 low low high low low low low high

" 34 0x22 low low high low low low high low

, 44 0x2C low low high low high high low low

. 46 0x2E low low high low high high high low

/ 47 0x2F low low high low high high high high

: 58 0x3A low low high high high low high low

? 63 0x3F low low high high high high high high

A 65 0x41 low high low low low low low high

B 66 0x42 low high low low low low high low

C 67 0x43 low high low low low low high high

D 68 0x44 low high low low low high low low

E 69 0x45 low high low low low high low high

F 70 0x46 low high low low low high high low

G 71 0x47 low high low low low high high high

H 72 0x48 low high low low high low low low

I 73 0x49 low high low low high low low high

J 74 0x4A low high low low high low high low

K 75 0x4B low high low low high low high high

L 76 0x4C low high low low high high low low

M 77 0x4D low high low low high high low high

N 78 0x4E low high low low high high high low

O 79 0x4F low high low low high high high high

P 80 0x50 low high low high low low low low

Q 81 0x51 low high low high low low low high

R 82 0x52 low high low high low low high low

S 83 0x53 low high low high low low high high

T 84 0x54 low high low high low high low low

U 85 0x55 low high low high low high low high

V 86 0x56 low high low high low high high low

W 87 0x57 low high low high low high high high

X 88 0x58 low high low high high low low low

Y 89 0x59 low high low high high low low high

Z 90 0x5A low high low high high low high low

89

Beschreiben der Anzeige

Das LCD-Modul C0802-04 hat vier Datenleitungen und der eingebaute Controller kann daher nur

im 4-Bit-Modus betrieben werden. Da der Controller aber auch für den 8-Bit-Modus ausgelegt ist,

muss ihm zu Beginn der Datenübertragung mitgeteilt werden, dass der 4-Bit-Modus verwendet

wird. Das ist nicht einfach, wenn der Zustand des Controllers unbekannt ist.

Zum Zeitpunkt der Nutzung des Displays könnte der Controller a) im 8-Bit-Modus sein (zum

Beispiel nach Anlegen der Versorgungsspannung, siehe oben), b) im 4-Bit-Modus sein, und auf den

ersten Takt mit dem höherwertigen Nibble warten, c) im 4-Bit-Modus sein, und auf den zweiten

Takt mit dem niederwertigen Nibble warten, nachdem im ersten Takt der Befehl zum Umschalten in

den 8-Bit-Modus erfolgte, oder d) im 4-Bit-Modus sein, und auf den zweiten Takt mit dem

niederwertigen Nibble warten, ohne dass im ersten Takt der Befehl zum Umschalten in den 8-Bit-

Modus erfolgte. Die folgenden Befehle stellen sicher, dass der Controller in jedem dieser Fälle in

den 4-Bit-Modus versetzt wird:

E RS D7 D6 D5 D4

8-Bit-Moduseinschalten

low low low low high high

high " " " " "

3 ms warten (danach wird E auf low gesetzt, um den Befehl abzuschließen)

8-Bit-Moduseinschalten

low low low low high high

high " " " " "

3 ms warten (danach wird E auf low gesetzt, um den Befehl abzuschließen)

8-Bit-Moduseinschalten

low low low low high high

high " " " " "

3 ms warten (danach wird E auf low gesetzt, um den Befehl abzuschließen)

4-Bit-Moduseinschalten

low low low low high low

high " " " " "

3 ms warten (danach wird E auf low gesetzt, um den Befehl abzuschließen)

Dabei bedeutet " , dass der vorherige Wert (Zeile oberhalb) unverändert bleibt. Nach dem Setzen des

4-Bit-Modus muss jeder Befehl in zwei Schritten gesendet werden, um alle 8 Bits eines Befehls zu

übertragen.

Das LCD-Modul C0802-04 hat eine zweizeilige Anzeige mit 5x8-Zeichenmatrix16. Wir wollen die

geschriebenen Zeichen stets sehen und verzichten im Folgenden auf das Ein- und Ausblenden der

Anzeige. Wenn der Cursor sichtbar ist, wird er nach dem letzten Zeichen angezeigt, also an der

Position, an der das nächste Zeichen geschrieben werden kann. Man kann den Cursor mit dem hier

16 Bei der 5 x 8-Zeichenmatrix stehen 5 x 7 Pixel (horizontal x vertikal) zur Darstellung eines Zeichens zur Verfügung und die unterste Zeile (5 x 1 Pixel) dient nur zur Darstellung des Cursors, wenn dieser gezeigt wird.

90

verwendeten Display verwenden, aber in den folgenden Beispielen bleibt er ausgeschaltet. Der

Cursor kann als Unterstrich oder blinkender Block dargestellt werden. Bei nicht sichtbarem Cursor

ist das natürlich unbedeutend. Der Controller enthält einen Zeichenspeicher, welcher mehr als die

sichtbaren Zeichen speichern kann. Bei fester Zeichenanzeige nutzt man nur den ersten Teil des

Zeichenspeichers für die Anzeige; dies ist einfacher. Da Deutsch und Englisch von links nach rechts

geschrieben wird, sollte der Cursor nach dem Schreiben eines Zeichens nach rechts rücken.

Folgende Befehle setzen die Steuerbits richtig, löschen die Anzeige und setzen den Cursor an den

Anfang, sodass danach Zeichen geschrieben werden können. * bedeutet, dass der Wert egal ist.

E RS D7 D6 D5 D4

Steuerbits

1. Nibble,D4:

DL = low, 2. Nibble,D7 - D6:N = highF = low

low low low low high low

high " " " " "

3 ms warten (danach wird E auf low gesetzt, um den Befehl abzuschließen)

low low high low * *

high " " " " "

3 ms warten (danach wird E auf low gesetzt, um den Befehl abzuschließen)

Steuerbits

2. Nibble,D6 - D4:D = highC = lowB = low

low low low low low low

high " " " " "

3 ms warten (danach wird E auf low gesetzt, um den Befehl abzuschließen)

low low high high low low

high " " " " "

3 ms warten (danach wird E auf low gesetzt, um den Befehl abzuschließen)

Steuerbits

2. Nibble,D5 - D4:

I / D = highS = low

low low low low low low

high " " " " "

3 ms warten (danach wird E auf low gesetzt, um den Befehl abzuschließen)

low low low high high low

high " " " " "

3 ms warten (danach wird E auf low gesetzt, um den Befehl abzuschließen)

Anzeigelöschen

undCursoran denAnfangsetzen

low low low low low low

high " " " " "

3 ms warten (danach wird E auf low gesetzt, um den Befehl abzuschließen)

low low low low low high

high " " " " "

3 ms warten (danach wird E auf low gesetzt, um den Befehl abzuschließen)

91

Mit folgender Befehlsfolge kann man nun das Zeichenpaar OK auf dem Display schreiben.

E RS D7 D6 D5 D4

schreibt denBuchstaben

O(und rücktdann den

unsichtbarenCursor

nach rechts)

low high low high low low

high " " " " "

3 ms warten (danach wird E auf low gesetzt, um den Befehl abzuschließen)

low high high high high high

high " " " " "

3 ms warten (danach wird E auf low gesetzt, um den Befehl abzuschließen)

schreibt denBuchstaben

K(und rücktdann den

unsichtbarenCursor

nach rechts)

low high low high low low

high " " " " "

3 ms warten (danach wird E auf low gesetzt, um den Befehl abzuschließen)

low high high low high high

high " " " " "

3 ms warten (danach wird E auf low gesetzt, um den Befehl abzuschließen)

Befehlsende low " " " " "

Allgemein gilt bei der Übertragung einer Zeichenkette an den Controller: Die ersten 8 Zeichen, die

an den Controller gesandt werden, ergeben die obere Zeile (eventuell mit Leerzeichen). Das 41. bis

48. an den Controller gesandte Zeichen wird in der unteren Zeile gezeigt. Nach dem 8. Zeichen der

oberen Zeile muss man also 32 Leerzeichen (oder beliebige andere Zeichen) senden und erst danach

die Zeichenkette für die untere Zeile. Dies merkwürdige Verfahren rührt daher, dass der Controller

nicht nur den vorliegenden Typ mit 8 Zeichen pro Zeile versorgen kann, sondern auch Displays mit

40 Zeichen pro Zeile.

Aufgabe 8

a) Schreiben Sie ein Python-Programm, das OK auf dem Display schreibt !

b) Schreiben Sie ein Python-Programm, das in der oberen Zeile des Displays HALLO und in der

unteren Zeile des Displays WELT! schreibt !

92

Anhang

Internetradio- und Internetfernsehsender und ihre URLs

Radiosender, die mit dem Mediaplayer omxplayer abgespielt werden können:

afk M94.5 http://stream.m945.mwn.de:80/m945-hq.oggBayern 1 http://br-mp3-bayern1muc-s.akacast.akamaistream.net/7/487/142690/v1/gnl.akacast.akamaistream.net/br_mp3_bayern1muc_s

Bayern 2http://br-mp3-bayern2sued-s.akacast.akamaistream.net/7/717/256282/v1/gnl.akacast.akamaistream.net/br_mp3_bayern2sued_s

BR-Klassik http://br-mp3-br-klassik-s.akacast.akamaistream.net/7/150/142693/v1/gnl.akacast.akamaistream.net/br_mp3_br-klassik_s

B5 aktuellhttp://br-mp3-b5aktuell-s.akacast.akamaistream.net/7/773/142694/v1/gnl.akacast.akamaistream.net/br_mp3_b5aktuell_sBBC Radio 1 http://bbcmedia.ic.llnwd.net/stream/bbcmedia_radio1_mf_pBBC Radio 4 http://bbcmedia.ic.llnwd.net/stream/bbcmedia_radio4fm_mf_pBBC Radio 4 Extra http://bbcmedia.ic.llnwd.net/stream/bbcmedia_radio4extra_mf_pBBC Radio 5 Live http://bbcmedia.ic.llnwd.net/stream/bbcmedia_radio5live_mf_pBBC World Service http://bbcwssc.ic.llnwd.net/stream/bbcwssc_mp1_ws-eieukBerliner Rundfunk 91.4 http://stream.berliner-rundfunk.de/brf/mp3-128/internetradioBremen Eins http://rb-mp3-m-bremeneins.akacast.akamaistream.net/7/716/234436/v1/gnl.akacast.akamaistream.net/rb-mp3-m-bremeneins

Campusradio Jena http://crjstream.stud.fh-jena.de:8090/Campusradio-JenaDeutschlandfunk http://dradio_mp3_dlf_s.akacast.akamaistream.net/7/251/142684/v1/gnl.akacast.akamaistream.net/dradio_mp3_dlf_s

DRadio Wissen http://dradio_mp3_dwissen_s.akacast.akamaistream.net/7/698/142684/v1/gnl.akacast.akamaistream.net/dradio_mp3_dwissen_s

DW English (Sendezeit) http://dw-radio-english-mp3.akacast.akamaistream.net/7/779/135362/v1/gnl.akacast.akamaistream.net/dw-radio-english-mp3

France Musique http://audio.scdn.arkena.com/11012/francemusique-midfi128.mp3F ritz (128kbit/s) http://fritz.de/livemp3 Hoerspielprojekt http://stream.laut.fm:80/hoerspielKlassik Radio http://stream.klassikradio.de/live/mp3-128/www.klassikradio.de/Klassik Radio - Barock http://stream.klassikradio.de/barock/mp3-128Klassik Radio - Pure Bach http://stream.klassikradio.de/purebach/mp3-128K lassik Radio - Pure Mozart http://stream.klassikradio.de/puremozart/mp3-128KACU http://stream1.kacu.org:8012/liveKPFK http://ic1.mainstreamnetwork.com/kpfk-fm.mp3LBC http://media-ice.musicradio.com/LBCUKMP3LowMDR Figarino http://c22033-l.i.core.cdn.streamfarm.net/22033mdr/live/3087mdr_figaro/ch_figarino_128.mp3

MDR Sputnik http://d85195728.i.tis.core005.cdn.streamfarm.net:80/22005mdrsputnik/live/3087mdr_sputnik_live/de_96.mp3

Newstalk (96kbit/s) http://176.124.246.11/nt Radio Blau (Leipzig) http://stream.radioblau.deRadio Klasika Bratislava http://live-icy.gss.dr.dk:8000/A/A04H.mp3Radio1920 http://stream.laut.fm/radio1920RBB Inforadio http://inforadio.de/livemp3 RBB Kulturradio http://kulturradio.de/livemp3Sport1.fm http://stream.sport1.fm/api/livestream-redirect/SPORT1FM_24_7.mp3SRF 2 Kultur http://stream.srg-ssr.ch/m/drs2/mp3_128 SRF 4 News http://stream.srg-ssr.ch/m/drs4news/mp3_128

StadtRadio Göttingen http://stream.stadtradio-goettingen.de:8000/stadtradio.mp3Rai Radio 5 Classica http://icestreaming.rai.it/5.mp3Sputnik Deutschland http://audio1.video.ria.ru/voicegerSputnik U S / China http://audio2.video.ria.ru/voiceeng / http://audio1.video.ria.ru/voicechiUK 1940s Radio Station http://1940sradio1.co.uk:8100/1Vermont Public Radio http://vpr.streamguys.net/vpr96.mp3WDR 5 http://wdr-5.akacast.akamaistream.net/7/41/119439/v1/gnl.akacast.akamaistream.net/wdr-5WEKU http://pubint.ic.llnwd.net/stream/pubint_wekuWMBR MIT campus http://stream.wmbr.org:8000/hi WNPV http://162.244.80.33:8700/;stream.mp31000 Oldies http://streaming.radionomy.com/1000Oldies 1920s R adio Network http://kara.fast-serv.com:8358/

93

Shell-Skript für ein einfaches Web-Radio, das den omxplayer verwendet

Wenn man das folgende Skript unter dem Namen radio1 speichert und (mit dem Konsolenbefehl

chmod a+x radio1) das Ausführungsrecht gibt, kann man es mit ./radio1 starten.

#!/bin/bash

# radio1

# einfaches Web-Radio, das den omxplayer verwendet

PS3="Auswahl (9 = ausschalten): "

select eingabe in "Bayern 2" "Bayern 5 aktuell" "BBC World Service" "Bremen 1" \

"Deutschlandfunk" "RBB Kulturradio" "SRF 4 News" "WDR 5" ausschalten

do

if [[ $REPLY == [1-8] ]]; then

echo $eingabe ; echo "Tasten: - leiser, + lauter, q = beenden" ; fi

case "$eingabe" in

"Bayern 2")

omxplayer -o both http://br-mp3-bayern2sued-s.akacast.akamaistream.ne\

t/7/717/256282/v1/gnl.akacast.akamaistream.net/br_mp3_bayern2sued_s 1> /dev/null

;;

"Bayern 5 aktuell")

omxplayer -o both http://br-mp3-b5aktuell-s.akacast.akamaistream.net/7/7\

73/142694/v1/gnl.akacast.akamaistream.net/br_mp3_b5aktuell_s 1> /dev/null

;;

"BBC World Service")

omxplayer -o both http://bbcwssc.ic.llnwd.net/stream/bbcwssc_mp\

1_ws-eieuk 1> /dev/null

;;

"Bremen 1")

omxplayer -o both http://rb-mp3-m-bremeneins.akacast.akamaistream.ne\

t/7/716/234436/v1/gnl.akacast.akamaistream.net/rb-mp3-m-bremeneins 1> /dev/null

;;

"Deutschlandfunk")

omxplayer -o both http://dradio_mp3_dlf_s.akacast.akamaistream.net/7/251/142684/v1/gnl.aka\

cast.akamaistream.net/dradio_mp3_dlf_s 1> /dev/null

;;

"RBB Kulturradio")

omxplayer -o both http://kulturradio.de/livemp3 1> /dev/null

;;

"SRF 4 News")

omxplayer -o both http://stream.srg-ssr.ch/m/drs4news/mp3_128 1> /dev/null

;;

"WDR 5")

omxplayer -o both http://wdr-5.akacast.akamai\

stream.net/7/41/119439/v1/gnl.akacast.akamaistream.net/wdr-5 1> /dev/null

;;

*)

break

;;

esac

sleep 1done

94

Radiosender, die mit dem vlc gehört werden können:

BBC Four http://www.radiofeeds.co.uk/bbcradio4fm.plsBBC Radio 4 Extra http://www.radiofeeds.co.uk/bbcradio4extra.plsBBC World Service (48kbit/s)http://wsdownload.bbc.co.uk/worldservice/meta/live/shoutcast/mp3/eieuk.plsBritish Comedy Radio http://listen.abacus.fm/britishcomedy.m3uCBC Radio One http://www.surfmusic.de/m3u/cbcv-cbc-radio-one-90-5-fm,15345.m3uCountry 95.5 FM http://www.surfmusik.de/m3u/chlb-country-95-5,15299.m3uFox News Talk http://www.surfmusic.de/m3u/fox-news-talk,18436.m3uGuldkanalen 60-tal http://www.guldkanalen.se/static/streamGK60/64AAC.plsHank's Old Time Radio (32kbit/s) http://myradiostream.com/hanksotrKALW San Francisco http://live.str3am.com:2430/listen.plsLBC http://media-ice.musicradio.com/LBCUK.m3uMDR Info http://avw.mdr.de/livestreams/mdr_info_live_128.m3uN DR Info (Nds.) http://www.ndr.de/resources/metadaten/audio/m3u/low/ndrinfo_nds.m3uNDR Info Spezial http://www.ndr.de/resources/metadaten/audio/m3u/low/ndrinfo_spezial.m3uN DR Kultur http://www.ndr.de/resources/metadaten/audio/m3u/low/ndrkultur.m3uNDR K. klass. unterwegs http://www.ndr.de/resources/metadaten/audio/m3u/ndrloop4.m3uNDR 1 (Oldenburg) http://www.ndr.de/resources/metadaten/audio/m3u/low/ndr1niedersachsen_ol.m3uNDR 2 (Niedersachsen) http://www.ndr.de/resources/metadaten/audio/m3u/low/ndr2_nds.m3uNDR 90,3 http://www.ndr.de/resources/metadaten/audio/m3u/ndr903.m3uNewsTalkRadio 77 WABC http://www.surfmusic.de/m3u/wabc-770-am,205.m3uNewstalk ZB (64kbit/s) http://streaming.radiomyway.co.nz/zbakalt.plsNordwestradio http://www.surfmusik.de/m3u/nordwestradio,8567.m3uNPR Program Stream http://www.npr.org/streams/mp3/nprlive24.m3uPolish Radio http://mp3.polskieradio.pl:8908R adio 10 60s & 70s Hits http://stream.radiocorp.nl/r10_6070s_mp3.m3uR.SA Oldieclub http://streams.rsa-sachsen.de/rsa-oldies/mp3-128/listenlive/play.m3uSchlagertempel http://radio-schlagertempel.de/listen.plsSputnik Deutschland http://nfw.video.ria.ru/flv/audio.aspx?ID=97594110&amp;type=mp3WBUR Boston NPR http://audio.wbur.org/stream/live_mp3.m3uWCBS Newsradio 880 http://www.surfmusic.de/m3u/wcbs-880-am,6270.m3uWDR 1 Live http://www.wdr.de/wdrlive/media/einslive.m3uWDR 2 http://www.wdr.de/wdrlive/media/wdr2.m3uWDR 3 http://www.wdr.de/wdrlive/media/wdr3.m3uWDR 4 http://www.wdr.de/wdrlive/media/wdr4.m3uWDR 5 http://www.wdr.de/wdrlive/media/wdr5.m3uWDR KinderRadioKanal http://www.wdr.de/wdrlive/media/kiraka.m3uWNYC New York http://www.wnyc.org/stream/wnyc-fm939/aac.plsWPR Ideas Network http://wpr-ice.streamguys.net/wpr-ideas-mp3-64.m3uWPR News & Classical N. http://wpr-ice.streamguys.net/wpr-music-mp3-96.m3uWPR All Classical Netw. http://wpr-ice.streamguys.net/wpr-hd2-mp3-96.m3uWPR Special Events http://wpr-ice.streamguys.net/wpr-special-64.m3uWQXR classical music http://www.wnyc.org/stream/wqxr/windows.plsWUNC (64kbit/s) http://mediaserver.wuncfm.unc.edu:8000/wunc64.m3u24/7 News http://www.surfmusic.de/m3u/24-7-news,18547.m3u

Zum Beispiel wird BBC Four mit folgendem Konsolenbefehl gespielt:cvlc http://www.radiofeeds.co.uk/bbcradio4fm.pls

95

Fernsehsender, die mit omxplayer und vlc gesehen werden können:

Fernsehen über das Internet ist mit den oben genannten Programmen auf dem Π_1B kaum, auf den

leistungsstärkeren Π_2B und Π_3B aber möglich. Mit vlc oder dem omxplayer , kann man ver-

schiedene deutsche Fernsehsender wiedergeben. Die ARD-Programme Das Erste und Tagesschau24

empfängt man über die URLs

http://daserste_live-lh.akamaihd.net/i/daserste_de@91204/master.m3u8

http://tagesschau-lh.akamaihd.net/i/tagesschau_1@119231/master.m3u8

und das ZDF-Programm, ZDFinfo , ZDFneo und ZDFkultur über

http://zdf1314-lh.akamaihd.net/i/de14_v1@392878/master.m3u8?b=0-736&dw=0&__a__=off

http://zdf1112-lh.akamaihd.net/i/de12_v1@392882/master.m3u8?b=0-736&dw=0&__a__=off

http://zdf1314-lh.akamaihd.net/i/de13_v1@392877/master.m3u8?b=0-736&dw=0&__a__=off

http://zdf1112-lh.akamaihd.net/i/de11_v1@392881/master.m3u8?b=0-736&dw=0&__a__=off

Bayerisches Fernsehen über

http://livestreams.br.de/i/bfssued_germany@119890/master.m3u8

NDR Fernsehen über

http://ndr_fs-lh.akamaihd.net/i/ndrfs_nds@119224/master.m3u8

rbb Fernsehen über

http://rbb_live-lh.akamaihd.net/i/rbb_berlin@108248/master.m3u8

SR Fernsehen und WDR Fernsehen über

http://livestream.sr-online.de/live.m3u8

http://www.metafilegenerator.de/WDR/WDR_FS/m3u8/wdrfernsehen.m3u8

das sogenannte Bildungsfernsehen ARD-alpha über

http://livestreams.br.de/i/bralpha_germany@119899/master.m3u8

ARTE über

http://delive.artestras.cshls.lldns.net/artestras/contrib/delive.m3u8

und den Fernsehsender 3sat über die URL

http://zdf0910-lh.akamaihd.net/i/dach10_v1@392872/master.m3u8?dw=0

empfangen. Die staatliche Auslandssender Deutsche Welle ist auf folgenden URLs zu empfangen:

http://www.metafilegenerator.de/DWelle/tv/ios/master.m3u8

http://www.metafilegenerator.de/DWelle/tv-asia/ios/master.m3u8http://www.metafilegenerator.de/DWelle/tv-northamerica/ios/master.m3u8

Die österreichischen Fernsehsender ORF 1 , 2 , 3 und ORF sport sind über die URLs

http://apasfiisl.apa.at/ipad/orf1_q4a/orf.sdp/playlist.m3u8

http://apasfiisl.apa.at/ipad/orf2_q4a/orf.sdp/playlist.m3u8

96

http://apasfiisl.apa.at/ipad/orf3_q4a/orf.sdp/playlist.m3u8

http://185.85.28.20/orfs/q8c.sdp/chunklist.m3u8

zu sehen. Allerdings ist die Wiedergabe in Deutschland eingeschränkt. Nachrichten auf Deutsch

beziehungsweise Englisch gibt es von Euronews mit den URLs

rtsp://ewns-hls-b-stream.hexaglobe.net/rtpeuronewslive/de_vidan750_rtp.sdprtsp://ewns-hls-b-stream.hexaglobe.net/rtpeuronewslive/en_vidan750_rtp.sdp

Englischsprachige Nachrichten erhält man auch vom US-Sender ABC News ,

http://abclive.abcnews.com/i/abc_live4@136330/index_1200_av-b.m3u8http://abclive.abcnews.com/i/abc_live4@136330/master.m3u8?b=500,300,700,900,1200

Wirtschaftsnachrichten von Bloomberg Television :

http://btv-i.akamaihd.net/hls/live/202760/btvusa_ios/P1/M700.m3u8

Kleinere Sender in den USA sind zum Beispiel University of California TV , Jupiter Broadcasting ,

KTVU (San Francisco Bay Area) , This Week in Tech , und WGN Chicago :

rtmp://ucsdtv-wowza.ucsd.edu:1935/live/live_800

rtsp://videocdn-us.geocdn.scaleengine.net/jblive/live/jblive.stream

http://ktvulive-i.akamaihd.net/hls/live/224677/ktvu1/master.m3u8

http://bglive-a.bitgravity.com/twit/live/highhttp://wgntribune-lh.akamaihd.net/i/WGNPrimary_1@304622/index_350_av-p.m3u8

In England gibt es London Live und in Irland RTÉ News Now :

http://bcoveliveios-i.akamaihd.net/hls/live/217434/3083279840001/master_900.m3u8

http://wmsrtsp1.rte.ie/live/android.sdp/playlist.m3u8

Englischsprachige Nachrichten vom französischen Sender France 24 , vom japanischen NHK World ,

von den russischen RT International und RT Documentary , vom arabischen Al Jazeera English , von

den indischen NDTV 24x7 und NewsX , und vom nigerianischen TVC News erhält man mit

http://static.france24.com/live/F24_EN_LO_HLS/live_web.m3u8http://web-cache.stream.ne.jp/www11/nhkworld-tv/global/222714/live.m3u8

http://rt.ashttp14.visionip.tv/live/rt-global-live-HD/playlist.m3u8

http://rt.ashttp14.visionip.tv/live/rt-doc-live-HD/playlist.m3u8http://aljazeera-eng-apple-live.adaptive.level3.net/apple/aljazeera/english/appleman.m3u8

http://bglive-a.bitgravity.com/ndtv/247hi/live/nativehttp://newsx.live-s.cdn.bitgravity.com/cdn-live/_definst_/newsx/live/newsxnew.smil/playlist.m3u8

http://77.92.76.135:1935/tvcnews/livestream/playlist.m3u8

Auf iPanda gibt es rund um die Uhr nur Pandabären zu sehen:

http://fms.cntv.lxdns.com/live/flv/channel95.flv

Neues von der NASA kann man auf folgenden URLs betrachten:

http://nasatv-lh.akamaihd.net/i/NASA_101@319270/master.m3u8http://iphone-streaming.ustream.tv/uhls/6540154/streams/live/iphone/playlist.m3u8

97

Raspbian Wichtige Befehle für die Kommandozeile

Tasten für Kopieren: Shift+Strg+C , Einfügen: Shift+Strg+V ; Blättern in früheren Befehlen: /

Informationenwhatis / man bf kurze / lange Info zu einem Befehl bf ; apropos bf suche in man-Seitendf -m zeige gesamten, belegten und verfügbaren Speicherplatz in MB (Option -m)date zeige Datum und Uhrzeit; date +%D zeige Datum; date +%T zeige Uhrzeitcal zeige Kalender für aktuellen Monat; ncal -3w zeige 3 Monate, Kalenderwochenhostname zeige Rechnername; uname -a zeige Betriebssystem und Rechnertypid zeige uid (Nutzer-ID), gid (Gruppen-ID) und Gruppenzugehörigkeiten des aktuellen Nutzerssudo fdisk -l zeige Info zu angeschlossenen Datenträgern (SD-Karte, eventuell USB-Stick)

Software-Verwaltungsudo apt-get update aktualisiere die Datenbank für die Paketverwaltung APTsudo apt-get upgrade aktualisiere die installierten Pakete (nach ... update anwenden)apt-cache search "txt" suche nach Pakten, deren Kurzbeschreibung txt enthaltenapt-cache policy pk ob für ein installiertes Paket pk eine neue Version verfügbar istsudo apt-get install prg installiere das über die APT verfügbare Paket prgsudo apt-get purge prg prg vollständig, einschließlich Konfigurationsdateien entfernen

Dateien (zum Beispiel d1 und d2) und Verzeichnisse (z. B. v1 und v2, Heimatverzeichnis: ~ )ls -l zeige Verzeichnisinhalt, -a auch versteckte ; pwd zeige Pfad zum Arbeitsverz.cd v1 wechsle Arbeitsv. ; cd wechsle ins Heimatv.; cd .. ins übergeordnete V. mkdir v1 Verz. anlegen ; mv v1 v2 umbenenne / verschiebe V. ; rm -r v1 lösche V.touch d1 erzeuge Datei ; mv d1 d2 / v1 umbenenne / verschiebe D. ; rm d1 lösche D.chmod R d1 setze (+) / lösche (-) Rechte R: u Nutzer, g Gruppe, a alle, r read, w write, x executecp d1 d2 kopiere Datei; cp d1 v1 k. in Verzeichnis v1 ; cp -r v1 v2 k. Verzeichniscat d1 zeige Datei-Inhalt; cat d1 d2 > d12 hänge Dateien aneinander (Konkatenation)less d1 zeige Datei seitenweise, / / Bild / Bild Zeile oder Seite vor / zurück, q Endegrep tx d1 zeige Zeilen in d1, welche die Zeichenkette oder Regulären Ausdruck tx enthaltenbf1 | bf2 Pipe, leitet die Standardausgabe des Befehls bf1 an die Eingabe des Befehs bf2wc d1 zähle Zeilenumbrüche, Wörter und Bytes, -c Bytes, -l Zeilen, -m Zeichen, -w Wörtersum / cksum / md5sum / sha256sum d1 errechne Prüfsumme / (128 / 256 bit) Hashwert> d1 , >> d1 Ausgabe in d1 umlenken (überschreiben, anhängen); < d1 Eingabe aus d1 lesen./d1 führe das in der Datei d1, die im aktuellen Verzeichnis liegt, gespeicherte Programm aus

Archive verarbeiten

tar cfv archiv.tar d1 d2 packe Dateien oder Ordner, -c create, -f file, -v verbosetar xfv archiv.tar entpacke Archiv (Tarball) einschließlich Benutzerrechte, -x extracttar cfzv archiv.tar d1 d2 erstelle komprimiertes Archiv, -z komprimierentar xfvz archiv.tar.gz Archivdatei archiv.tar.gz dekomprimieren und auspacken

Prozess-Operationen und Netzwerkbetrieb (Schnittstellen, Kabel: etho und Funk: wlan0)

ps -ef zeige Liste aller laufenden Prozesse (Option -e) in ausführlichem Format (-f)pgrep -l txt zeige alle Prozesse, deren Name die Zeichenkette txt enthältkill pid bitte Prozess pid, sich zu beenden; kill -9 pid beende Prozess pidpkill txt oder pkill -9 txt bitte / zwinge Prozesse mit txt im Namen zum Endesleep x mache eine Pause von x Sekunden (in Shell-Skripten zur Programmunterbrechung)ip a zeige IP-Adressen ; sudo ip l set up / down dev eth0 schalte etho ein / ausping / ping6 -c n host teste n mal, ob host (Name, IPv4- / IPv6-Adresse) erreichbar ist

98

Bash Shell-Variablen

Lokale Shell-Variablen (speichern zugewiesene und andere spezielle Werte eines Shell-Skripts)

Variablen wird (ohne vorherige Deklaration) durch den Operator = ein Wert zugewiesen. Vor und nach = dem darf kein Leerzeichen stehen. Die Befehlszeile a=42 ; a="Sinn des Lebens" belegt die Variable a zunächst mit dem Wert "42" , danach mit dem Wert "Sinn des Lebens". Ohne weitere Festlegungen werden alle Werte als Zeichenkette gespeichert. Zeichenketten mit Leer- oder Sonderzeichen müssen in Anführungszeichen stehen. Um auf den Inhalt einer Variablen zuzugrei-fen, schreibt mn ein $ vor den Variablennamen, zum Beispiel zeigt echo a den Inhalt der Vari-ablen a . Lokale Variablen sind zunächst nur in der Shell verfügbar, in der sie erzeugt wurden. Durch exportieren werden sie aber auch in Subshells (Shells, die von der aktuellen Shell erzeugt werden) verfügar. Zum Beispiel wird mit dem Befehl export a die Variable a exportiert. Eine Ausnahme bilden Subshells, sie durch Klammerung () von Befehlen erzeugt werden; bei Ihnen werden die wurden alle Variablen automatisch aus der Vater-Shell exportiert.Neben nutzerdefinierten Variablen gibt es auch von der Shell erzeugte, spezielle lokale Variablen:

? Exit-Staus des letzten Vordergrund-Prozesses [0 , wenn kein Fehler auftrat]$ Prozess-ID der aktuellen Shell! Prozess-ID des zuletzt aufgerufenen Hintergrund-Prozesses0 Programm-Name; 1 - 9 Positionsparameter (bei Aufruf eines Shell-Skripts)# Anzahl der Positionsparameter; * / @ Zeichenkette / Liste der Positionsparameter

Mit readonly kann man Konstanten (schreibgeschützte Variablen) definieren. Mit dem Befehl env zeigt man Umgebungsvariablen und exportierte Variablen an und mit set alle Variablen.

Umgebungsvariablen (globale Variablen, sie speichern Infos für die Shell und andere Programme)Umgebungsvariablen werden automatisch beim Start einer Shell auf einen bestimmten Wert gesetzt (siehe unten) und enthalten, sofern ihr Wert nicht verändert wird, in allen Shells den gleichen Wert.

BASH Pfad zur aktuellen Shell [bei Raspbian in der Regel: /bin/bash]BASH_ENV Name einer Datei die beim Start einer neuen Shell statt .bashrc ausgeführt wird []BASH_VERSION Version der aktuellen Shell [4.3.30(1)-release (oder höher)]EUID effektiver Nutzer-ID des aktuellen Benutzers [1000 (nach normalem Log-in)]HOME Home-Verzeichnis des aktuellen Benutzers [/home/pi (nach normalem Log-in)]HOSTNAME Rechnername [raspberrypi (wenn kein anderer Name konfiguriert wurde)]IFS Internal Field Separator, Trennzeichen [beliebig viele Leerzeichen, Tabs, Newlines]LANG länderspezifischer Zeichensatz [de_DE.UTF-8 (nach deutscher Konfiguration)]LINENO aktuelle Zeilennummer, die beim Debugging von Bash-Skripten nützlich sein kannLOGNAME Login-Name des aktuellen Benutzers [pi (nach normalem Log-in)]MAIL Mailbox, Name einer Datei zur Speicherung ankommender E-mailsMAILCHECK Periodendauer (in s) für die Prüfung, ob eine E-Mail angekommen ist [60]PATH Liste von Pfadnamen, die durch : getrennt sind, für die Suche nach KommandosPPID Prozess-ID des Vater-Prozesses, Subshells, die Shell-Kopien sind, behalten die PPIDPS3 Eingabe-Prompt von Menüs, die mit einem Shell-Skript erzeugt wurdenPWD Pfad zum aktuellen ArbeitsverzeichnisRANDOM ganze Zufallszahl z, 0 ≤ z ≤ 32767; Initialisierung des Generators mit RANDOM=nREPLY in einem Shell-Skript: gewählte Nummer in Menü oder eingelesene Zeile bei readSECONDS Laufzeit in Sekunden der aktuellen Shell, kann auf neuen Startwert gesetzt werdenSHLVL shell level, Verschachtelungstiefe der Shell, zum Beispiel 1 für eine Konsolen-ShellTERM Terminal-Typ (dessen Bildschirmsteuersequenzen in einer Datei beschreiben werden)UID Nutzer-ID des aktuellen Benutzers [1000 (nach normalem Log-in)]

99