Adventskalender Raspberry Pi 2017

Transkript

1 Adventskalender Raspberry Pi 2017 Mit einem normalen PC oder gar einem Notebook einfache Elektronik zu steuern ist auch wenn es nur ein paar LEDs sind für den Hobbyprogrammierer mit kaum vertretbarem Aufwand verbunden. Dem PC fehlen einfach die dafür notwendigen Schnittstellen. Außerdem ist das Windows-Betriebssystem denkbar ungeeignet dafür, mit Elektronik zu kommunizieren. Der Raspberry Pi ist obwohl es auf den ersten Blick gar nicht so aussieht ein vollwertiger Computer. Vieles geht etwas langsamer, als man es von modernen PCs gewohnt ist, dafür ist der Raspberry Pi aber auch viel kleiner und vor allem billiger als ein PC. Dieser Adventskalender enthält für jeden Tag ein Hardwareexperiment mit dem Raspberry Pi. Die Experimente werden mit Scratch oder Python programmiert. Beide Programmiersprachen sind auf dem Rasp berry Pi vorinstalliert. Alle Experimente funktionieren mit dem Raspberry Pi 3. Die wichtigsten Bauteile kurz erklärt Steckbrett Für den schnellen Aufbau elektronischer Schaltungen, ohne dass man löten muss, enthält der Adventskalender ein Steckbrett. Hier können elektronische Bauteile direkt in ein Lochraster gesteckt werden. Bei diesem Steckbrett sind alle äußeren Längsreihen über Kontakte (X und Y) miteinander verbunden. Diese Kontaktreihen werden oft als Plusund Minuspol zur Stromversorgung der Schaltungen genutzt. In den anderen Kontaktreihen sind jeweils fünf Kontakte (A bis E und F bis J) quer miteinander verbunden, wobei in der Mitte der Platine eine Lücke ist. So können hier größere Bauelemente eingesteckt und nach außen hin verdrahtet werden. Die Verbindungen auf dem Steckbrett. LEDs LEDs (zu Deutsch: Leuchtdioden) leuchten, wenn Strom in Durchflussrichtung durch sie fließt. LEDs werden in Schaltungen mit einem pfeilförmigen Dreieckssymbol dargestellt, das die Flussrichtung vom Pluspol zum Minuspol oder zur Masseleitung angibt. Eine LED lässt in der Durchflussrichtung nahezu beliebig viel Strom durch, sie hat nur einen sehr geringen Widerstand. Um den Durchflussstrom zu begrenzen und damit ein Durchbrennen der LED zu verhindern, wird üblicherweise zwischen dem verwendeten GPIO-Pin und der Anode der LED oder zwischen Kathode und Massepin ein 220-Ohm-Vorwiderstand eingebaut. Dieser Vorwiderstand schützt auch den GPIO-Ausgang des Raspberry Pi vor zu hohen Stromstärken. Die LEDs im Adventskalender haben den Vorwiderstand bereits eingebaut und können daher direkt an die GPIO-Pins angeschlossen werden. LED in welcher Richtung anschließen? Die beiden Anschlussdrähte einer LED sind unterschiedlich lang. Der längere ist der Pluspol, die Anode, der kürzere die Kathode. Einfach zu merken: Das Pluszeichen hat einen Strich mehr als das Minuszeichen und macht damit den Draht quasi etwas länger. Außerdem sind die meisten LEDs auf der Minusseite abgeflacht, vergleichbar mit einem Minuszeichen. Auch leicht zu merken: Kathode = kurz = Kante. Schaltplan einer LED mit Vorwiderstand. RGB-LEDs Eine normale LED leuchtet immer nur in einer Farbe. Die im Adventskalender verwendeten RGB-LEDs können wahlweise in mehreren Farben leuchten. Bei ihnen sind im Prinzip drei verschiedenfarbige LEDs in einem transparenten Gehäuse eingebaut. Jede dieser drei LEDs hat eine eigene Anode, über die sie mit einem GPIO-Pin verbunden wird. Die Kathode, die mit der Masseleitung verbunden wird, ist nur einmal vorhanden. Deshalb hat eine RGB-LED vier Anschlussdrähte. Anschlusspins einer RGB-LED. Die Anschlussdrähte von RGB-LEDs sind unterschiedlich lang, damit sie eindeutig zu erkennen sind. Anders als bei normalen LEDs ist die Kathode hier der längste Draht. RGB-LEDs funktionieren wie drei einzelne LEDs und brauchen deshalb auch drei Vorwiderstände. Diese sind in den im Adventskalender enthaltenen RGB-LEDs ebenfalls eingebaut. Widerstand Widerstände werden zur Strombegrenzung an empfindlichen elektronischen Bauteilen sowie als Vorwiderstände für LEDs verwendet. Die Maßeinheit für Widerstände ist Ohm Ohm entsprechen einem Kiloohm, abgekürzt kohm kohm entsprechen einem Megaohm, abgekürzt MOhm. Oft wird für die Einheit Ohm auch das Omega-Zeichen Ω verwendet.

2 Interner Schaltplan für eine RGB-LED mit drei Vorwiderständen. Die farbigen Ringe auf den Widerständen geben den Widerstandswert an. Mit etwas Übung sind sie deutlich leichter zu erkennen als winzig kleine Zahlen, die man nur noch auf ganz alten Widerständen findet. Die meisten Widerstände haben vier solcher Farbringe. Die ersten beiden Farbringe bezeichnen die Ziffern, der dritte einen Multiplikator und der vierte die Toleranz. Dieser Toleranzring ist meistens gold- oder silberfarben Farben, die auf den ersten Ringen nicht vorkommen. Dadurch ist die Leserichtung immer eindeutig. Der Toleranzwert selbst spielt in der Digitalelektronik kaum eine Rolle. Die Tabelle zeigt die Bedeutung der farbigen Ringe auf Widerständen. In welcher Richtung ein Widerstand eingebaut wird, ist egal. Bei LEDs dagegen spielt die Einbaurichtung eine große Rolle. Servo Ein Servo ist ein kleiner Motor mit einem Arm, an dem Gegenstände befestigt werden können. Mit einem Steuerungssignal kann dieser um einen bestimmten Winkel gedreht werden. Servos haben drei Anschlussleitungen, zwei dienen der Stromversorgung, auf der dritten empfängt das Servo die Steuerungssignale. GPIO-Verbindungskabel Die farbigen Verbindungskabel haben alle auf beiden Seiten eine Steckbuchse, die auf einen GPIO-Pin des Raspberry Pi passt. LEDs und andere Bauteile können direkt in diese Steckbuchsen gesteckt werden. Zusätzlich sind Pinleisten enthalten, die in das Steckbrett gesteckt werden, um die Verbindungskabel mit Kontaktreihen zu verbinden. Jede Pinleiste verfügt über drei Pins, die voneinander unabhängig, also nicht elektrisch verbunden sind. Belegung der GPIO-Pins. Farbe Widerstandswert in Ohm 1. Ring (Zehner) 2. Ring (Einer) 3. Ring (Multiplikator) 4. Ring (Toleranz) Silber 10 2 = 0,01 ±10 % Gold 10 1 = 0,1 ±5 % Schwarz = 1 Braun = 10 ±1 % Rot = 100 ±2 % Orange = Gelb = Grün = ±0,5 % Blau = ±0,25 % Violett = ±0,1 % Grau = ±0,05 % Weiß = Vorsichtsmaßnahmen Auf keinen Fall sollte man irgendwelche GPIO-Pins miteinander verbinden und abwarten ab, was

3 passiert. Nicht alle GPIO-Pins lassen sich frei programmieren. Ein paar sind für die Stromversorgung und andere Zwecke fest eingerichtet. Einige GPIO-Pins sind direkt mit Anschlüssen des Prozessors verbunden, ein Kurzschluss kann den Rasp berry Pi komplett zerstören. Verbindet man über einen Schalter oder eine LED zwei Pins miteinander, muss immer ein Schutzwiderstand dazwischengeschaltet werden. Eine Ausnahme bilden die LEDs mit eingebautem Vorwiderstand. Für Logiksignale muss immer Pin 1 verwendet werden, der +3,3 V liefert und bis 50 ma belastet werden kann. Pin 6 ist die Masseleitung für Logiksignale. Pin 2 und 4 liefern +5 V zur Stromversorgung externer Hardware. Hier kann so viel Strom entnommen werden, wie das USB-Netzteil des Raspberry Pi liefert. Diese Pins dürfen aber nicht mit einem GPI- O-Eingang verbunden werden. 1. Tag 1 LED rot mit eingbautem Vorwiderstand 1 GPIO-Verbindungskabel Raspberry Pi vorbereiten Um den Raspberry Pi in Betrieb zu nehmen, braucht man: USB-Tastatur und Maus HDMI-Kabel für Monitor Netzwerkkabel MicroSD-Karte mit Betriebssystem Raspbian Jessie Micro-USB-Handyladegerät als Netzteil (mindestens 2 A) Das Netzteil muss als Letztes angeschlossen werden, damit schaltet sich der Raspberry Pi automatisch ein. Es gibt keinen eigenen Ein-/Ausschalter. Betriebssysteminstallation in Kürze Für alle, die ihren Raspberry Pi noch nicht mit der aktuellen Raspbian-Version betriebsbereit haben, folgt hier die Systeminstallation in zehn Schritten: 1. NOOBS (mindestens Version 2.0.0) von auf den PC herunterladen und Zip-Archiv auf die Festplatte entpacken. 2. Wurde die SD-Karte bereits benutzt, mit SD-Formatter im PC neu formatieren: Dabei Format Size Adjustment einschalten (die SD-Karte muss mindestens 4 GB groß sein). 3. Die Dateien und Unterverzeichnisse von NOOBS auf die SD-Karte kopieren. 4. SD-Karte aus dem PC nehmen, in den Raspberry Pi stecken und booten. Ganz unten Deutsch als Installationssprache wählen. Dann wird automatisch auch die deutsche Tastatur ausgewählt. 5. Das Häkchen beim vorausgewählten Raspbian-Betriebssystem setzen und oben links auf Install klicken. Nach Bestätigung einer Sicherheitsabfrage, dass die Speicherkarte überschrieben wird, startet die Installation, die einige Minuten dauert. 6. Nach abgeschlossener Installation bootet der Raspberry Pi neu. 7. Im Menü unter Einstellungen das Tool Raspberry Pi Configuration starten. 8. Auf der Registerkarte Lokalisierung im Feld Zeitzone festlegen die Optionen Europe und Berlin auswählen. Sprachumgebung und Tastatur sollten automatisch auf Deutsch gesetzt sein. 9. Auf der Registerkarte Schnittstellen den Schalter SSH auf Aktiviert setzen, wenn Sie über das Netzwerk Daten vom PC auf den Raspberry Pi übertragen wollen. 10. Auf OK klicken und den Raspberry Pi über den Menüpunkt Shutdown neu booten. Eine eventuell auftauchende Warnung wegen eines unsicheren Passworts kann ignoriert werden. LED leuchtet Das Experiment zeigt, wie LEDs angeschlossen werden. Achten Sie darauf, dass die LED richtig herum eingebaut ist. Die Kathode (kurzer Draht) ist mit dem GND-Pin des Raspberry Pi verbunden, die Anode (langer Draht) mit dem GPIO-Pin 4. Stecken Sie die LED einfach direkt in die GPI- O-Verbindungskabel. Alle Schaltungsaufbauzeichnungen sind in den Downloads zum Adventskalender in Farbe enthalten, damit Sie die Leitungen besser erkennen können.

4 Bauteile: 1 LED rot mit eingbautem Vorwiderstand, 2 GPIO-Verbindungskabel Die erste LED leuchtet am Raspberry Pi. Gesteuert wird das Ganze über ein Programm in Scratch. Programme zum Download Die im Adventskalender verwendeten Programme und Aufbauzeichnungen gibt es hier zum Download: Tragen Sie für dieses Produkt den Code in das Eingabefeld ein. Öffnen Sie die Webseite direkt mit dem auf dem Raspberry Pi vorinstallierten Browser und laden Sie die Zip-Datei in das Home-Verzeichnis /home/pi herunter. Starten Sie den Dateimanager auf dem Raspberry Pi. Er zeigt beim Start automatisch das Home-Verzeichnis an. Klicken Sie mit der rechten Maustaste auf die heruntergeladene Zip-Datei und wählen Sie im Kontextmenü Hier entpacken. Das Archiv enthält insgesamt 25 Verzeichnisse, jeder Tag ist in einem eigenen Verzeichnis abgelegt. Zusätzlich gibt es ein allgemeines Verzeichnis. Scratch ist auf dem Raspberry Pi im Menü unter Entwicklung vorinstalliert und gilt als eine der am leichtesten zu erlernenden Programmiersprachen. Seit Raspbian Jessie unterstützt Scratch die GPIO-Schnittstelle des Raspberry Pi. Die GPIO-Unterstützung muss vor der ersten Verwendung über den Menüpunkt Bearbeiten/Start GPIO server eingeschaltet werden. GPIO-Server in Scratch starten. In Scratch braucht man beim Programmieren keinen Programmcode zu tippen. Die Blöcke werden einfach nur per Drag-and-drop aneinandergehängt. Die Blockpalette im linken Teil des Scratch-Fensters enthält, nach Themen geordnet, die verfügbaren Blöcke. Sie können das Programm auf dem Bildschirm selbst zusammenbauen oder das Programm 01led01 aus dem Download zum Adventskalender verwenden. Wählen Sie dazu Öffnen im Menü Datei und klicken Sie im nächsten Dialogfeld auf die Schaltfläche pi, um das persönliche Home-Verzeichnis auszuwählen, in dem die heruntergeladenen Programme liegen. Dieses Scratch-Programm 01led01 lässt die LED eine halbe Sekunde leuchten. Klicken Sie in Scratch oben links auf das gelbe Symbol Steuerung. Daraufhin werden in der Blockpalette links die Blöcke zur Steuerung angezeigt. Für dieses erste Programm brauchen wir nur diese gelben Blöcke. Ziehen Sie die Blöcke, die Sie brauchen, einfach aus der Blockpalette in das Skriptfenster in der Mitte von Scratch. Der Block Wenn (grüne Fahne) angeklickt dient dazu, ein Programm zu starten. Die folgenden Skriptelemente werden ausgeführt, wenn man auf das grüne Fähnchen rechts oben in Scratch klickt. Der Block ist oben rund, passt also unter keinen anderen Block. Er muss immer als Erstes gesetzt werden. Die GPIO-Befehle werden über den Scratch-Block sende... an alle ausgegeben. In das Textfeld werden die jeweilige Pinbezeichnung und entsprechende Schlüsselwörter eingetragen. Klicken Sie dazu in das Textfeld im Block, wählen Sie Neu/edit... und geben Sie den Text ein. Am Anfang wird der GPIO-Pin 4 mit config4out als Ausgang definiert. Jeder GPIO-Pin kann entweder Ausgang oder Eingang sein. Im nächsten Schritt wird über einen weiteren Scratch-Block sende... an alle mit dem Text gpio4on die an GPIO-Pin 4 angeschlossene LED eingeschaltet. Danach wartet das Programm eine halbe Sekunde. Dazu bietet Scratch einen eigenen Block warte...sek. an. Scratch verwendet wie viele amerikanische Programme den Punkt als Dezimaltrennzeichen, nicht das in Deutschland übliche Komma. Eine halbe Sekunde wird also als 0.5 eingetragen und nicht als 0,5. Zuletzt wird über einen weiteren Scratch-Block sende... an alle mit dem Text gpio4off die an GPIO-Pin 4 angeschlossene LED wieder ausgeschaltet startet, wenn man oben rechts im Scratch-Fenster auf das grüne Fähnchen klickt.

