Für alle folgenden Übungen wird vorausgesetzt, dass der Raspberry Pi soweit konfiguriert ist, dass das Betriebssystem und die Internetanbindung sowie das Modul RPi.GPIO installiert sind. Sollte das noch nicht der Fall sein, dann muss es jetzt nachgeholt werden. Hier ist die Anleitung.

Übrigens können alle hier vorgestellten Übungen natürlich auch ohne Gertboard durchgeführt werden -> siehe hier. 

Wer bereits Erfahrungen mit Mikrocontrollern gesammelt hat und diese auf den Raspberry Pi übertragen möchte, der wird sich in vielen Bereichen umstellen müssen.

• Der Raspberry Pi (Raspi) arbeitet unter dem Betriebssystem LINUX. Wie es zu installieren ist, kann hier nachgelesen werden.
• Der Schwerpunkt der Arbeit wird sich mehr auf die sogenannte Konsolenarbeit konzentrieren.
• Der Raspi ist im Vergleich zu seinen Mitstreitern, den AVR-, PIC- oder Propeller Controllern, deutlich langsamer und anfälliger, da kaum elektronische Schutzfunktionen gegen Fehlbehandlungen eingebaut sind. Deshalb verwenden wir zusätzlich das Gertboard.
• Die Steuerungssoftware für die elektronischen Bauteile und Sensoren ist Python, eine leicht zu erlernende Sprache. Wer bereits Programmierkenntnisse in C, BASIC oder SPIN mitbringt, für den ist die Umstellung leicht. Wir werden in jeder Übung umfassende Erklärungen des Programmcodes geben, so dass diese Übungen auch als Lerneinstieg in die Sprache Python genommen werden können.

Schaltungsaufbau (Verdrahtungsplan) auf dem Gertboard

Das Programm

Wie arbeitet das Programm test1.py?

Kommentarzeile

Eine einfache Kommentarzeile wird mit dem Zeichen

• #

eingeleitet und reicht bis zum Ende einer Zeile.

Mehrzeilige Kommentare werden mit

• """        eingeleitet und mit
• """        beendet.

-------------------------------------------------------------------------------------------

Module importieren

Mit Hilfe von Bibliotheksfunktionen oder Modulen lassen sich viele zusätzliche Funktionen implementieren. Sie gehören nicht zum Sprachkern von Python; eine solche Bibliotheksfunktion ist RPi.GPIO. Es gibt verschiedene Varianten des Programmaufrufs. Die Syntax lautet

-------------------------------------------------------------------------------------------

import <modulname> as <name>

Wirkung: Alle Funktionen des Moduls werden mit name.Funktionsname() aufgerufen. Im vorliegenden Programm wird die Funktion setmode mit GPIO.setmode(Parameter) aufgerufen.

-------------------------------------------------------------------------------------------

from <modulname> import <Funktion1, ..., Funktion k>

Wirkung: Diese Variante ist in der Handhabung einfacher, da die Namen der importierten Funktionen 1, ..., k direkt in den nachfolgenden Programmzeilen verwendet werden dürfen. Im vorliegenden Programm lautet die Programmzeile

• from time import sleep

dabei wird die Funktion sleep später ohne Voranstellung des Modulnamens verwendet -> sleep(0.5).

Wird anstelle einzelner Funktionen hinter dem Schlüsselwort import nur ein * gesetzt, werden alle Funktionen außer denen, die mit einem doppeltem Unterstrich __ beginnen, importiert.

--------------------------------------------------------------------------------------------

import <modulname>

Wirkung: Das Modul wird eingelesen; alle darin definierten Funktionen werden dann über

modulname.Funktionsname()

aufgerufen. In Programm test1.py lautet die entsprechende Programmzeile import sys; auf die Funktionen aus diesem Modul wird aber im weiteren Programmablauf nicht zugegriffen.

--------------------------------------------------------------------------------------------

Die Funktion GPIO.setmode aus der Bibliothek RPi.GPIO legt fest, dass alle folgenden GPIO-Angaben nach der BCM-Bezeichnung erfolgen und mit GPIO.setup(7, GPIO.OUT) wird GPIO 7 als Ausgang festgelegt.

--------------------------------------------------------------------------------------------

Eine eigene Funktion erstellen

Möchte man eine eigene Funktion erstellen, dann beginnen sie in einem Python Programm immer mit dem Schlüsselwort

•    def <Funktionsname(Parameter 1, Parameter2, ...)>:
•     Befehlsblock mit eingerückten Zeilen

gefolgt von einem Funktionsnamen und einer oder mehrerer Variablen (optional), die dann in Klammern gesetzt werden. Abgeschlossen werden muss die Zeile mit einem Doppelpunkt.

Alle eingerückten Programmzeilen unmittelbar unterhalb des def-Aufrufs gehören zum Befehlsblock.

Im Programm test1.py wird eine Funktion mit Namen led_blink mit einer Übergabevariablen wdh erstellt.

--------------------------------------------------------------------------------------------

Schleifenaufruf