5 2. Tag 1 Steckbrett (SYB 46) 1 LED grün mit eingebautem Vorwiderstand 1 GPIO-Verbindungskabel 2 Pinleisten (3 Pins) Zwei LEDs blinken abwechselnd rot und grün Das Experiment des 2. Tags lässt beide LEDs abwechselnd rot und grün leuchten. Gesteuert wird das Ganze über eine Endlosschleife in Scratch. Bauteile: 1 Steckbrett, 1 LED rot mit eingbautem Vorwiderstand, 1 LED grün mit eingbautem Vorwiderstand, 3 GPIO-Verbindungskabel, 2 Pinleisten (3 Pins) Zwei LEDs blinken am Raspberry Pi. Diesmal nutzen wir, wie bei den meisten Experimenten in diesem Adventskalender, ein Steckbrett zum Aufbau der Schaltung. Verwenden Sie die mitgelieferten Pinleisten, um die GPIO-Verbindungskabel am Steckbrett anzuschließen. Am Anfang werden die beiden GPIO-Pins 4 und 10 mit config4out und config10out als Ausgänge definiert. Eine wiederhole fortlaufend-schleife sorgt dafür, dass die beiden LEDs endlos blinken, und zwar so lange, bis der Benutzer auf das rote Stopp symbol oben rechts in Scratch klickt. Wenn die rote LED an Pin 4 eingeschaltet und die grüne an Pin 10 ausgeschaltet ist, wartet das Programm eine halbe Sekunde. Danach werden auf die gleiche Weise die grüne LED an Pin 10 eingeschaltet und die rote an Pin 4 ausgeschaltet. Nach einer weiteren halben Sekunde wiederholt sich der Zyklus. 02led02 steuert die beiden LEDs. 3. Tag 2 GPIO-Verbindungskabel Zwei LEDs blinken mit Python abwechselnd rot und grün Das Experiment des 3. Tags lässt wieder zwei LED abwechselnd rot und grün leuchten. Allerdings verwenden wir diesmal Python statt Scratch. Bauteile: 1 Steckbrett, 1 LED rot mit eingebautem Vorwiderstand, 1 LED grün mit eingebautem Vorwiderstand, 3 GPIO-Verbindungskabel, 2 Pinleisten (3 Pins) Zwei LEDs blinken am Raspberry Pi. Python ist auf dem Raspberry Pi ebenfalls vorinstalliert, sogar in zwei verschiedenen Versionen. Python 3 ist nicht einfach, wie der Name vermuten lässt, eine neuere Version von Python 2. Die Sprachen verwenden teilweise eine andere Syntax. Programme sind also nicht eins zu eins kompatibel. Viele externe Bibliotheken sind nur für eine der beiden Versionen erhältlich. Entwickler von Python-Programmen müssen ihren Nutzern also immer mitteilen, mit welcher Version ein Programm funktioniert. Wir verwenden in diesem Adventskalender immer das moderne Python 3. Starten Sie im Menü unter Entwicklung das Programm Python 3. IDLE ist eine komplette Python-Shell und -Entwicklungsumgebung. Für den Start in die Programmierung sind keine zusätzlichen Komponenten nötig. Öffnen Sie über File/Open das Programm 03led02.py aus dem Download oder öffnen Sie in der Python-Shell über File/New ein neues Fenster und

6 tippen Sie das Programm ein. ist eine fast genaue Umsetzung des Scratch-Programms vom 2. Tag, jedoch mit einem wichtigen Unterschied: Die LEDs blinken nicht ewig, sondern genau zehnmal. #!/usr/bin/python import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) GPIO.setup(4, GPIO.OUT) GPIO.setup(10, GPIO.OUT) for i in range(10): GPIO.output(4, True) GPIO.output(10, False) time.sleep(0.5) GPIO.output(10, True) GPIO.output(4, False) time.sleep(0.5) So funktioniert das Programm #!/usr/bin/python Python-Programme, die über die Kommandozeile gestartet werden, müssen am Anfang immer obige Zeile enthalten. Bei Programmen, die nur über die Python-Shell gestartet werden, ist das nicht nötig. Aus Gründen der Kompatibilität sollten Sie sich aber angewöhnen, diese Zeile am Anfang jedes Python-Programms einzutragen. import RPi.GPIO as GPIO import time Ein großer Vorteil von Python ist die einfache Erweiterbarkeit um neue Funktionen aus Funktionsbibliotheken. Für nahezu jede Aufgabe gibt es bereits fertige Bibliotheken, sodass Sie viele Standardaufgaben nicht mehr selbst zu lösen brauchen. Die Bibliothek RPI.GPIO wird für die Unterstützung der GPIO-Pins importiert, die Bibliothek time enthält Zeitfunktionen, zum Beispiel, um eine Wartezeit zwischen dem Blinken der beiden LEDs zu realisieren. GPIO.setmode(GPIO.BCM) Die Bibliothek RPi.GPIO unterstützt zwei Methoden zur Bezeichnung der Pins. Im Modus BCM werden die bekannten GPIO-Portnummern verwendet, die auch in Scratch genutzt werden. Im Modus BOARD entsprechen die Bezeichnungen den Pinnummern auf der Raspberry-Pi-Platine. Üblicherweise wird BCM verwendet. Deshalb und um die Python-Programme mit den Scratch-Programmen leichter vergleichen zu können, verwenden wir in diesem Adventskalender ebenfalls den Modus BCM. GPIO.setup(4, GPIO.OUT) GPIO.setup(10, GPIO.OUT) Die Funktion GPIO.setup initialisiert einen GPIO-Pin als Ausgang oder als Eingang. Der erste Parameter bezeichnet den Pin je nach vorgegebenem Modus, BCM oder BOARD, mit seiner GPIO oder Pinnummer. Der zweite Parameter kann entweder GPIO.OUT für einen Ausgang oder GPIO.IN für einen Eingang sein. for i in range(10): Schleifen mit for arbeiten eine bestimmte Anzahl von Durchläufen ab. Dabei kann im Parameter range() außer einer einfachen Zahl auch ein Wertebereich oder eine Berechnungsfunktion angegeben werden. Einrückungen sind in Python wichtig In den meisten Programmiersprachen werden Programmschleifen oder Entscheidungen eingerückt, um den Programmcode übersichtlicher zu machen. In Python dienen diese Einrückungen nicht nur der Übersichtlichkeit, sondern sind für die Programmlogik sogar zwingend nötig. Dafür braucht man in dieser Sprache keine speziellen Satzzeichen, um Schleifen oder Entscheidungen zu beenden. GPIO.output(4, True) GPIO.output(10, False) Die eingerückten Zeilen werden in jedem Schleifendurchlauf einmal ausgeführt. Die Funktion GPIO.output setzt den Status eines GPIO-Pins. Jeder

7 Pin kann auf zwei verschiedene Zustände gesetzt werden. True schaltet den Pin ein, False schaltet ihn wieder aus. Die obigen Zeilen schalten die LED an GPIO-Pin 4 ein und die LED an GPIO-Pin 10 aus. time.sleep(0.5) wartet eine halbe Sekunde. GPIO.output(10, True) GPIO.output(4, False) time.sleep(0.5) Anschließend wird die LED an GPIO-Pin 10 ein- und die LED an GPIO-Pin 4 ausgeschaltet. Danach wartet das Programm wieder eine halbe Sekunde. Die letzte Zeile ist nicht mehr eingerückt, sie wird erst ausgeführt, nachdem die Schleife zehnmal durchgelaufen ist. Am Ende eines Programms müssen alle verwendeten GPIO-Pins wieder zurückgesetzt werden, um Warnungen beim nächsten Programmstart zu vermeiden. Die obige Zeile erledigt das für alle vom Programm initialisierten GPIO-Pins auf einmal. Pins, die von anderen Programmen initialisiert wurden, bleiben davon unberührt. So wird der Ablauf dieser anderen, möglicherweise parallel laufenden Programme nicht gestört. 4. Tag 1 Taster 1 Pinleiste (3 Pins) LEDs mit Taster umschalten Das Experiment des 4. Tags schaltet die LEDs nicht automatisch um, sondern erst, wenn der Benutzer einen Taster betätigt. Bauteile: 1 Steckbrett, 1 LED rot mit eingbautem Vorwiderstand, 1 LED grün mit eingebautem Vorwiderstand, 1 Taster, 5 GPI- O-Verbindungskabel, 3 Pinleisten (3 Pins) LEDs mit Taster umschalten. funktioniert ähnlich wie das des 2. Tags. Auch hier werden in einer Endlosschleife abwechselnd die beiden LEDs ein- und ausgeschaltet. Im Unterschied zum vorherigen Programm erfolgt die Umschaltung nicht nach einer bestimmten Zeit, sondern erst, wenn der Benutzer den Taster gedrückt hat. 04taster01 steuert die beiden LEDs über einen Taster. Am Anfang wird zusätzlich zu den beiden Ausgängen GPIO-Pin 7 als Eingang definiert. Eingänge am Rasp berry Pi verarbeiten digitale Logiksignale. Ist ein Eingang mit +3,3 V verbunden, bekommt er das Signal logisch High, was Scratch als 1 auswertet, ist der Eingang mit GND verbunden, bekommt er das Signal logisch Low, was Scratch als 0 auswertet. Achtung Verwenden Sie nie die +5-V-Pins des Raspberry Pi für Logiksignale in Schaltungen. 5 V würden die GPIO-Eingänge überlasten und den Raspberry Pi beschädigen. Ein Druck auf den Taster verbindet in unserer Schaltung den GPIO-Pin 7 mit +3,3 V. Lässt man den Taster wieder los, bekommt der Eingang einen undefinierten Zustand, was in der Digitalelektronik nicht passieren darf. Für solche Fälle verfügen alle GPIO-Pins über sogenannte Pull-down-Widerstände, die einen Eingang, an dem kein Signal anliegt, automatisch auf Low herunterziehen. Definieren Sie den GPIO-Pin für den Taster mit config7inpulldown, um den eingebauten Pull-down-Widerstand am Eingang zu aktivieren. Wenn eine LED leuchtet, wartet das Programm nicht mehr eine bestimmte Zeit lang, sondern mit einem warte bis...-block, bis ein bestimmtes Ereignis eintritt, in diesem Fall bis der GPIO-Pin 7 den Wert 1 annimmt, der Taster also gedrückt wurde.

8 Für die Abfrage selbst ist im warte bis...-block ein längliches Feld mit spitzen Enden vorgesehen. Hier muss ein Block aus der grünen Blockpalette Operatoren eingefügt werden. Ziehen Sie den Block mit dem Gleichheitszeichen auf das Platzhalterfeld im warte bis...-block. Dieser Operator ist immer dann wahr, wenn die beiden Werte links und rechts des Gleichheitszeichens gleich sind. In unserem Fall soll der Wert des GPIO-Pins 7 dem Wert 1 entsprechen. Die Ziffer 1 steht für High. Schreiben Sie also eine 1 in das rechte der beiden Textfelder in dem grünen Block. Klicken Sie jetzt einmal auf das grüne Fähnchen oben rechts, um das noch unfertige Programm zu starten. Damit werden die GPIO-Pins definiert. Klicken Sie anschließend wieder auf das rote Stoppschild. Zur Abfrage von GPIO-Eingängen wird der Block Wert von Sensor... aus der blauen Blockpalette Fühlen verwendet. Wählen Sie im Listenfeld des blauen Blocks den Sensor GPIO-7 aus. Neben einigen vordefinierten Sensoren werden alle GPIO-Pins zur Auswahl angeboten, die als Eingang definiert sind. Deshalb musste das Programm einmal kurz gestartet werden. Ziehen Sie dann den blauen Block Wert von Sensor... in das linke Feld des grünen Blocks innerhalb des warte bis...-blocks. Danach wartet das Programm mit einem warte...sek.-block 0,2 Sekunden. Damit wird verhindert, dass der Taster sofort wieder als gedrückt gilt, wenn das Programm weiterläuft. Der Benutzer hat so lange Zeit, den Taster wieder loszulassen. Erst anschließend werden die LEDs umgeschaltet, und das Programm wartet erneut darauf, dass der Benutzer den Taster drückt. Blöcke duplizieren Beim Bau eines Scratch-Programms brauchen Sie ähnliche Blockkombinationen nicht jedes Mal neu anzulegen. Klicken Sie mit der rechten Maustaste auf den ersten Block, der dupliziert werden soll. Wählen Sie dann im Menü Duplizieren. Alle darunterhängenden Blöcke werden automatisch mit dupliziert. Die duplizierten Blöcke können dann an passender Stelle im Programm wieder eingefügt werden. 5. Tag 2 GPIO-Verbindungskabel LEDs auf der Weihnachtspyramide mit Python umschalten des 5. Tags verwendet Python, um zwei LEDs mit einem Taster umzuschalten. Die LEDs können diesmal auf die Weihnachtspyramide gesteckt werden und sind mit GPIO-Verbindungskabeln direkt am Raspberry Pi angeschlossen. Bauteile: 1 Steckbrett, 1 LED rot mit eingebautem Vorwiderstand, 1 LED grün mit eingebautem Vorwiderstand, 1 Taster, 6 GPI- O-Verbindungskabel, 1 Pinleiste (3 Pins) Zwei LEDs auf der Pyramide und ein Taster auf dem Steckbrett. Die Weihnachtspyramide Auf der Rückseite des Adventskalenders befinden sich zwei Teile zum Ausschneiden, die zusammengesetzt eine Weihnachtspyramide ergeben. Die beiden Teile der Weihnachtspyramide. Falten Sie das ovale Teil entlang der aufgedruckten Linien und schneiden Sie auf beiden Teilen die kurzen Linienstücke ein. Die runden Löcher im dreieckigen Teil sind für die LEDs. Setzen Sie die Weihnachtspyramide dann wie auf der Abbildung gezeigt zusammen. So wird die Weihnachtspyramide zusammengesetzt. Im Unterschied zum Scratch-Programm von gestern leuchtet im Python-Programm 05pyramide01.py die rote LED an Pin 4 nur, solange der Taster gedrückt ist. Lässt man ihn wieder los, leuchtet stattdessen die grüne LED an Pin 10.

9 #!/usr/bin/python import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) GPIO.setup(4, GPIO.OUT) GPIO.setup(10, GPIO.OUT) GPIO.setup(7, GPIO.IN, GPIO.PUD_DOWN) try: while True: if GPIO.input(7)==True: GPIO.output(4, True) GPIO.output(10, False) else: GPIO.output(10, True) GPIO.output(4, False) except KeyboardInterrupt: So funktioniert das Programm GPIO.setup(7, GPIO.IN, GPIO.PUD_DOWN) Nach der bereits bekannten Initialisierung der GPIO-Pins für die LEDs wird Pin 7 als Eingang für den Taster initialisiert. Der Parameter GPI O.PUD_DOWN schaltet den internen Pull-down-Widerstand ein. try: while True: Diese Zeilen leiten eine Endlosschleife mit Abbruchmöglichkeit ein. Die while-schleife läuft endlos, da die Bedingung True immer wahr ist. Die davorgeschaltete try-anweisung lässt aber eine weiter unten bei except angegebene Abbruchbedingung zu. if GPIO.input(7)==True: GPIO.output(4, True) GPIO.output(10, False) else: GPIO.output(10, True) GPIO.output(4, False) Das Wort if (englisch für wenn) steht für eine Bedingung. Ist sie erfüllt, wird der folgende eingerückte Programmteil ausgeführt. == ist nicht gleich = Das doppelte Gleichheitszeichen == steht für eine Gleichheitsabfrage, wohingegen das einfache Gleichheitszeichen = für Variablenzuweisungen verwendet wird. Wenn der Taster an Pin 7 gedrückt ist, hat dieser Pin den Wert True. Die LED an Pin 4 wird eingeschaltet, die LED an Pin 10 aus. Hinter dem Programmteil, der ausgeführt wird, wenn die Bedingung erfüllt ist, kann ein weiterer Block mit dem Schlüsselwort else stehen. Der darauffolgende Programmteil wird ausgeführt, wenn die Bedingung nicht erfüllt ist. Ist der Taster an Pin 7 also nicht gedrückt, wird die LED an Pin 10 eingeschaltet, die LED an Pin 4 aus. except KeyboardInterrupt: Mit Drücken der Tastenkombination [Strg]+[C] auf der Tastatur wird die Abbruchbedingung ausgelöst. Damit wird die Schleife beendet, und anschließend werden die GPIO-Pins zurückgesetzt. 6. Tag 1 LED gelb mit eingebautem Vorwiderstand Scratch-Katze schaltet LEDs Die Katze auf der Scratch-Bühne, dem Teilfenster rechts oben, ist nicht nur die Symbolfigur von Scratch, sondern ein frei programmierbares

10 Objekt, das verschiedenste Aktionen ausführen kann. Im Experiment des 6. Tags wird die Katze über einen Hintergrund mit drei verschiedenfarbigen Streifen grün, gelb und rot laufen. Je nachdem, welche Hintergrundfarbe die Katze berührt, leuchten die entsprechenden LEDs. Bauteile: 1 Steckbrett, 1 LED rot mit eingebautem Vorwiderstand, 1 LED gelb mit eingebautem Vorwiderstand, 1 LED grün mit Vorwiderstand, 4 GPIO-Verbindungskabel, 2 Pinleisten (3 Pins) Die Scratch-Katze schaltet drei LEDs. verwendet die sogenannte Scratch-Bühne, ein grafisches Ausgabefenster rechts oben auf dem Scratch-Bildschirm. Das verwendete Hintergrundbild kann mit dem in Scratch mitgelieferten Malprogramm selbst gemalt werden. 06katze01 lässt die Scratch-Katze drei LEDs steuern. Das Malprogramm für den Hintergrund in Scratch. Um den Hintergrund zu verändern, klicken Sie auf der Objektpalette rechts unten auf dem Scratch-Bildschirm auf das weiße Symbol Bühne. Das Scratch-Programmfenster erscheint leer, da keine Programmblöcke direkt für die Bühne genutzt werden. Schalten Sie oben auf die Registerkarte Hintergründe und klicken Sie auf Bearbeiten. Damit startet das Malprogramm, das die wesentlichen Funktionen eines einfachen Grafikprogramms bietet. Mithilfe des Rechtecksymbols und der Farbpalette links unten malen Sie drei farbige Balken, grün, gelb und rot, auf den Hintergrund. Verlassen Sie anschließend das Malprogramm mit OK, klicken Sie auf der Objektpalette unten rechts auf die Katze, hier als Objekt1 bezeichnet, und schalten Sie wieder auf die Registerkarte Skripte, auf der Sie das Programm zusammenbauen. Nach dem Start werden als Erstes die drei GPIO-Pins für die LEDs als Ausgänge definiert: config4out, config22out, config11out. Danach wird die Katze in die Ausgangsposition am linken Rand der Bühne auf dem grünen Balken gesetzt. Dazu verwenden wir den Block gehe zu x:... y:... von der Blockpalette Bewegung. Damit wird die Katze an eine absolute Koordinatenposition gebracht. Die Scratch-Bühne erstreckt sich in horizontaler x-richtung auf die Länge zwischen den Koordinaten 240 und 240. Standardmäßig steht die Katze bei 0,0 genau in der Mitte. Da sie selbst etwa 100 Koordinateneinheiten breit ist, kommt sie an den im Block eingetragenen Koordinaten x:-150 y:0 an eine gute Ausgangsposition, um quer über die Bühne zu laufen. Danach startet eine Wiederhole fortlaufend-schleife, die eine endlose Bewegung der Katze erzeugt. Innerhalb dieser Schleife läuft eine weitere Schleife, die genau 30 Mal wiederholt wird. Da die Katze in jedem Schritt zehn Koordinateneinheiten in x-richtung gehen soll, erreicht sie nach 30 Wiederholungen bei x:150 y:0 die Wendeposition am rechten Rand der Bühne. Innerhalb der Schleife folgen drei falls...sonst-abfragen, von denen jede prüft, ob die Katze eine bestimmte Hintergrundfarbe berührt. Ist das der Fall, wird der Block innerhalb der oberen Klammer falls ausgeführt, wenn nicht, wird der andere Block innerhalb der unteren Klammer sonst ausgeführt. Zur Überprüfung verwenden wir den Block wird Farbe... berührt von der Blockpalette Fühlen. Klicken Sie auf das farbige Feld im Block, erscheint der Mauszeiger als Pipette, und Sie können die gewünschte Farbe auf der Scratch-Bühne durch Anklicken auswählen. Die erste falls...sonst-abfrage prüft, ob die Katze die grüne Farbe des mittleren Balkens berührt. Ist das der Fall, soll die grüne LED an Pin 11 eingeschaltet werden (gpio11on). Berührt die Katze den grünen Balken im Moment der Abfrage nicht, wird diese LED ausgeschaltet (gpio11off). Nach dem gleichen Schema schaltet die zweite falls...sonst-abfrage bei Berührung des gelben Balkens die gelbe LED an Pin 22 ein und aus. Die dritte falls...sonst-abfrage schaltet bei Berührung des roten Balkens die rote LED an Pin 4 ein und aus. Jetzt geht die Katze einen Schritt von zehn Koordinateneinheiten. Der Block gehe...-er Schritt von der Blockpalette Bewegung bewegt ein Objekt relativ von seiner aktuellen Position aus, im Gegensatz zum am Anfang verwendeten Block gehe zu x:... y:..., der das Objekt an eine absolute Koordinatenposition bringt. Damit man die Bewegung gut mitverfolgen kann, wartet das Programm nach jedem Bewegungsschritt 0,2 Sekunden, bevor die innere Schleife neu startet und die Katze den nächsten Schritt geht.

11 Hat die Katze nach 30 Schritten die rechte Seite der Bühne erreicht, soll sie sich um 180 Grad drehen. Dazu verwenden wir den Block drehe... Grad von der Blockpalette Bewegung. Damit die Katze nach der Drehung nicht auf dem Kopf steht, aktivieren Sie das Doppelpfeilsymbol bei der Katze oberhalb des Skriptbereichs. Danach startet die Endlosschleife, und die Katze läuft wieder zurück. Da nur relative Bewegungen verwendet werden, braucht man im Skript nicht zwischen dem Gang nach rechts und nach links zu unterscheiden. Dieses Symbol schaltet zwischen Drehung und Links-rechts-Ausrichtung um. 7. Tag 2 GPIO-Verbindungskabel LEDs mit einer Smartphone-App schalten Einige Schaltungen, die Sie mit diesem Adventskalender aufbauen, werden über eine mobile App bedient. Hierfür wird eine mobile Webseite programmiert und vom Smartphone aus aufgerufen. Die mobile Webseite funktioniert auf jedem Smartphone mit WLAN und einem installierten Browser, und auch über den Browser auf dem Raspberry Pi oder Ihrem PC können Sie die programmierte Seite nutzen. Wichtig ist, dass sich Smartphone und Raspberry Pi im gleichen Netzwerk befinden. Zusätzlich müssen Sie folgende Dinge durchführen: Schritt 1: Webserver installieren Schritt 2: PHP5 installieren Schritt 1: Webserver installieren Damit die Webseite auf dem Raspberry Pi ablaufen und von Ihrem Smartphone aus aufgerufen werden kann, müssen Sie einen Webserver installieren. Wir verwenden den Apache HTTP Server. Für die Installation öffnen Sie das LXTerminal über das Menü Zubehör. Geben Sie im geöffneten LXTerminal-Fenster folgenden Befehl ein: sudo apt get install apache2 Der Webserver wird nun heruntergeladen und installiert. Über das Smartphone (oder auch über den Browser auf dem Raspberry Pi) können Sie die Installation direkt testen. Hierfür benötigen Sie die IP-Adresse des Raspberry Pi. Sie finden sie, wenn Sie mit der Maus über das Netzwerksymbol oben rechts auf dem Desktop fahren. Öffnen Sie den Browser in Ihrem Smartphone und geben Sie Adresse Raspberry PI> ein, das Beispiel aus dem Screenshot zeigt die Adresse Durch Klick auf den Menüeintrag öffnet sich die Eingabeaufforderung. Der Raspberry-Pi-Desktop zeigt die IP-Adresse an. Die Testseite auf dem Smartphone. Damit ist die Webserverinstallation abgeschlossen. Die Adresse auf Ihrem Raspberry Pi wird wahrscheinlich anders lauten. Sie können den Webserver auch über den Browser auf Ihrem Raspberry Pi testen. Geben Sie dafür die Adresse ein, und schon sehen Sie die Testseite im Browser. Schritt 2: PHP5 installieren Der Befehl phpinfo() gibt Systeminformationen zur PHP-Installation in Form einer Webseite aus.

12 Nachdem der Webserver erfolgreich getestet ist, müssen Sie noch PHP5 installieren. Starten Sie dazu zuerst das LXTerminal und aktualisieren Sie das System mit folgendem Aufruf: sudo apt get update Installieren Sie PHP5 mit nachfolgendem Befehl: sudo apt get install php5 Anschließend sollten Sie die Installation testen. Hierfür bleiben Sie im LXTerminal. Wechseln Sie mit dem Befehl cd /var/www in das Verzeichnis und fügen Sie Schreibrechte für alle Benutzer für das HTML-Verzeichnis /var/www/html hinzu: chmod R a+w html Über cd html wechseln Sie in das HTML-Verzeichnis und erzeugen mit touch phpinfo.php eine leere Datei mit dem Namen phpinfo.php. Diese Datei öffnen Sie zum Editieren mit dem Befehl nano phpinfo.php. Tippen Sie folgenden Quellcode in die Datei: <?php phpinfo();?> Speichen Sie die Datei über das Tastaturkürzel [Strg]+[O]. Der Editor fragt Sie nach einem Dateinamen. Bestätigen Sie den Vorschlag mit der [Enter]-Taste. Beenden Sie den Editor über [Strg]+[X]. Öffnen Sie die Datei im Browser über auf Ihrem Smartphone oder über im Browser des Raspberry Pi. Umsetzung des Projekts Jetzt haben Sie alle Voraussetzung für die Umsetzung der ersten mobilen App geschaffen. Zunächst bauen wir die Schaltung auf. Hierfür benötigen wir die nachfolgend aufgeführten Bauteile. Bauteile: 1 Steckbrett, 1 LED rot mit eingebautem Vorwiderstand, 2 GPIO-Verbindungskabel, 2 Pinleisten (3 Pins) Über die App wird eine LED eingeschaltet, und diese schaltet sich nach der eingestellten Zeit wieder aus. Für die Ansteuerung der LED wird das Python-Programm 07led.py aus dem Verzeichnis tag07 genutzt. Die LED geht an und nach einer Sekunde wieder aus. Die Leuchtdauer können Sie im Aufruf von time.sleep(1) beeinflussen. Der Parameter ist die Dauer in Sekunden, in diesem Fall also eine Sekunde. #!/usr/bin/python import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) GPIO.setup(4, GPIO.OUT) GPIO.output(4, True) time.sleep(1) Die App Die mobile Webseite erstellen Sie anhand einer Vorlage. Diese finden Sie im Verzeichnis app_vorlage im Downloadarchiv. In dem Verzeichnis befinden sich die Datei index.php und das Verzeichnis css. Im Verzeichnis css sind die Formatvorlagen für die mobile App enthalten. Die Datei index.php ist die eigentliche Vorlage für die App. Diese Vorlage werden Sie an unterschiedlichen Tagen benötigen. Schritt 1: Vorlage in das Verzeichnis des Webservers kopieren Der Inhalt von /var/www/html/tag07 nach dem Kopieren der Vorlage. Öffnen Sie das LXTerminal und wechseln Sie in das Verzeichnis /var/www/html: cd /var/www/html Erzeugen Sie in diesem Verzeichnis ein neues Verzeichnis mit dem Namen tag07:

13 mkdir tag07 Wechseln Sie in das Verzeichnis und kopieren Sie den Inhalt des Verzeichnisses app_vorlage sowie die Datei 07led.py in das soeben erstellte Verzeichnis. Das Verzeichnis sollte jetzt wie das in nebenstehenden Abbildung aussehen. Nun können Sie die Vorlage im Browser auf dem Raspberry Pi über öffnen. Schritt 2: Vorlage anpassen Die kopierte Vorlage im Browser des Raspberry Pi. Öffnen Sie anschließend die Datei index.php aus dem Verzeichnis tag07, indem Sie nano index.php im LXTerminal eingeben. In der Datei sehen Sie unter anderem folgenden Block: <form action="index.php" method="post"> </form> Dieser Block stellt ein Formular dar, über das Sie Kommandos an den Webserver und somit an den Raspberry Pi senden können. Um die LED anzuschalten, benötigen Sie eine Schaltfläche. Ändern Sie deswegen den Block wie folgt: <form action="index.php" method="post"> <input name="licht_an" id="licht_an" type="submit" value="licht an" style="background color: #4180C5"> </form> Damit erzeugen Sie eine blaue Schaltfläche mit der Beschriftung Licht an. Falls Sie die Farbe ändern wollen, ändern Sie den Wert in background color. Um den Text zu ändern, passen Sie den Text bei value an. Speichern Sie die Datei mit [Strg]+[O] und beenden Sie den Editor über [Strg]+[X]. Öffnen Sie über erneut die Datei index.php im Browser. Die angepasste Vorlage im Browser des Raspberry Pi. Jetzt muss noch die Vorlage mit dem Python-Skript verbunden werden. Der Aufruf des Skripts erfolgt über PHP. Ändern Sie den Anfang der Datei index.php wie folgt: <head> <?php if ($_POST["licht_an"]) { echo shell_exec( sudo /var/www/html/tag07/07led.py ); }?> <title>conrad Raspberry Pi Adventskalender</title> Die Datei öffnen Sie wieder per nano index.php. Mit <?php wird der PHP-Teil eingeleitet und mit?> beendet. Beim Klick auf die Schaltfläche Licht an wird ein Post-Request abgeschickt, der von der Seite ausgewertet wird. Über $_POST können Sie auf die gesendeten Werte zugreifen. Bei der Definition der Schaltfläche haben wir die ID und den Namen der Schaltfläche auf licht_an gesetzt: <input name="licht_an" id="licht_an" type="submit" value="licht an" style="background color: #4180C5"> In der If-Abfrage wird über $_POST["licht_an"] geprüft, ob die Schaltfläche gedrückt wurde (der Wert wird nur dann mitgeliefert). In diesem Fall wird das Python-Skript über echo shell_exec aufgerufen. Damit ist die mobile Webseite schon fertig. Wenn Sie nun die Seite im Browser öffnen und auf die Schaltfläche drücken, passiert noch nichts. Sie müssen erst die richtigen Rechte setzen. Schritt 3: Rechte setzen Öffnen Sie erneut das LXTerminal und wechseln Sie über cd /var/www/html/tag07 in das Verzeichnis von Tag 7. Geben Sie der Datei das Ausführungsrecht: chmod a+x 07led.py Nun müssen Sie noch erlauben, dass der Webserver dieses Skript ausführen darf. Rufen Sie dafür folgenden Befehl auf: sudo visudo Fügen Sie dann diese Zeile ein: www data ALL=(ALL) NOPASSWD: /var/www/html/tag07/07led.py Speichern Sie die Datei über [Strg]+[O] und schließen Sie sie mit [Strg]+[X]. Schritt 4: App testen

14 Sie haben es geschafft und können die App auf Ihrem Smartphone testen. Starten Sie den Browser auf Ihrem Smartphone, rufen Sie die Seite über Raspberry Pi/tag07/index.php auf und drücken Sie auf die Schaltfläche Licht an. Nun sollte das Licht angehen. Sie können jetzt das Licht über das Smartphone anschalten. 8. Tag 1 Taster LEDs dimmen LEDs können zwei verschiedene Zustände annehmen, ein und aus. Das Gleiche gilt für die als digitale Ausgänge definierten GPIO-Ports. Demnach wäre es theoretisch nicht möglich, eine LED zu dimmen. Mit einem Trick erreicht man es dennoch, die Helligkeit einer LED an einem digitalen GPIO-Port zu regeln. Lässt man eine LED schnell genug blinken, nimmt das menschliche Auge das nicht mehr als Blinken wahr. Die als Pulsweitenmodulation (PWM) bezeichnete Technik erzeugt ein pulsierendes Signal, das sich in sehr kurzen Abständen ein- und ausschaltet. Die Spannung des Signals bleibt immer gleich, nur das Verhältnis zwischen Level False (0 V) und Level True (+3,3 V) wird verändert. Das Tastverhältnis gibt das Verhältnis der Länge des eingeschalteten Zustands zur Gesamtdauer eines Schaltzyklus an. Je kleiner das Tastverhältnis, desto kürzer ist die Leuchtzeit der LED innerhalb eines Schaltzyklus. Dadurch wirkt die LED dunkler als eine permanent eingeschaltete LED. Bauteile: 1 Steckbrett, 1 LED gelb mit eingbautem Vorwiderstand, 2 Taster, 6 GPIO-Verbindungskabel, 3 Pinleisten (3 Pins) Links: Tastverhältnis 50 % rechts: Tastverhältnis 20 %. Die beiden Taster dimmen die LED. Eines der GPIO-Verbindungskabel wird dazu verwendet, zwei Kontaktreihen des Steckbretts zu verbinden, über die die beiden Taster am +3,3-V-Pn des Raspberry Pi angeschlossen sind. Einer der beiden Taster lässt die LED schrittweise heller leuchten, der andere bei jedem Drücken einen Schritt dunkler. Variablen in Scratch Variablen sind kleine Speicherplätze, in denen sich ein Programm eine Zahl oder irgendetwas anderes merkt. Wenn das Programm beendet wird, werden diese Variablenspeicher automatisch geleert. Variablen müssen in Scratch auf der Blockpalette Variablen erst einmal angelegt werden, bevor man sie benutzen kann. Anschließend können Sie das Symbol der neu angelegten Variablen aus der Blockpalette in ein dafür vorgesehenes Feld eines Blocks im Programm ziehen. Auf der Blockpalette stehen zusätzlich verschiedene Blöcke zum Auslesen und Verändern der Variablen zur Verfügung. 08pwm01 dimmt eine LED über zwei Taster. Am Anfang definiert das Programm den GPIO-Pin 4 als Ausgang mit PWM-Funktion. Bei einem so definierten Pin bietet Scratch spezielle Funktionen zur Steuerung eines PWM-Signals an. Danach wird die vorab definierte Variable pwm auf den Wert 0 gesetzt. In diesem Zustand ist der PWM-Pin komplett ausgeschaltet. Danach fragt eine Endlosschleife die beiden Taster ab, ändert, wenn einer gedrückt wurde, die Variable pwm und setzt den GPIO-Pin 4 anschließend auf den neuen Wert. Die falls-abfragen überprüfen mit einem und-block zwei Bedingungen, die beide erfüllt sein müssen, um die Variable pwm höher oder niedriger

15 einzustellen. Einerseits muss der Taster gedrückt sein, andererseits darf die Variable pwm nicht über die Grenzwerte 500 bzw. 0 hinauslaufen. Dazu wird beim Erhöhen überprüft, ob sie noch kleiner als 500 ist, beim Absenken muss sie größer als 0 sein. Für jede Variable wird auf der Blockpalette Variablen ein Block angelegt, den Sie in anderen Scratch-Blöcken verwenden können, um den Inhalt dieser Variablen auszuwerten. Der Block ändere um verändert eine Variable relativ zum aktuellen Wert. In unserem Fall werden 10 addiert oder subtrahiert. Unabhängig davon, welches Ergebnis die beiden falls-abfragen liefern, wird der GPIO-Pin anschließend auf den aktuellen Wert der Variablen gesetzt. Dazu verwenden wir den Block verbinde, der zwei beliebige Texte zu einem verbindet, indem er sie hintereinanderhängt. Zahlen werden dabei wie Text behandelt, also nicht addiert, sondern ebenfalls hintereinandergehängt. Schreiben Sie in das erste Feld des Blocks die Zeichenfolge gpio4pwm und ziehen Sie die Variable pwm in das zweite Feld. Auf diese Weise setzen Sie einen PWM-Pin auf einen bestimmten Wert. Die LED leuchtet mit der eingestellten Helligkeit, danach startet die Endlosschleife neu und fragt wieder ab, ob ein Taster gedrückt ist. 9. Tag 1 Pinleiste (3 Pins) LEDs mit Python dimmen Das Experiment des 9. Tags dimmt eine LED mit zwei Tastern über ein Python-Programm. Das Prinzip ähnelt dem Scratch-Programm von Tag 8. Bauteile: 1 Steckbrett, 1 LED gelb mit eingebautem Vorwiderstand, 2 Taster, 6 GPIO-Verbindungskabel, 3 Pinleisten (3 Pins) Die beiden Taster dimmen die LED. 09pwm01.py zeigt, wie PWM-Signale mit Python ausgegeben werden. #!/usr/bin/python import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) LED = 4 T1 = 16 T2 = 7 GPIO.setup(LED, GPIO.OUT) GPIO.setup(T1, GPIO.IN, GPIO.PUD_DOWN) GPIO.setup(T2, GPIO.IN, GPIO.PUD_DOWN) pwm = 0 p = GPIO.PWM(LED, 50) p.start(pwm) try: while True: if GPIO.input(T1)==True and pwm<100: pwm += 10 if GPIO.input(T2)==True and pwm>0:

16 pwm = 10 p.changedutycycle(pwm) time.sleep(0.1) except KeyboardInterrupt: p.stop() So funktioniert das Programm LED = 4 T1 = 16 T2 = 7 Für die Nummern der für die LED und die beiden Taster genutzten GPIO-Pins verwenden wir diesmal Variablen. Das macht das Programm übersichtlicher, da man sofort sieht, welcher Pin gemeint ist. Außerdem lässt sich die Schaltung leicht umbauen, man braucht nur an einer Stelle den jeweiligen Pin zu ändern. p = GPIO.PWM(LED, 50) Die Funktion GPIO.PWM() aus der GPIO-Bibliothek ist entscheidend für die Ausgabe von PWM-Signalen. Diese Funktion benötigt zwei Parameter, den GPIO-Pin und die Frequenz des PWM-Signals. In unserem Fall wird der GPIO-Pin über die Variable LED festgelegt, die Frequenz ist 50 Hertz (Schwingungen pro Sekunde). Warum 50 Hertz die ideale Frequenz für PWM ist Das menschliche Auge nimmt Lichtwechsel schneller als 20 Hertz nicht wahr. Da das Wechselstromnetz in Europa eine Frequenz von 50 Hertz nutzt, blinken viele Beleuchtungskörper mit dieser Frequenz. Blinkt eine LED mit mehr als 20 Hertz, aber weniger als 50 Hertz, kann es zu Interferenzen mit anderen Lichtquellen kommen, wodurch der Dimmeffekt nicht mehr gleichmäßig erscheint. GPIO.PWM() erzeugt ein sogenanntes Objekt, das in der Variablen p gespeichert wird. Solche Objekte sind weit mehr als nur einfache Variablen. Objekte können verschiedene Eigenschaften haben und über Methoden beeinflusst werden. Methoden werden durch einen Punkt getrennt direkt hinter dem Objektnamen angegeben. p.start(pwm) Die Methode start() startet die Generierung des PWM-Signals. Dazu muss noch ein Tastverhältnis angegeben werden. In unserem Fall ist das Tastverhältnis 0, das vorher in der Variablen pwm gespeichert wurde. Die LED ist also immer ausgeschaltet. Im Gegensatz zu Scratch, wo PWM-Werte zwischen 0 und 500 liegen, verwendet Python Werte zwischen 0 und 100, die direkt dem Prozentsatz der Zeit entsprechen, während der der Pin innerhalb eines Frequenzzyklus eingeschaltet ist. Ein PWM-Wert von 25 lässt die LED also ein Viertel der Zeit leuchten und während der übrigen Zeit im Zyklus aus. try: while True: if GPIO.input(T1)==True and pwm<100: pwm += 10 if GPIO.input(T2)==True and pwm>0: pwm = 10 Dann startet wieder eine Endlosschleife, die zunächst die beiden Taster abfragt und ähnlich wie im Scratch-Programm die Variable pwm verändert, solange die Grenzen nicht erreicht sind. p.changedutycycle(pwm) In jedem Schleifendurchlauf setzt die Methode ChangeDutyCycle() das Tastverhältnis des PWM-Objekts auf den aktuellen Wert der Variablen pwm. time.sleep(0.1) Danach wartet das Programm 0,1 Sekunden bis zum nächsten Schleifendurchlauf. Damit wird verhindert, dass versehentlich längeres Drücken des Tasters als mehrere Tastendrücke ausgewertet wird. except KeyboardInterrupt: p.stop() Beim Drücken der Tastenkombination [Strg]+[C] auf der Tastatur wird vor dem Zurücksetzen der GPIO-Pins das PWM-Signal beendet.