Der Befehlsblock der FOR-Schleife umfasst vier Kommandos (sie müssen eingerückt sein), die nacheinander so oft ausgeführt werden, wie im Argument der Funktion range durch die Variable wdh vorgegeben.

• GPIO.output(7,1)

setzt den I/O Pin 7 (BCM-Notierung) auf 1 oder HIGH, mit der Folge, dass die dort angeschlossene LED an geht. Anschließend tritt eine Pause von 0,5s ein.

• GPIO.output(7, 0)

setzt den I/O Pin 7 auf 0 oder LOW und die dort angeschlossene LED erlischt für 0,5s.

Syntax der FOR-Schleife

• for <variable1> in range(variable2):

Wird als variable2 eine Zahl angegeben, wie zum Beispiel 10, dann durchläuft variable1 alle Zahlen von 0 bis 9.

---------------------------------------------------------------------------------------------

Programmabbruch verhindern - Fehler abfangen

Die Klausel try - except ist eine Ausnahmebehandlung unter Python, mit der Fehler in einem Programm behoben werden können. Dabei erscheinen im try-Block alle Programmbefehle und im except Block die Reaktionen darauf, wenn ein Fehler eintritt. Unter Python klingt das dann so:

------------------------------------------------------------------------------------------------------------------------

Versuche erst einmal den normalen Programmteil auszuführen, wenn es nicht gelingt und ein Fehler auftritt, dann führe das aus, was im except-Block (Ausnahmebereich) steht.

------------------------------------------------------------------------------------------------------------------------

Die Syntax dieser Anweisung lautet:

• try:
•    Programmblock
• except <spezifischer Fehler>:
•    Programmblock

Beim vorliegenden Programm wird die Funktion led_blink(10) auf Fehler untersucht und in dem Moment, in dem das Programm von außen abgebrochen wird oder ein Fehler auftritt, beendet. Genauer gesagt werden alle Kanäle, die zu Beginn des Programms als Ein- oder Ausgang definiert wurden, zurückgesetzt.

Das Zurücksetzen aller Kanäle erfolgt auch, wenn das Programm ganz normal beendet wird.

Verdrahtungsplan auf dem Gertboard

Das Programm led2.py

Wie arbeitet das Programm led2.py?

Gegenüber dem ersten Programm ist die erste neue Programmzeile

• GPIO.setup(8, GPIO.OUT)

mit der I/O Port 8 zum Ausgang erklärt wird, wie eine Zeile vorher Port 7. In der Funktion led_blink sind zwei Programmzeilen hinzugekommen.

• GPIO.output(8, 1) und
• GPOI.output(8, 0)

Wie im  Programm vorher bewirken beide Befehle, dass die LED an P8 eingeschaltet und nachher wieder ausgeschaltet wird.

Eine Änderung muss hier noch erwähnt werden. Ganz zum Schluss fehlt die Programmzeile GPIO.cleanup() (vgl. Abb. 3). Wird das Programm normal beendet, dann werden die Kanäle nicht zurückgesetzt, so dass bei einem folgenden Programmaufruf eine Warnung im Python-Editor erscheint.

Verdrahtungsplan auf dem Gertboard

Das Programm led12reihe.py<< Neues Textfeld >>

Wie arbeitet das Programm led12reihe.py?

Neu ist in diesem Programm die Aufzählungsliste ioports

In ihr sind die Ports des Raspi benannt, über die die 12 LEDs angesteuert werden. Etwas verwirrend ist, dass die Portbezeichnung auf dem Gertboard an einigen Stellen nicht mehr mit dem tatsächlichen Port am Raspi übereinstimmt -> Das Gertboard für den Raspi - Abschnitt 4. Das ist zum Beispiel beim Port GP21 der Fall; tatsächlich ist dieser Port auf GP27 vom Hersteller des Raspi umgelenkt worden - und die Beschriftung auf dem Board ist dem nicht hinterhergeeilt. Deshalb muss man an dieser Stelle aufpassen. Wer die Beschriftung auf dem Gertboard übernimmt, also statt 27 in die Liste 21 aufnimmt, wird feststellen, dass eine LED (die an P27) nicht leuchtet.

In der folgenden FOR-Schleife werden diese Ports mit zwei Befehlszeilen als Ausgang gesetzt.

Die nachfolgende Funktion led_blink, die wir bereits aus den beiden anderen Übungen kennen, wird noch einmal erweitert. Es gibt zwei FOR-Schleifen.

Die erste - übergeordnete - Schleife zählt von 0 bis 9 und ist für die Anzahl der Wiederholungen zuständig, die zweite Schleife (sie steuert die LEDs an) ruft nacheinander alle Elemente der Aufzählungsliste ioports auf und weist sie der Variablen led zu, die dann auf 1 bzw. 0 gesetzt werden.

Damit alle veränderten Kanäle am Ende des Programms wieder zurückgesetzt werden, wurde die letzte Programmzeile aus dem ersten Programm wieder eingefügt: GPIO.cleanup().