17 10. Tag 2 GPIO-Verbindungskabel LEDs mit App dimmen Das Experiment des 10. Tags dimmt eine LED über eine mobile App. Für den Aufbau der Schaltung benötigen Sie folgende Bauteile: Bauteile: 1 Steckbrett, 1 LED rot mit eingebautem Vorwiderstand, 1 LED gelb mit eingebautem Vorwiderstand, 4 GPIO-Verbindungskabel Die beiden LEDs werden über eine mobile App gedimmt. Das Dimmen der LEDs erfolgt über eine App. Für das Hoch- und Runterdimmen soll es eine Schaltfläche geben. Bei Betätigen der Schaltfläche wird ein Python-Skript ausgeführt. Da es zwei Aktionen sind, werden auch zwei Programme benötigt. Für das Hochdimmen nutzen Sie das Programm 10pwm_auf.py: #!/usr/bin/python #10pwm_auf.py import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) LED = 4 GPIO.setup(LED, GPIO.OUT) pwm = 0 p = GPIO.PWM(LED, 50) p.start(pwm) while pwm<100: pwm += 5 p.changedutycycle(pwm) time.sleep(0.1) p.stop() Für das Runterdimmen gibt es das Programm 10pwm_ab.py: #!/usr/bin/python #10pwm_ab.py import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) LED = 22 GPIO.setup(LED, GPIO.OUT) pwm = 100 p = GPIO.PWM(LED, 50) p.start(pwm) while pwm>0: pwm = 5 p.changedutycycle(pwm) time.sleep(0.1) p.stop() Die App Sollten Sie den Webserver und PHP5 noch nicht installiert haben, folgen Sie bitte den Schritten von Tag 7. Zur Umsetzung der App müssen Sie wieder die gleichen vier Schritte wie an Tag 7 erledigen.

18 Schritt 1: Vorlage in das Verzeichnis des Webservers kopieren Zuerst müssen Sie sich wieder die Vorlage app_vorlage in ein Verzeichnis auf dem Webserver kopieren. Folgen Sie dabei Schritt 1 bei der App des 7. Tages. Nennen Sie Ihr Verzeichnis tag10 statt tag07. Schritt 2: Vorlage anpassen Öffnen Sie die Datei index.php aus dem Verzeichnis tag10 per Eingabe von nano index.php im LXTerminal. Fügen Sie dem leeren form-block die notwendigen Schaltflächen hinzu: <form action="index.php" method="post"> <input name="hoch" id="hoch" type="submit" value="hochdimmen" style="background color: #4180C5"> <input name="runter" id="runter" type="submit" value="runterdimmen" style="background color: #4180C5"> </form> Damit erzeugen Sie zwei blaue Schaltflächen mit den Beschriftungen Hochdimmen und Runterdimmen. Speichern Sie die Datei mit [Strg]+[O] und beenden Sie den Editor über [Strg]+[X]. Öffnen Sie dann erneut die Datei index.php im Browser über Nun muss noch die Vorlage mit den beiden Python-Skripten verbunden werden. Ändern Sie hierfür den Anfang der Datei index.php wie folgt: <head> <?php if ($_POST["hoch"]) { echo shell_exec( sudo /var/www/html/tag10/10pwm_auf.py ); } elseif ($_POST["runter"]) { echo shell_exec( sudo /var/www/html/tag10/10pwm_ab.py ); }?> <title>conrad Raspberry Pi Adventskalender</title> Damit ist mobile die Webseite fertig, und Sie können zum Setzen der Rechte übergehen. Schritt 3: Rechte setzen Öffnen Sie erneut das LXTerminal und wechseln Sie über cd /var/www/html/tag10 in das Verzeichnis von Tag 10. Geben Sie den Skripten das Ausführungsrecht: chmod a+x 10*.py Nun müssen Sie noch erlauben, dass der Webserver dieses Skript ausführen darf. Rufen Sie dafür folgenden Befehl auf: sudo visudo Fügen Sie folgende Zeilen ein: www data ALL=(ALL) NOPASSWD: /var/www/html/tag10/10pwm_auf.py www data ALL=(ALL) NOPASSWD: /var/www/html/tag10/10pwm_ab.py Speichern Sie die Datei über [Strg]+[O] und schließen Sie sie mit [Strg]+[X]. Schritt 4: App testen Sie haben es geschafft und können die App auf Ihrem Smartphone testen. Starten Sie den Browser auf Ihrem Smartphone, rufen Sie die Seite über Raspberry Pi/tag10/index.php auf, und schon können Sie das Licht dimmen. Nun können Sie das Licht über das Smartphone dimmen. 11. Tag 1 Servo Servo steuern Ein Servo ist ein kleiner Motor, der einen Servoarm oder andere bewegliche Teile in eine bestimmte Position dreht. Die meisten Servos haben einen Drehbereich von 180 Grad, machen also nicht wie klassische Motoren viele Umdrehungen in Folge.

19 Bauteile: 1 Servo, 1 Pinleiste (3 Pins), 3 GPIO-Verbindungskabel Servo mit einem Scratch-Programm steuern. Das Servo wird in diesem Experiment ohne Steckbrett über GPIO-Verbindungskabel und eine Pinleiste direkt am Raspberry Pi angeschlossen. Die rote und die schwarze Leitung dienen der Stromversorgung, auf der gelben Leitung empfängt das Servo die Steuersignale. Scratch bietet spezielle Codes zur Servosteuerung, in anderen Programmiersprachen wird dies über PWM-Signale gelöst. 11servo01 steuert ein Servo über Eingaben auf der Tastatur. Diesmal besteht das Programm aus mehreren unabhängigen Blöcken, die über verschiedene Ereignisse ausgelöst werden. Bei Klick auf das grüne Fähnchen in Scratch wird Pin 18 als Ausgang für das Steuersignal des Servos definiert, und die Variable s wird auf 0 gesetzt. Diese wird für das Steuersignal verwendet. Scratch liefert dem Servo ein Steuersignal, das einem Prozentwert des Maximalausschlags in einer Richtung entspricht. Bei 0% steht das Servo in der Mittelstellung, bei 100 % an einem Anschlag (meist etwa 90 Grad), bei 100% am anderen Anschlag. Direkt nach der Initialisierung wird über einen verbinde -Block das Signal servo18%0 gesendet. Dabei steht die 18 für den GPIO-Pin, die 0 für den Servowinkel. Drei Blöcke Wenn Taste gedrückt starten automatisch Aktionen, wenn die betreffende Taste auf der Tastatur gedrückt wurde. In Scratch braucht man keine Programmschleifen, die auf die jeweilige Aktion warten, wie dies bei angeschlossenen Tastern der Fall ist. Die Taste [Pfeilæ] setzt die Variable s auf -100 und dreht das Servo an den einen Anschlag, die Taste [PfeilÆ] setzt die Variable s auf 100 und dreht das Servo an den anderen Anschlag. Die Taste [Pfeil½] dreht das Servo in die Mittelstellung. Servos neigen dazu, in einer bestimmten Position nicht ruhig stehen zu bleiben, sondern leicht zu zittern. Die [Leertaste] sendet den Befehl servo18stop und schaltet damit den GPIO-Pin aus. Das Servo bleibt stehen. muss anschließend über das grüne Fähnchen neu aktiviert werden, um das Servo wieder steuern zu können. 12. Tag 1 Servoarm mit Montageschrauben Schrauben Sie den Servoarm mit der kurzen Schraube von oben auf das Servo. Servo dreht mit Python Das Experiment des 12. Tags steuert das Servo über zwei Taster. Ein Druck auf den einen Taster dreht das Servo einen Schritt nach links, ein Druck auf den anderen Taster einen Schritt nach rechts. Bauteile: 1 Servo, 2 Taster, 4 Pinleisten (3 Pins), 6x GPI- O-Verbindungskabel Das Servo wird über zwei Taster gesteuert. Achten Sie beim Schaltungsaufbau genau auf die im Bild gezeigten Reihen auf dem Steckbrett. Das +3,3-V-Signal des Servos wird gleichzeitig als High-Signal für die Taster verwendet. 12servo03.py ähnelt dem Programm zum Dimmen einer LED über zwei Taster. Da Python keine eigenen Funktionen für Servos anbietet, werden PWM-Signale ähnlich wie bei LEDs verwendet. Bei einem 50-Hertz-PWM-Signal entspricht ein Wert von 2,5 dem einen Ende des Drehbereichs des Servos, ein Wert von 12,5 dem anderen Ende. #!/usr/bin/python import RPi.GPIO as GPIO import time servopin = 18

20 t1 = 16 t2 = 7 pwm = 7.5 GPIO.setmode(GPIO.BCM) GPIO.setup(servoPIN, GPIO.OUT) GPIO.setup(t1, GPIO.IN, pull_up_down=gpio.pud_down) GPIO.setup(t2, GPIO.IN, pull_up_down=gpio.pud_down) p = GPIO.PWM(servoPIN, 50) p.start(pwm) try: while True: if GPIO.input(t1) == True and pwm < 12.5: pwm += 2.5 p.changedutycycle(pwm) time.sleep(0.5) p.changedutycycle(0) if GPIO.input(t2) == True and pwm > 2.5: pwm = 2.5 p.changedutycycle(pwm) time.sleep(0.5) p.changedutycycle(0) except KeyboardInterrupt: p.stop() So funktioniert das Programm servopin = 18 t1 = 16 t2 = 7 pwm = 7.5 Am Anfang des Programms werden Variablen für die verwendeten GPIO-Pins definiert. Die Variable pwm wird auf einen PWM-Wert von 7,5 gesetzt, was der Mittelstellung des Servos entspricht. Die Initialisierung der GPIO-Pins und des PWM-Signals entspricht der Vorgehensweise beim Dimmen einer LED. if GPIO.input(t1) == True and pwm < 12.5: pwm += 2.5 p.changedutycycle(pwm) time.sleep(0.5) p.changedutycycle(0) Innerhalb der Endlosschleife werden wieder die Taster überprüft. Wurde ein Taster gedrückt und der Grenzwert noch nicht erreicht, wird die Variable pwm um 2,5 Einheiten in die entsprechende Richtung verändert. Danach wird das PWM-Signal über p.changedutycycle(pwm) auf den neuen Wert gesetzt und dem Servo damit ein Steuerimpuls übermittelt. Nach einer Wartezeit von einer halben Sekunde wird das PWM-Signal auf 0 gesetzt. Damit wird ein Zittern des Servos verhindert. Dies kann vorkommen, da ein softwaregeneriertes PWM-Signal immer geringfügige Toleranzen haben kann. Beim Drücken der Tastenkombination [Strg]+[C] auf der Tastatur wird das PWM-Signal gestoppt, und die GPIO-Pins werden zurückgesetzt. 13. Tag 1 x Knete Formen Sie die Knete zu einem Fuß für das Servo, damit dieses nicht so leicht umfällt. In späteren Experimenten wird die Knete auch für andere Zwecke verwendet. Servo mit App steuern An diesem Tag kommt die Schaltung aus Tag 11 zum Einsatz. Die Steuerung des Servos erfolgt dabei über eine mobile App.

21 Bauteile: 1 Servo, 1 Pinleiste (3 Pins), 3 GPIO-Verbindungskabel Die Schaltung haben Sie bereits vorgestern aufgebaut. Das Drehen des Servos erfolgt über eine App. Für die Links- und Rechtsdrehung soll es eine Schaltfläche geben. Bei Betätigen der Schaltfläche soll jeweils ein Python-Skript ausgeführt werden. Da es zwei Aktionen sind, werden auch zwei Programme benötigt. Für die Drehung nach links nutzen Sie das Programm 13servo_li.py: #!/usr/bin/python #13servo_li.py import RPi.GPIO as GPIO import time servopin = 18 pwm = 12.5 GPIO.setmode(GPIO.BCM) GPIO.setup(servoPIN, GPIO.OUT) p = GPIO.PWM(servoPIN, 50) p.start(pwm) time.sleep(0.5) p.changedutycycle(0) p.stop() Für die Drehung nach rechts nutzen Sie das Programm 13servo_re.py: #!/usr/bin/python #13servo_re.py import RPi.GPIO as GPIO import time servopin = 18 pwm = 2.5 GPIO.setmode(GPIO.BCM) GPIO.setup(servoPIN, GPIO.OUT) p = GPIO.PWM(servoPIN, 50) p.start(pwm) time.sleep(0.5) p.changedutycycle(0) p.stop() Die App Sollten Sie den Webserver und PHP5 noch nicht installiert haben, folgen Sie bitte den Schritten von Tag 7. Zur Umsetzung der App müssen Sie wieder die gleichen vier Schritte wie bei der App an Tag 7 gehen. Schritt 1: Vorlage in das Verzeichnis des Webservers kopieren Zuerst müssen Sie sich wieder die Vorlage app_vorlage in ein Verzeichnis auf dem Webserver kopieren. Folgen Sie dabei Schritt 1 bei der App des 7. Tages. Nennen Sie Ihr Verzeichnis tag13 statt tag07. Schritt 2: Vorlage anpassen Öffnen Sie die Datei index.php aus dem Verzeichnis tag13 mit der Eingabe von nano index.php im LXTerminal. Fügen Sie dem leeren form-block die notwendigen Schaltflächen hinzu: <form action="index.php" method="post"> <input name="servo_links" id="servo_links" type="submit" value="servo links" style="background color: #4180C5"> <input name="servo_rechts" id="servo_rechts" type="submit" value="servo rechts" style="background color: #4180C5"> </form>

22 Damit erzeugen Sie zwei blaue Schaltflächen mit den Beschriftungen Servo links und Servo rechts. Speichern Sie die Datei mit [Strg]+[O] und beenden Sie den Editor über [Strg]+[X]. Öffnen Sie erneut die Datei index.php im Browser über Nun muss die Vorlage noch mit den beiden Python-Skripten verbunden werden. Ändern Sie dafür den Anfang der Datei index.php wie folgt: <head> <?php if ($_POST["servo_links"]) { echo shell_exec( sudo /var/www/html/tag13/13servo_li.py ); } elseif ($_POST["servo_rechts"]) { echo shell_exec( sudo /var/www/html/tag13/13servo_re.py ); }?> <title>conrad Raspberry Pi Adventskalender</title> Damit ist die mobile Webseite fertig, und Sie können zum Setzen der Rechte übergehen. Schritt 3: Rechte setzen Öffnen Sie erneut das LXTerminal und wechseln Sie über cd /var/www/html/tag13 in das Verzeichnis von Tag 13. Geben Sie den Skripten das Ausführungsrecht: chmod a+x 13*.py Nun müssen Sie noch erlauben, dass der Webserver dieses Skript ausführen darf. Rufen Sie dafür folgenden Befehl auf: sudo visudo Fügen Sie folgende Zeilen ein: www data ALL=(ALL) NOPASSWD: /var/www/html/tag13/13servo_li.py www data ALL=(ALL) NOPASSWD: /var/www/html/tag13/13servo_re.py Speichern Sie die Datei über [Strg]+[O] und schließen Sie sie mit [Strg]+[X]. Schritt 4: App testen Sie haben es geschafft und können die App auf Ihrem Smartphone testen. Starten Sie hierfür den Browser auf Ihrem Smartphone, rufen Sie die Seite über Raspberry Pi/tag13/index.php auf, und schon können Sie das Servo drehen. Nun können Sie den Servo über das Smartphone steuern. 14. Tag 1 20-MOhm-Widerstand (rot-schwarz-blau) 1 Pinleiste (3 Pins) Sensorkontakt aus Knete Ampeln, Türöffner, Lichtschalter und Automaten werden heute oft mit Sensorkontakten gesteuert, die man nur zu berühren braucht. Taster, die wirklich gedrückt werden müssen, werden immer seltener. Das Experiment des 14. Tags steuert ein Zufallsspiel über einen einfachen Sensorkontakt. Bauteile: 1 Steckbrett, 1 LED rot mit eingbautem Vorwiderstand, 1 LED gelb mit eingebautem Vorwiderstand, 1 LED grün mit eingebautem Vorwiderstand, 1 20-MOhm-Widerstand (rot-schwarz-blau), 7 GPI- O-Verbindungskabel, 5 Pinleisten (3 Pins), 1 Knetekontakt So funktionieren Sensorkontakte Der als Eingang geschaltete GPIO-Pin ist über einen extrem hochohmigen Widerstand (20 MOhm) mit +3,3 V verbunden, sodass ein schwaches, aber eindeutig als High definiertes Signal anliegt. Ein Mensch, der nicht gerade frei in der Luft schwebt, ist immer geerdet und liefert über die elektrisch leitfähige Haut einen Low-Pegel. Berührt er einen Sensorkontakt, wird das schwache High-Signal von dem deutlich stärkeren Low-Pegel der Hand überlagert und zieht den GPIO-Pin auf Low-Pegel.

23 Wie hoch allerdings der Widerstand zwischen Hand und Masse wirklich ist, hängt von vielen Dingen ab, unter anderem von Schuhen und Fußböden. Barfuß im nassen Gras ist die Verbindung zur Masse der Erde am besten, aber auch auf Steinfußboden funktioniert es meistens gut. Holzfußböden isolieren stärker, Kunststoffbodenbeläge sind oft sogar positiv aufgeladen. Sollte der Sensorkontakt nicht funktionieren, berühren Sie die Pinleiste auf der Masseschiene des Steckbretts und den eigentlichen Sensor gleichzeitig. Dann ist die Masseverbindung auf jeden Fall hergestellt. Knete leitet den Strom etwa so gut wie menschliche Haut. Sie lässt sich leicht in jede beliebige Form bringen, und ein Knetekontakt fasst sich viel besser an als ein einfaches Stück Draht. Die Fläche, mit der die Hand den Kontakt berührt, ist deutlich größer. So kommt es nicht so leicht zu einem Wackelkontakt. Stecken Sie eine Pinleiste in ein Stück Knete und schließen Sie dort ein GPIO-Verbindungskabel an, dessen anderes Ende Sie mit einer weiteren Pinleiste in das Steckbrett stecken. Sollten Sie den Massekonkakt benötigen, können Sie, um einen besseren Kontakt zur Hand herzustellen, auch dort ein Stück Knete auf die nach oben stehenden Pins drücken. Der Sensorkontakt schaltet die LED ein. 14knete01 lässt drei LEDs in kurzen Abständen abwechselnd blinken. 14knete01 lässt drei LEDs in kurzen Abständen abwechselnd blinken, solange der Knetekontakt berührt wird. Lässt man ihn los, leuchtet eine zufällige LED. Damit die Sensorkontakte funktionieren, muss zuerst der interne Pull-up-Widerstand an GPIO-Pin 20 ausgeschaltet werden, der auf dem Raspberry Pi standardmäßig immer eingeschaltet ist. Das erledigt der Zusatz pullnone am GPIO-Befehl config20in zur Initialisierung des GPI- O-Eingangs am Anfang des Programms. In der Hauptschleife des Programms wartet am Anfang ein warte bis -Block darauf, dass der Wert des GPIO-Pins 20 auf 0 geht, weil der Knetekontakt berührt wird. Danach läuft eine wiederhole bis -Schleife so lange, bis der Wert des GPIO-Pins 20 auf 1 geht, weil der Knetekontakt losgelassen wurde. Innerhalb der Schleife werden die drei LEDs nacheinander kurz ein- und wieder ausgeschaltet. Lässt man den Knetekontakt los, sind immer alle LEDs ausgeschaltet, da er nur am Anfang jedes neuen Schleifendurchlaufs abgefragt wird. In dem Fall wird die Schleife beendet, und eine zufällig ausgewählte LED soll leuchten. Für den verwendeten Zufallsalgorithmus werden in der Schaltung GPIO-Pins mit aufeinanderfolgenden Nummern genutzt. Dadurch kann die Steuerung über eine Zufallszahl zwischen 9 und 11 vonstattengehen. generiert eine Zufallszahl aus dem Bereich 9 bis 11. Zwei ineinander geschachtelte verbinde-blöcke erzeugen daraus eine dieser Zeichenfolgen: gpio9on, gpio10on, gpio11on. Die durch die Zeichenfolge eingeschaltete LED bleibt eingeschaltet, wenn die Endlosschleife wieder startet und darauf wartet, dass der Knetekontakt berührt wird. Der Blinkzyklus schaltet spätestens nach einem kompletten Durchlauf nach 0,05 Sekunden jede LED einmal aus. Deshalb ist keine eigene Anweisung zum Ausschalten der zufällig eingeschalteten LED im Programm vorhanden. Wie entstehen Zufallszahlen? Gemeinhin denkt man, in einem Programm könne nichts zufällig geschehen wie also kann ein Programm dann in der Lage sein, zufällige Zahlen zu generieren? Teilt man eine große Primzahl durch irgendeinen Wert, ergeben sich ab der x-ten Nachkommastelle Zahlen, die kaum noch vorhersehbar sind. Sie ändern sich auch ohne jede Regelmäßigkeit, wenn man den Divisor regelmäßig erhöht. Dieses Ergebnis ist zwar scheinbar zufällig, lässt sich aber durch ein identisches Programm oder den mehrfachen Aufruf des gleichen Programms jederzeit reproduzieren. Nimmt man aber eine aus einigen dieser Ziffern zusammengebaute Zahl und teilt sie wiederum durch eine Zahl, die sich aus der aktuellen Uhrzeitsekunde oder dem Inhalt einer beliebigen Speicherstelle des Computers ergibt, kommt ein Ergebnis heraus, das sich nicht reproduzieren lässt und daher als Zufallszahl bezeichnet wird. 15. Tag 1 RGB-LED mit eingebauten Vorwiderständen

24 RGB-Farbspiele Das Experiment des 15. Tags lässt eine RGB-LED automatisch nacheinander in verschiedenen Farben aufleuchten. Bauteile: 1 Steckbrett, 1 RGB-LED mit eingebauten Vorwiderständen, 4 GPIO-Verbindungskabel, 3 Pinleisten (3 Pins) RGB-LED an den GPIO-Pins 23, 24, rgbled01 schaltet nacheinander verschiedene der drei Farbkomponenten der RGB-LED ein und andere wieder aus. Da zeitweise zwei Farben eingeschaltet sind, leuchtet die RGB-LED abwechselnd in unterschiedlichen Mischfarben. 15rgbled01 steuert eine RGB-LED. Am Anfang wird die Variable z auf 5 gesetzt. Sie steuert die Zeit zwischen dem Aufleuchten der einzelnen Farben und damit die Blinkgeschwindigkeit der RGB-LED. Die Variable wird auf der Scratch-Bühne mit einem Regler angezeigt. Damit kann der Benutzer die Geschwindigkeit während des Programmlaufs interaktiv regeln. Diese Regler lassen sich über einen Rechtsklick auf die Variable auf der Scratch-Bühne ein- und ausblenden. Da die Regler nur auf ganzzahlige Werte eingestellt werden können, gibt die Variable z die Zeit in Zehntelsekunden an. Nachdem die drei verwendeten GPIO-Ausgänge initialisiert wurden, wird Pin 24 als Einziger eingeschaltet. Die RGB-LED leuchtet grün. Danach werden der Reihe nach andere Pins ein- und ausgeschaltet. Die Wartezeit zwischen den Schaltvorgängen wird über die Variable z in Zehntelsekunden geregelt und kann vom Benutzer interaktiv über den Regler auf der Scratch-Bühne verändert werden. 16. Tag 1 RGB-LED mit eingebauten Vorwiderständen RGB-Farbmischung Das Experiment des 16. Tags zeigt auf zwei RGB-LEDs unterschiedliche Farbverläufe, die vom Benutzer auf dem Bildschirm interaktiv verändert werden können. Mischfarben und Farbverläufe entstehen, wenn man die einzelnen Farben einer RGB-LED über PWM-Signale unterschiedlich hell einstellt. Bauteile: 1 Steckbrett, 2 RGB-LEDs mit eingebauten Vorwiderständen, 7 GPIO-Verbindungskabel, 5 Pinleisten (3 Pins) Zwei RGB-LEDs zeigen verschiedene Farbverläufe. 16rgbled02 verändert die drei Farben beider RGB-LEDs jeweils zyklisch über PWM-Signale. Dabei werden unterschiedliche Zykluszeiten verwendet, um verschiedene, scheinbar unregelmäßige Farbverläufe zu erzeugen. besteht aus sechs weitgehend ähnlichen Programmblöcken, die jeweils eine Farbe der beiden RGB-LEDs steuern. Sie starten, voneinander unabhängig, alle in dem Moment, in dem der Benutzer auf das grüne Fähnchen klickt. verwendet zwölf Variablen, die alle auf der Bühne angezeigt werden: r1, g1 und b1 enthalten die aktuellen Farbwerte der ersten RGB-LED, r2, g2 und b2 die aktuellen Farbwerte der zweiten RGB-LED. Die Variablen r1z, g1z und b1z enthalten die Wartezeiten zwischen den einzelnen Schaltvorgängen der drei Farben der ersten RGB-LED in Zehntelsekunden, r2z, g2z und b2z enthalten die entsprechenden Werte für die zweite RGB-LED. Diese Zeiten können interaktiv über Regler eingestellt werden, um die Farbeffekte zu beeinflussen. Jeder Programmblock verändert das PWM-Signal einer Farbkomponente in zehn Schritten von 0 auf 500 und danach wieder zurück. Durch unterschiedlich eingestellte Farben entstehen unterschiedliche Farbspiele. 16rgbled02 steuert zwei RGB-LEDs über PWM.

25 17. Tag 1 LED blau mit eingebautem Vorwiderstand 1 Ausschneidevorlage für Anzeigeinstrument auf der Rückseite Analoge Anzeige mit Servo Das Experiment des 17. Tags nutzt das Servo als analoges Anzeige instrument, um die Position einer Figur auf der Scratch-Bühne anzuzeigen. Zusätzlich wird die Position durch vier farbige LEDs angezeigt. Bauteile: 1 Steckbrett, 1 Servo, 1 LED rot mit eingebautem Vorwiderstand, 1 LED gelb mit eingebautem Vorwiderstand, 1 LED grün mit eingebautem Vorwiderstand, 1 LED blau mit eingebautem Vorwiderstand, 8 GPIO-Verbindungskabel, 4 Pinleisten (3 Pins) Schneiden Sie die Skala aus der Kartonrückseite des Adventskalenders aus und stecken Sie sie so auf das Servo, dass sie am Servogehäuse einrastet. Schneiden Sie dann auch den Zeiger aus. Er wird erst auf das Servo gesteckt, wenn es über das Programm in die Ausgangsstellung gefahren ist. Servo und vier LEDs. Der Zeiger und die Skala für das Servo. Im Programm 17servo02 bewegt der Benutzer interaktiv eine Figur auf der Scratch-Bühne. Deren Position wird mit einem Servo und vier LEDs angezeigt. 17servo02 steuert vier LEDs und ein Servo anhand der Position einer Figur. Eine Wiederhole fortlaufend-schleife überprüft ständig, welche Farben auf dem Bildschirm die Figur berührt, und schaltet dann die LEDs in den entsprechenden Farben ein. Diese Figur wird auf der Scratch-Bühne bewegt und ihre Position angezeigt. Die Variable s wird auf einen Wert gesetzt, der sich aus der y-position des Objekts geteilt durch 1,8 ergibt. Die y-position der Figur kann ein Wert zwischen 180 und +180 sein, für das Servo werden aber Werte zwischen 100 und +100 benötigt deshalb die Umrechnung. Starten Sie das Programm mit einem Klick auf das grüne Fähnchen und ziehen Sie die Figur an den unteren Rand, bis im Feld Objekt1 y-position der Wert 0 angezeigt wird und die blaue LED leuchtet. Stecken Sie den Zeiger so auf das Servo, dass er auf die 0 der Skala zeigt. Wenn Sie nun die Figur bewegen, zeigt das Servo die aktuelle Position an. 18. Tag 4 GPIO-Verbindungskabel Drehbare Weihnachtspyramide Die drei LEDs sind über GPIO-Verbindungskabel direkt mit dem Rasp berry Pi verbunden. Sie stecken in den vorgesehenen Positionen auf der Pyramide. Setzen Sie die Pyramide auf den Servoarm, damit sie sich drehen kann. Sollte sie nicht richtig halten, können Sie die Schraube des Servoarms entfernen, diesen aber auf dem Servo stecken lassen und die Schraube durch den Boden der Pyramide wieder in den Servoarm schrauben. Damit sich die Pyramide frei drehen kann, sind die LEDs über zwei hintereinandergesteckte GPIO-Verbindungskabel mit dem Steckbrett verbunden. Ein Kabel wäre zu kurz und würde die Beweglichkeit der Pyramide einschränken. Die insgesamt sechs Leitungen der LEDs werden über zwei dreipolige Pinleisten mit weiteren sechs Leitungen verlängert. Bauteile: 1 Servo, 1 LED rot mit eingebautem Vorwiderstand, 1 LED gelb mit eingbautem Vorwiderstand, 1 LED grün mit eingebautem Vorwiderstand, 15 GPIO-Verbindungskabel, 3 Pinleisten (3 Pins) Servo und drei LEDs, ohne Steckbrett direkt am Raspberry Pi angeschlossen.

26 18pyramide01 besteht aus zwei unabhängigen Programmblöcken, die die Drehung der Pyramide und das Blinken der LEDs steuern. Die Geschwindigkeiten können unabhängig über Regler auf der Scratch-Bühne eingestellt werden. 18pyramide01 steuert Drehung und Blinken der Pyramide. Die Variable dreh enthält die Wartezeit zwischen zwei Drehbewegungen in Sekunden. Diese kann über den Regler minimal auf eine Sekunde eingestellt werden, da das Servo für seine Bewegungen eine gewisse Zeit benötigt. Das Servo dreht sich in einer Endlosschleife immer zwischen den Positionen 0, 100, 0 und 100. Die Variable blink enthält die Zeit, die eine LED leuchtet, in Zehntelsekunden. Während dieser eingestellten Zeit leuchten die drei LEDs jeweils nacheinander. Das Umschalten auf eine andere LED erfolgt ohne Wartezeit. So leuchtet immer eine LED. 19. Tag 1 GPIO-Verbindungskabel Drehbare Weihnachtspyramide mit Taster steuern Das Experiment des 19. Tags steuert die blinkende und drehende Weihnachtspyramide mit einem Taster über ein Python-Programm. Die LEDs auf der Pyramide sind wieder über je zwei hintereinandergehängte GPIO-Verbindungskabel angeschlossen. Bauteile: 1 Servo, 1 LED rot mit eingebautem Vorwiderstand, 1 LED gelb mit eingebautem Vorwiderstand, 1 LED grün mit eingebautem Vorwiderstand, 1 Taster, 16 GPIO-Verbindungskabel, 5 Pinleisten (3 Pins) LEDs auf der drehenden Weihnachtspyramide mit einem Taster auf dem Steckbrett. Achten Sie auf den genauen Aufbau. Der Taster und das Servo verwenden die gleiche Kontaktreihe für das +5-V-Signal. 19pyramide05.py dreht die Pyramide auf dem Servo abwechselnd in beiden Richtungen hin und her. Die LEDs leuchten nacheinander als Lauflicht. Ein Druck auf den Taster kehrt die Richtung des Lauflichts um. #!/usr/bin/python import RPi.GPIO as GPIO import time LED = [[17, 22, 10],[10, 22, 17]] x = 0 t1 = 8 servopin = 21 GPIO.setmode(GPIO.BCM) GPIO.setup(t1, GPIO.IN, GPIO.PUD_DOWN) GPIO.setup(servoPIN, GPIO.OUT) pwm = 2.5 a = 2.5 p = GPIO.PWM(servoPIN, 50) p.start(pwm) for i in LED[0]: GPIO.setup(i, GPIO.OUT) try: while True: p.changedutycycle(pwm) pwm += a if pwm==12.5 or pwm==2.5: a = a time.sleep(0.2) p.changedutycycle(0)

27 for i in LED[x]: GPIO.output(i, True) time.sleep(0.2) GPIO.output(i, False) if GPIO.input(t1) == True: x = 1 x except KeyboardInterrupt: p.stop() So funktioniert das Programm LED = [[17, 22, 10],[10, 22, 17]] x = 0 Die Pins für die drei LEDs werden als verschachtelte Liste definiert. Das erste Listenelement ist eine weitere Liste der drei Pinnummern, das zweite Listenelement ist eine Liste der Pinnummern in umgekehrter Reihenfolge. Die Variable x wird später zur Auswahl einer dieser beiden Listen verwendet. Die Zählung von Listenelementen beginnt immer bei 0. Die beiden Elemente dieser Liste haben also die Nummern LED[0] und LED[1]. for i in LED[0]: GPIO.setup(i, GPIO.OUT) Die drei GPIO-Pins werden über die Liste LED[0] initialisiert. Da beide Listen die gleichen Pinnummern enthalten, kann genauso auch die andere Liste verwendet werden. p.changedutycycle(pwm) pwm += a In der Endlosschleife wird das Servo bei jedem Schleifendurchlauf auf den aktuellen pwm-wert gesetzt. Dieser wird in jedem Durchlauf um die zuvor auf 2.5 gesetzte Variable a erhöht. if pwm==12.5 or pwm==2.5: a = a Hat das Servo eine der beiden Endstellungen erreicht, wird das Vorzeichen der Variablen a geändert, damit sich das Servo ab dem nächsten Schleifendurchlauf in die andere Richtung dreht. time.sleep(0.2) p.changedutycycle(0) Nach einer Wartezeit von 0,2 Sekunden erhält das Servo ein PWM-Signal mit dem Wert 0, um das bekannte Zittern zu vermeiden. for i in LED[x]: GPIO.output(i, True) time.sleep(0.2) GPIO.output(i, False) if GPIO.input(t1) == True: x = 1 x Jetzt startet eine Schleife, die über die drei LEDs läuft und sie nacheinander für jeweils 0,2 Sekunden einschaltet. In jedem Durchlauf dieser Schleife wird der Taster abgefragt. Wurde er gedrückt, wechselt die Variable x von 0 auf 1 oder umgekehrt. Damit wird die jeweils andere Liste der LEDs für das Lauflicht verwendet und auf diese Weise dessen Richtung umgekehrt. Nach einem Zyklus des Lauflichts startet die Endlosschleife wieder, dreht das Servo einen Schritt und startet einen weiteren Lauflichtzyklus. Beim Drücken der Tastenkombination [Strg]+[C] auf der Tastatur wird das PWM-Signal gestoppt, und die GPIO-Pins werden zurückgesetzt. 20. Tag 1 GPIO-Verbindungskabel Drehbare Weihnachtspyramide mit App-Steuerung Am heutigen Tag wird die Weihnachtspyramide mit einer mobilen App gesteuert. Bauteile: 1 Servo, 1 LED rot mit eingebautem Vorwiderstand, 1 LED gelb mit eingebautem Vorwiderstand, 1 LED grün mit eingebautem Vorwiderstand, 15 GPIO-Verbindungskabel, 3 Pinleisten (3 Pins)

28 Servo und drei LEDs, ohne Steckbrett direkt am Raspberry Pi angeschlossen. Das Drehen der Pyramide und das Schalten der LEDs werden im Folgenden über eine App gesteuert. Für die Links- und Rechtsdrehung soll es jeweils eine Schaltfläche geben. Auch für das Lauflicht und das Blinken der LEDs soll es jeweils eine Schaltfläche geben. Für jede der vier Funktionen wird ein Python-Skript benötigt. Für die Drehung der Pyramide nach links nutzen Sie das Programm 20servo_li.py: #!/usr/bin/python #20servo_li.py import RPi.GPIO as GPIO import time servopin = 21 pwm = 12.5 GPIO.setmode(GPIO.BCM) GPIO.setup(servoPIN, GPIO.OUT) p = GPIO.PWM(servoPIN, 50) p.start(pwm) time.sleep(0.5) p.changedutycycle(0) p.stop() Für die Drehung der Pyramide nach rechts nutzen Sie das Programm 20servo_re.py: #!/usr/bin/python #20servo_re.py import RPi.GPIO as GPIO import time servopin = 21 pwm = 2.5 GPIO.setmode(GPIO.BCM) GPIO.setup(servoPIN, GPIO.OUT) p = GPIO.PWM(servoPIN, 50) p.start(pwm) time.sleep(0.5) p.changedutycycle(0) p.stop() Für die Schaltung des Lauflichts nutzen Sie das Programm 20pyramide_lauflicht.py: #!/usr/bin/python #20pyramide_lauflicht.py import RPi.GPIO as GPIO import time LED = [17, 22, 10] GPIO.setmode(GPIO.BCM) for i in LED: GPIO.setup(i, GPIO.OUT) for j in range(3): for i in LED: GPIO.output(i, True) time.sleep(0.2) GPIO.output(i, False) Für das Einschalten des Blinkens nutzen Sie das Programm 20pyramide_blink.py: #!/usr/bin/python #20pyramide_blink.py import RPi.GPIO as GPIO import time

29 LED = [17, 22, 10] GPIO.setmode(GPIO.BCM) for i in LED: GPIO.setup(i, GPIO.OUT) for j in range(3): for i in LED: GPIO.output(i, True) time.sleep(0.2) for i in LED: GPIO.output(i, False) time.sleep(0.2) Die App Sollten Sie den Webserver und PHP5 noch nicht installiert haben, folgen Sie bitte den Schritten von Tag 7. Auch zur Umsetzung der App müssen Sie wieder die gleichen vier Schritte wie an Tag 7 durchführen. Schritt 1-App: Vorlage in das Verzeichnis des Webservers kopieren Zuerst müssen Sie sich wieder die Vorlage app_vorlage in ein Verzeichnis auf dem Webserver kopieren. Folgen Sie dabei Schritt 1 bei der App des 7. Tags. Nennen Sie Ihr Verzeichnis tag20 statt tag07. Schritt 2-App: Vorlage anpassen Öffnen Sie die Datei index.php aus dem Verzeichnis tag20 mit der Eingabe von nano index.php im LXTerminal. Fügen Sie dem leeren form-block die notwendigen Schaltflächen hinzu: <form action="index.php" method="post"> <input name="servo_links" id="servo_links" type="submit" value="pyramide links" style="background color: #4180C5"> <input name="servo_rechts" id="servo_rechts" type="submit" value="pyramide rechts" style="background color: #4180C5"> <input name="lauflicht" id="lauflicht" type="submit" value="lauflicht" style="background color: #4180C5"> <input name="blinken" id="blinken" type="submit" value="blinken" style="background color: #4180C5"> </form> Damit erzeugen Sie vier blaue Schaltflächen mit den Beschriftungen Pyramide links, Pyramide rechts, Lauflicht und Blinken. Speichern Sie die Datei mit [Strg]+[O] und beenden Sie den Editor über [Strg]+[X]. Öffnen Sie die Datei index.php im Browser über Nun muss die Vorlage noch mit den beiden Python-Skripten verbunden werden. Ändern Sie dafür den Anfang der Datei index.php wie folgt: <head> <?php if ($_POST["servo_links"]) { echo shell_exec( sudo /var/www/html/tag20/20servo_li.py ); } elseif ($_POST["servo_rechts"]) { echo shell_exec( sudo /var/www/html/tag20/20servo_re.py ); } elseif ($_POST["lauflicht"]) { echo shell_exec( sudo /var/www/html/tag20/20pyramide_lauflicht.py ); } elseif ($_POST["blinken"]) { echo shell_exec( sudo /var/www/html/tag20/20pyramide_blink.py ) }?> <title>conrad Raspberry Pi Adventskalender</title> Damit ist die mobile Webseite fertig, und Sie können zum Setzen der Rechte übergehen. Schritt 3: Rechte setzen Öffnen Sie hierfür erneut das LXTerminal und wechseln Sie über cd /var/www/html/tag20 in das Verzeichnis von Tag 20. Geben Sie den Skripten das Ausführungsrecht: chmod a+x 20*.py

30 Nun müssen Sie noch erlauben, dass der Webserver dieses Skript ausführen darf. Rufen Sie dafür folgenden Befehl auf: sudo visudo Nun können Sie die Pyramide und die LEDs über das Smartphone steuern. Fügen Sie folgende Zeilen ein: www data ALL=(ALL) NOPASSWD: /var/www/html/tag20/20servo_li.py www data ALL=(ALL) NOPASSWD: /var/www/html/tag20/20servo_re.py www data ALL=(ALL) NOPASSWD: /var/www/html/tag20/20pyramide_lauflicht.py www data ALL=(ALL) NOPASSWD: /var/www/html/tag20/20pyramide_blink.py Speichern Sie die Datei über [Strg]+[O] und schließen Sie sie mit [Strg]+[X]. Schritt 4: App testen Sie haben es geschafft und können die App auf Ihrem Smartphone testen. Starten Sie hierfür den Browser auf Ihrem Smartphone, rufen Sie die Seite über Raspberry Pi/tag20/index.php auf, und schon können Sie die Weihnachtspyramide steuern. 21. Tag 1 20-MOhm-Widerstand Weihnachtspyramide mit Knetesteuerung Im Experiment des 21. Tags steuern zwei Knetekontakte über ein Python-Programm das Blinken der LEDs auf der Weihnachtspyramide, die sich diesmal nicht dreht. Da sich die Pyramide heute nicht dreht, reichen einfache GPIO-Kabel für die LEDs aus. Es ist nicht nötig, sie mit einem zweiten Kabel zu verlängern. Daher können die vorhandenen Pinleisten für die beiden Knetekontakte verwendet werden. Bauteile: 1 Steckbrett, 1 LED rot mit eingebautem Vorwiderstand, 1 LED gelb mit eingebautem Vorwiderstand, 1 LED grün mit eingebautem Vorwiderstand, 2 20-MOhm-Widerstände (rot-schwarz-blau), 11 GPI- O-Verbindungskabel, 5 Pinleisten (3 Pins), 2 Knetekontakte Zwei Knetekontakte steuern drei LEDs auf der Weihnachtspyramide. 21knete03.py zeigt, wie Knetekontakte mit Python angesprochen werden. Berührt man den einen Knetekontakt, blinken die LEDs als Lauflicht, berührt man den anderen, blinken alle drei gleichzeitig. #!/usr/bin/python import RPi.GPIO as GPIO import time LED = [17, 22, 10] k1 = 13 k2 = 20 GPIO.setmode(GPIO.BCM) GPIO.setup(k1, GPIO.IN) GPIO.setup(k2, GPIO.IN) for i in LED: GPIO.setup(i, GPIO.OUT) try: while True: while GPIO.input(k1) == False: for i in LED: GPIO.output(i, True) time.sleep(0.1) GPIO.output(i, False)

31 while GPIO.input(k2) == False: for i in LED: GPIO.output(i, True) time.sleep(0.1) for i in LED: GPIO.output(i, False) time.sleep(0.1) except KeyboardInterrupt: So funktioniert das Programm LED = [17, 22, 10] k1 = 13 k2 = 20 Die GPIO-Pins für die LEDs werden wieder als Liste gespeichert, die Pins der Knetekontakte in den Variablen k1 und k2. while GPIO.input(k1) == False: for i in LED: GPIO.output(i, True) time.sleep(0.1) GPIO.output(i, False) Innerhalb der Endlosschleife laufen zwei while-schleifen. Jede läuft, solange einer der beiden Knetekontakte berührt wird. Innerhalb der ersten while-schleife läuft eine for-schleife, die die drei LEDs nacheinander für jeweils 0,1 Sekunden einschaltet. while GPIO.input(k2) == False: for i in LED: GPIO.output(i, True) time.sleep(0.1) for i in LED: GPIO.output(i, False) time.sleep(0.1) Wird der andere Knetekontakt berührt, werden alle drei LEDs unmittelbar nacheinander eingeschaltet und nach einer Wartezeit von 0,1 Sekunden alle wieder ausgeschaltet. Das erscheint wie ein gleichzeitiges Blinken aller drei LEDs. 22. Tag 1 Pinleiste (3 Pins) Drehbare Weihnachtspyramide mit Knete steuern Das Experiment des 22. Tags basiert auf dem Experiment des 18. Tags mit dem Unterschied, dass die LEDs nur dann blinken und die Pyramide sich nur dann bewegt, wenn der Knetekontakt berührt wird. Die LEDs auf der Pyramide sind wieder über je zwei hintereinandergehängte GPI- O-Verbindungskabel angeschlossen. Bauteile: 1 Servo, 1 Steckbrett, 1 LED rot mit eingebautem Vorwiderstand, 1 LED gelb mit eingebautem Vorwiderstand, 1 LED grün mit eingebautem Vorwiderstand, 1 20-MOhm-Widerstand (rot-schwarz-blau), 17 GPIO-Verbindungskabel, 6 Pinleisten (3 Pins), 1 Knetekontakt Drehbare Weihnachtspyramide mit einem Knetekontakt steuern. 22pyramide02 besteht ähnlich wie das Programm des 18. Tags aus zwei unabhängigen Blöcken, die die Drehung der Pyramide und die Blinkeffekte der LEDs steuern. Statt der Endlosschleifen sind Sensorabfragen eingebaut. Zuerst wartet ein warte bis -Block darauf, dass der Wert des GPIO-Pins 8 auf 0 geht, weil der Knetekontakt berührt wird. Danach läuft eine wiederhole bis -Schleife so lange, bis der Wert des GPIO-Pins 8 wieder auf 1 geht, weil der Knetekontakt losgelassen wurde.

32 22pyramide02 steuert die Pyramide mit einem Knetekontakt. Bedingt durch die relativ langsame Drehung des Servos, hören die LEDs beim Loslassen des Knetekontakts nahezu sofort auf zu blinken, das Servo dreht aber noch einen Moment. Auch hier ist ein Block eingebaut, der beim Drücken der [Leertaste] den Befehl servo18stop sendet und damit den GPIO-Pin ausschaltet. Das Servo bleibt stehen und zittert auch nicht mehr. 23. Tag 1 RGB-LED mit eingebauten Vorwiderständen RGB-Farbspiele mit Python Das Experiment des 23. Tags lässt drei RGB-LEDs mithilfe von PWM-Signalen automatisch in verschiedenen Farben leuchten. Bauteile: 1 Steckbrett, 3 RGB-LEDs mit eingbauten Vorwiderständen, 10 GPIO-Verbindungskabel, 5 Pinleisten (3 Pins) Drei RGB-LEDs mit Vorwiderständen. 23rgbled03.py erzeugt Farbwechseleffekte auf den RGB-LEDs unter Verwendung des HSV-Farbsystems. HSV- und RGB-Farbsystem Das RGB-Farbsystem, das bisher in allen Programmen verwendet wurde, beschreibt Farben als drei Komponenten Rot, Grün und Blau, die miteinander gemischt werden. Für einen Menschen ist es relativ schwierig, sich eine Mischfarbe vorzustellen. Im Gegensatz dazu beschreibt das HSV-Farbsystem die Farben über die Werte H = Hue (Farbwert), S = Saturation (Sättigung) und V = Value (Helligkeit). Durch eine einfache Veränderung des H-Werts können alle Farben des Farbspektrums in voller Intensität beschrieben werden, wenn man die beiden anderen Werte auf Maximum einstellt. #!/usr/bin/python import RPi.GPIO as GPIO import time import colorsys GPIO.setmode(GPIO.BCM) LED1 = [21, 20, 16] LED2 = [12, 7, 8] LED3 = [25, 24, 23] p1 = [0, 0, 0] p2 = [0, 0, 0] p3 = [0, 0, 0] for i in range(3): GPIO.setup(LED1[i], GPIO.OUT) GPIO.setup(LED2[i], GPIO.OUT) GPIO.setup(LED3[i], GPIO.OUT) for i in range(3): p1[i] = GPIO.PWM(LED1[i], 50) p1[i].start(0) p2[i] = GPIO.PWM(LED2[i], 50) p2[i].start(0)

33 p3[i] = GPIO.PWM(LED3[i], 50) p3[i].start(0) try: while True: for i in range(100): rgb1 = colorsys.hsv_to_rgb(i/100, 1, 1) x2 = i+20 if x2 > 100: x2 = 100 rgb2 = colorsys.hsv_to_rgb(x2/100, 1, 1) x3 = i+40 if x3 > 100: x3 = 100 rgb3 = colorsys.hsv_to_rgb(x3/100, 1, 1) for j in range(3): p1[j].changedutycycle(rgb1[j]) p2[j].changedutycycle(rgb2[j]) p3[j].changedutycycle(rgb3[j]) time.sleep(0.1) except KeyboardInterrupt: for i in range(3): p1[i].stop() p2[i].stop() p3[i].stop() So funktioniert das Programm import colorsys Zusätzlich zu den bereits bekannten Bibliotheken wird die Bibliothek colorsys zur Umrechnung zwischen HSV- und RGB-Farbsystem importiert. LED1 = [21, 20, 16] LED2 = [12, 7, 8] LED3 = [25, 24, 23] Dann werden die Pinnummern aller drei RGB-LEDs in einer eigenen Liste gespeichert. p1 = [0, 0, 0] p2 = [0, 0, 0] p3 = [0, 0, 0] Danach werden für die insgesamt neun PWM-Signale der drei RGB-LEDs ebenfalls drei Listen angelegt. for i in range(3): GPIO.setup(LED1[i], GPIO.OUT) GPIO.setup(LED2[i], GPIO.OUT) GPIO.setup(LED3[i], GPIO.OUT) Eine Schleife setzt alle verwendeten GPIO-Pins als Ausgänge. for i in range(3): p1[i] = GPIO.PWM(LED1[i], 50) p1[i].start(0) p2[i] = GPIO.PWM(LED2[i], 50) p2[i].start(0) p3[i] = GPIO.PWM(LED3[i], 50) p3[i].start(0) Eine weitere Schleife richtet die insgesamt neun PWM-Signale ein und startet alle mit dem Wert 0. Alle RGB-LEDs sind ausgeschaltet. Das HSV-Farbsystem verwendet üblicherweise für die Farbskala Werte zwischen 0 und 100 im Gegensatz zum RGB-System, das Werte zwischen 0 und 255 nutzt. In Python verwenden beide Farbsysteme Werte zwischen 0,0 und 1,0. for i in range(100): rgb1 = colorsys.hsv_to_rgb(i/100, 1, 1) Zur Umrechnung läuft eine Schleife von 0 bis 99. Innerhalb dieser Schleife werden die RGB-Werte der ersten RGB-LED in jedem Schleifendurchlauf neu berechnet, indem der Schleifenzähler als HSV-Wert mithilfe der Funktion colorsys.hsv_to_rgb() in einen RGB-Wert umgerechnet wird. Diese Funktion liefert automatisch eine Liste aus drei Werten, die in der Variablen rgb1 gespeichert wird.

34 x2 = i+20 if x2 > 100: x2 = 100 rgb2 = colorsys.hsv_to_rgb(x2/100, 1, 1) Die zweite RGB-LED erhält einen gegenüber der ersten LED um 20 Einheiten verschobenen HSV-Wert. Dieser wird nach der gleichen Formel umgerechnet und in der Variablen rgb2 gespeichert. Wenn der durch Addition auf den Schleifenzähler entstandene Wert die Obergrenze von 100 überschreitet, werden automatisch 100 subtrahiert, sodass er wieder bei 0 startet. x3 = i+40 if x3 > 100: x3 = 100 rgb3 = colorsys.hsv_to_rgb(x3/100, 1, 1) Auf die gleiche Weise wird der Farbwert der dritten RGB-LED durch Addition von 40 auf den HSV-Wert der ersten LED errechnet. Die zweite und dritte RGB-LED laufen also im Farbspektrum der ersten leicht hinterher. for j in range(3): p1[j].changedutycycle(rgb1[j]) p2[j].changedutycycle(rgb2[j]) p3[j].changedutycycle(rgb3[j]) time.sleep(0.1) Dann setzt eine Schleife die PWM-Signale der drei RGB-LEDs auf die errechneten RGB-Werte und wartet danach 0,1 Sekunden, bevor die nächsten Farben errechnet werden. except KeyboardInterrupt: for i in range(3): p1[i].stop() p2[i].stop() p3[i].stop() Bricht der Benutzer mit der Tastenkombination [Strg]+[C] das Programm ab, werden alle neun PWM-Signale gestoppt und die GPIO-Pins zurückgesetzt. 24. Tag 1 Downloadcode 1 Ausschneidevorlage für Anzeigeinstrument auf der Rückseite Uhr für Wartezeit bis zum nächsten Adventskalender Eine Uhr zeigt die Wartezeit bis zum nächsten Adventskalender an und spielt je nach Jahreszeit eine passende Melodie ab. Laden Sie dazu über den hinter dem heutigen Türchen liegenden Downloadcode die Lieder bei herunter. Entpacken Sie das Zip-Archiv in das Home-Verzeichnis /home/pi. Bauteile: 1 Servo, 1 Pinleiste (3 Pins), 3 GPIO-Verbindungskabel, Downloadcode für Musik Auf der Rückseite des Adventskalenders finden Sie eine Skala mit zwölf Monaten, die Sie auf das Servo stecken können. Servo zur Steuerung der Uhr. Die Skala für die zwölf Monate. 24uhr01.py zeigt mit dem Servo an, wie viele Monate man noch bis zum nächsten Adventskalender warten muss, und spielt ein Lied ab. #!/usr/bin/python import RPi.GPIO as GPIO import time

35 import subprocess servopin = 21 GPIO.setmode(GPIO.BCM) GPIO.setup(servoPIN, GPIO.OUT) p = GPIO.PWM(servoPIN, 50) p.start(0) zeit = time.localtime() m = zeit.tm_mon pwm = (m/12*10)+2.5 p.changedutycycle(pwm) time.sleep(0.5) p.changedutycycle(0) if m<4: subprocess.popen(["omxplayer", "lied1.mp3"]) elif m<7: subprocess.popen(["omxplayer", "lied2.mp3"]) elif m<10: subprocess.popen(["omxplayer", "lied3.mp3"]) elif m<12: subprocess.popen(["omxplayer", "lied4.mp3"]) else: subprocess.popen(["omxplayer", "lied5.mp3"]) p.stop() So funktioniert das Programm import subprocess Zusätzlich zu den bereits bekannten Bibliotheken wird die Bibliothek subprocess importiert. Damit ist es möglich, Linux-Kommandozeilenprogramme aus einem Python-Programm heraus zu starten. Wie bereits bekannt, wird der GPIO-Pin für das Servo als Ausgang eingerichtet und ein PWM-Signal gestartet. zeit = time.localtime() Die aktuelle Zeit wird im Objekt zeit gespeichert. Dazu wird die Funktion time.localtime() aus der time-bibliothek verwendet. Das Ergebnis ist eine Datenstruktur, die aus verschiedenen Einzelwerten besteht. m = zeit.tm_mon Aus dem Zeit-Objekt wird der Monat ausgelesen und in der Variablen m gespeichert. Der Monat ist eine Zahl zwischen 1 (Januar) und 12 (Dezember). pwm = (m/12*10)+2.5 p.changedutycycle(pwm) Aus der Monatszahl wird der passende PWM-Wert im Drehbereich des Servos errechnet und das Servo auf diesen Wert gedreht. time.sleep(0.5) p.changedutycycle(0) Nach einer Wartezeit von einer halben Sekunde bekommt das Servo den PWM-Wert 0, um das Zittern zu vermeiden. Es bleibt auf der zuvor ermittelten Position stehen. if m<4: subprocess.popen(["omxplayer", "lied1.mp3"]) Ist der aktuelle Monat kleiner als 4 (Januar bis März), wird die Melodie lied1.mp3 abgespielt. Dazu wird die Funktion subprocess.popen() verwendet, die in diesem Fall den kommandozeilenbasierten Medienplayer omxplayer aufruft. elif m<7: subprocess.popen(["omxplayer", "lied2.mp3"]) elif m<10: subprocess.popen(["omxplayer", "lied3.mp3"]) elif m<12: subprocess.popen(["omxplayer", "lied4.mp3"])

36 Die Abfragen hinter elif werden ausgeführt, wenn zuvor keine Abfrage den Wert True lieferte. Auf diese Weise können beliebig viele Abfragen hintereinander geschachtelt werden. Je nach aktuellem Monat (April bis Juni, Juli bis September, Oktober bis November) werden unterschiedliche Lieder abgespielt. else: subprocess.popen(["omxplayer", "lied5.mp3"]) Lieferte keine der Abfragen den Wert True, ist der aktuelle Monat Dezember. In diesem Fall wird die Melodie lied5.mp3 abgespielt. Zum Schluss wird noch das PWM-Signal gestoppt, und die GPIO-Pins werden zurückgesetzt. Frohe Weihnachten!