Die wichtigsten Bauteile kurz...

2

Adventskalender Raspberry Pi 2017 . . . . . . . . . . . . . . 3Die wichtigsten Bauteile kurz erklärt . . . . . . . . . . . . . . . . . . . . . . . . . . 3Steckbrett . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3LEDs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3RGB-LEDs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3Widerstand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4Servo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4GPIO-Verbindungskabel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5Raspberry Pi vorbereiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5Betriebssysteminstallation in Kürze . . . . . . . . . . . . . . . . . . . . . . . . . . . 5LED leuchtet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7Zwei LEDs blinken abwechselnd rot und grün . . . . . . . . . . . . . . . . . . . 7Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

3 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8Zwei LEDs blinken mit Python abwechselnd rot und grün . . . . . . . . . . 8Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8So funktioniert das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

4 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10LEDs mit Taster umschalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10

5 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .12Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12LEDs auf der Weihnachtspyramide mit Python umschalten . . . . . . . . . 12Die Weihnachtspyramide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12So funktioniert das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

6 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14Scratch-Katze schaltet LEDs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

7 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .16LEDs mit einer Smartphone-App schalten . . . . . . . . . . . . . . . . . . . . . . .16Umsetzung des Projekts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Die App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .18

8 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20LEDs dimmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

9 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22LEDs mit Python dimmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22So funktioniert das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

10 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24LEDs mit App dimmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24Die App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

11 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26Servo steuern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

12 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27Servo dreht mit Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27So funktioniert das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

13 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29Servo mit App steuern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29Die App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

14 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .31Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31Sensorkontakt aus Knete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31So funktionieren Sensorkontakte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

15 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33RGB-Farbspiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

16 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34RGB-Farbmischung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

17 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35Analoge Anzeige mit Servo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

18 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37Drehbare Weihnachtspyramide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37

19 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38Drehbare Weihnachtspyramide mit Taster steuern . . . . . . . . . . . . . . . 38Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38So funktioniert das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

20 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40Drehbare Weihnachtspyramide mit App-Steuerung . . . . . . . . . . . . . . . 40Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40Die App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .41

21 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43Weihnachtspyramide mit Knetesteuerung . . . . . . . . . . . . . . . . . . . . . . 43Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43So funktioniert das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

22 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45Drehbare Weihnachtspyramide mit Knete steuern . . . . . . . . . . . . . . . 45Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

23 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47RGB-Farbspiele mit Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47So funktioniert das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

24 . Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50Heute im Adventskalender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50Uhr für Wartezeit bis zum nächsten Adventskalender . . . . . . . . . . . . . 50Das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50So funktioniert das Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

Alle Versuche im Überblick

3

Adventskalender Raspberry Pi 2017Mit 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 Expe-rimente 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

SteckbrettFü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) mitein-ander verbunden . Diese Kontaktreihen werden oft als Plus- und Minuspol zur Strom-versorgung 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 .

LEDsLEDs (zu Deutsch: Leuchtdioden) leuchten, wenn Strom in Durch-flussrichtung durch sie fließt . LEDs werden in Schaltungen mit einem pfeilförmigen Dreieckssymbol dargestellt, das die Flussrich-tung 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 Durch-flussstrom zu begrenzen und damit ein Durchbrennen der LED zu verhindern, wird üblicherweise zwischen dem verwendeten GPIO-Pin und der Anode der LED oder zwi-schen 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 .

RGB-LEDsEine 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 .

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 brau-chen deshalb auch drei Vorwiderstände . Diese sind in den im Adventskalender enthaltenen RGB-LEDs ebenfalls einge-baut .

Die Verbindungen auf dem Steckbrett .

Schaltplan einer LED mit Vorwiderstand .

Anschlusspins einer RGB-LED .

4

WiderstandWiderstände werden zur Strombegrenzung an empfindlichen elektronischen Bautei-len sowie als Vorwiderstände für LEDs verwendet . Die Maßeinheit für Widerstände ist Ohm . 1 .000 Ohm entsprechen einem Kiloohm, abgekürzt kOhm . 1 .000 kOhm entsprechen einem Megaohm, abgekürzt MOhm . Oft wird für die Einheit Ohm auch das Omega-Zeichen Ω verwendet .

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 Tole-ranzwert 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 Einbau-richtung eine große Rolle .

ServoEin 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 Strom-versorgung, auf der dritten empfängt das Servo die Steuerungssignale .

GPIO-VerbindungskabelDie farbigen Verbindungskabel haben alle auf beiden Seiten eine Steckbuchse, die auf einen

GPIO-Pin des Raspberry Pi passt . LEDs und andere Bauteile kön-nen 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 .

Vorsichtsmaßnahmen Auf keinen Fall sollte man irgendwelche GPIO-Pins miteinander verbinden und abwarten ab, was pas-siert . 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 miteinan-der, 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 wer-den 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 GPIO-Eingang verbunden werden .

Interner Schaltplan für eine RGB-LED mit drei Vorwiderständen .

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 0 100 = 1

Braun 1 1 101 = 10 ±1 %

Rot 2 2 102 = 100 ±2 %

Orange 3 3 103 = 1 .000

Gelb 4 4 104 = 10 .000

Grün 5 5 105 = 100 .000 ±0,5 %

Blau 6 6 106 = 1 .000 .000 ±0,25 %

Violett 7 7 107 = 10 .000 .000 ±0,1 %

Grau 8 8 108 = 100 .000 .000 ±0,05 %

Weiß 9 9 109 = 1 .000 .000 .000

Belegung der GPIO-Pins .

5

1 . Tag

1 . Tag

Heute im Adventskalender• 1 LED rot mit eingbautem Vorwiderstand

• 1 GPIO-Verbindungskabel

Raspberry Pi vorbereitenUm 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ürzeFü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 www.raspberrypi.org/downloads 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: www.sdcard.org/downloads/formatter_4 . 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 Ins-tallationssprache 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 kli-cken . 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 Tasta-tur 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 Shut-down neu booten . Eine eventuell auftauchende Warnung wegen eines unsicheren Passworts kann ignoriert werden .

LED leuchtetDas Experiment zeigt, wie LEDs angeschlossen werden . Achten Sie dar-auf, 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 GPIO-Verbindungskabel . Alle Schaltungsaufbauzeichnungen sind in den Downloads zum Adventskalender in Farbe enthalten, damit Sie die Lei-tungen besser erkennen können .

Bauteile: 1 LED rot mit eingbautem Vorwiderstand, 2 GPIO-Verbindungskabel

Gesteuert wird das Ganze über ein Programm in Scratch . Die erste LED leuchtet am Raspberry Pi .

6

Programme zum Download

Die im Adventskalender verwendeten Programme und Aufbauzeichnungen gibt es hier zum Download: www.buch.cd . Tragen Sie für dieses Produkt den Code 15002-8 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 .

Das ProgrammScratch 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 Bear-beiten/Start GPIO server eingeschaltet werden .

In Scratch braucht man beim Programmieren keinen Programmcode zu tippen . Die Blöcke werden einfach nur per Drag-and-drop aneinandergehängt . Die Block-palette 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 zusam-menbauen 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 .

Klicken Sie in Scratch oben links auf das gelbe Symbol Steue-rung . 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 Blockpa-lette in das Skriptfenster in der Mitte von Scratch .

Der Block Wenn (grüne Fahne) ange-klickt dient dazu, ein Programm zu star-

ten . 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

Das Programm startet, wenn man oben rechts im Scratch-Fenster auf das grüne Fähnchen klickt .

GPIO-Server in Scratch starten .

Dieses Scratch-Programm 01led01 lässt die LED eine halbe Sekunde leuchten .

7

2 . Tag

Heute im Adventskalender• 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ünDas 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)

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 .

Das ProgrammAm 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 ausge-schaltet 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 .

Das Programm 02led02 steuert die beiden LEDs .

Zwei LEDs blinken am Raspberry Pi .

2 . Tag

8

3 . Tag

Heute im Adventskalender• 2 GPIO-Verbindungskabel

Zwei LEDs blinken mit Python abwechselnd rot und grünDas 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)

Python ist auf dem Raspberry Pi ebenfalls vorinstalliert, sogar in zwei verschiedenen Versionen . Python 3 ist nicht einfach, wie der Name ver-muten 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 funkti-oniert . 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 Down-load oder öffnen Sie in der Python-Shell über File/New ein neues Fens-ter und tippen Sie das Programm ein .

Das ProgrammDas Programm 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/pythonimport RPi.GPIO as GPIOimport 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) GPIO.cleanup()

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 GPIOimport time

Zwei LEDs blinken am Raspberry Pi .

3 . Tag

9

Ein großer Vorteil von Python ist die einfache Erweiterbarkeit um neue Funktionen aus Funktionsbiblio-theken . 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 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)

Das Programm 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 .

GPIO.cleanup()

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 .

10

4 . Tag

Heute im Adventskalender• 1 Taster

• 1 Pinleiste (3 Pins)

LEDs mit Taster umschalten Das Experiment des 4 . Tags schaltet die LEDs nicht automatisch um, son-dern 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 GPIO-Verbindungska-bel, 3 Pinleisten (3 Pins)

Das ProgrammDas Programm 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 .

Das Programm 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 pas-sieren 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 .

LEDs mit Taster umschalten .

4 . Tag

11

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 . Schrei-ben 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 star-ten . 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 vordefi-nierten 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 .

12

5 . Tag


LEDs auf der Weihnachtspyramide mit Python umschaltenDas Programm des 5 . Tags verwendet Python, um zwei LEDs mit einem Taster umzuschalten . Die LEDs können diesmal auf die Weihnachtspyra-mide 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 GPIO-Verbindungska-bel, 1 Pinleiste (3 Pins)

Die WeihnachtspyramideAuf 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 .

Das ProgrammIm 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 .


GPIO.setmode(GPIO.BCM)

Zwei LEDs auf der Pyramide und ein Taster auf dem Steckbrett .

5 . Tag

13

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: GPIO.cleanup()

So funktioniert das ProgrammGPIO.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 Tas-ter initialisiert . Der Parameter GPIO.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 Gleich-heitszeichen = 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 Bedin-gung 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: GPIO.cleanup()

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 .

14

6 . Tag

Heute im Adventskalender• 1 LED gelb mit eingebautem Vorwiderstand

Scratch-Katze schaltet LEDsDie Katze auf der Scratch-Bühne, dem Teilfenster rechts oben, ist nicht nur die Symbolfigur von Scratch, sondern ein frei programmierbares Objekt, das verschiedenste Aktionen ausführen kann . Im Experiment des 6 . Tags wird die Katze über einen Hintergrund mit drei verschiedenfar-bigen Streifen – grün, gelb und rot – laufen . Je nachdem, welche Hinter-grundfarbe 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)

Das ProgrammDas Programm 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 .

Das Programm 06katze01 lässt die Scratch-Katze drei LEDs steuern .

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 Regis-terkarte Hintergründe und klicken Sie auf Bear-beiten . Damit startet das Malprogramm, das die wesentlichen Funktionen eines einfachen Grafik-programms bietet .

Mithilfe des Rechtecksymbols und der Farbpa-lette 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

Die Scratch-Katze schaltet drei LEDs .

Das Malprogramm für den Hintergrund in Scratch .

6 . Tag

15

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 Koordinaten-einheiten breit ist, kommt sie an den im Block eingetragenen Koordinaten x:-150 y:0 an eine gute Aus-gangsposition, 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 wieder-holt 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 Wendeposi-tion 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 inner-halb der oberen Klammer falls ausgeführt, wenn nicht, wird der andere Block inner-halb 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 Bal-ken 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 .

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

palette Bewegung . Damit die Katze nach der Drehung nicht auf dem Kopf steht, aktivieren Sie das Dop-pelpfeilsymbol 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 .

16

7 . Tag


LEDs mit einer Smartphone-App schaltenEinige 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 Instal-lation ö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 http://<IP-Adresse Raspberry PI> ein, das Beispiel aus dem Screenshot zeigt die Adresse http://192.168.178.44 .

Die Testseite auf dem Smartphone . Damit ist die

Webserverinstallation abgeschlossen .

Durch Klick auf den Menüeintrag öffnet sich die Eingabeaufforderung .

Der Raspberry-Pi-Desktop zeigt die IP-Adresse an .

7 . Tag

17

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 http://localhost ein, und schon sehen Sie die Testseite im Browser .

Schritt 2: PHP5 installieren

Nachdem der Webserver erfolgreich getestet ist, müssen Sie noch PHP5 installieren . Starten Sie dazu zuerst das LXTerminal und aktualisieren Sie das Sys-tem 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 . Hier-fü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-Verzeich-nis /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 http://<IP-Adresse-Raspberry-Pi>/phpinfo.php auf Ihrem Smartphone oder über http://localhost/phpinfo.php im Browser des Raspberry Pi .

Umsetzung des ProjektsJetzt haben Sie alle Voraussetzung für die Umsetzung der ersten mobilen App geschaffen . Zunächst bauen wir die Schaltung auf . Hier-fü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)

Das ProgrammFü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 Sekun-den, in diesem Fall also eine Sekunde .


GPIO.setmode(GPIO.BCM)GPIO.setup(4, GPIO.OUT)GPIO.output(4, True)time.sleep(1)GPIO.cleanup()

Der Befehl phpinfo() gibt Systeminformationen zur PHP-Installation in Form einer Webseite aus .

Über die App wird eine LED eingeschaltet, und diese schaltet sich nach der eingestellten

Zeit wieder aus .

18

Die AppDie mobile Webseite erstellen Sie anhand einer Vorlage . Diese finden Sie im Ver-zeichnis 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

Ö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:

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 Verzeich-nis sollte jetzt wie das in nebenstehenden Abbildung aussehen .

Nun können Sie die Vorlage im Browser auf dem Raspberry Pi über http://localhost/tag07/index.php öffnen .

Schritt 2: Vorlage anpassen

Ö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 anzuschal-ten, benötigen Sie eine Schaltfläche . Ändern Sie des-wegen 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 back-ground-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 http://localhost/tag07/index.php erneut die Datei index.php im Browser .

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 .

Der Inhalt von /var/www/html/tag07 nach dem Kopieren der

Vorlage .

Die kopierte Vorlage im Browser des Raspberry Pi .

Die angepasste Vorlage im Browser des Raspberry Pi .

19

Ü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 folgen-den 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

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 http://<IP-Adresse 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 .

20

8 . Tag

Heute im Adventskalender• 1 Taster

LEDs dimmenLEDs können zwei verschiedene Zustände annehmen, ein und aus . Das Gleiche gilt für die als digitale Aus-gänge definierten GPIO-Ports . Demnach wäre es theo-retisch nicht möglich, eine LED zu dimmen .

Mit einem Trick erreicht man es dennoch, die Hellig-keit 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 Pulsweiten-modulation (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)

Eines der GPIO-Verbindungskabel wird dazu verwendet, zwei Kontakt-reihen des Steckbretts zu verbinden, über die die beiden Taster am +3,3-V-Pn des Raspberry Pi angeschlossen sind .

Das ProgrammEiner 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 ein-mal angelegt werden, bevor man sie benutzen kann . Anschließend können Sie das Symbol der neu angelegten Variablen aus der Block-palette 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 .

Das Programm 08pwm01 dimmt eine LED über zwei Taster .

Links: Tastverhältnis 50 % – rechts: Tastverhältnis 20 % .

Die beiden Taster dimmen die LED .

8 . Tag

21

Am Anfang definiert das Programm den GPIO-Pin 4 als Ausgang mit PWM-Funktion . Bei einem so defi-nierten 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 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 .

22

9 . Tag

Heute im Adventskalender• 1 Pinleiste (3 Pins)

LEDs mit Python dimmenDas 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)

Das ProgrammDas Programm 09pwm01.py zeigt, wie PWM-Signale mit Python ausgege-ben werden .


GPIO.setmode(GPIO.BCM)LED = 4T1 = 16T2 = 7

GPIO.setup(LED, GPIO.OUT)GPIO.setup(T1, GPIO.IN, GPIO.PUD_DOWN)GPIO.setup(T2, GPIO.IN, GPIO.PUD_DOWN)

pwm = 0p = 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: pwm -= 10 p.ChangeDutyCycle(pwm) time.sleep(0.1)

except KeyboardInterrupt: p.stop() GPIO.cleanup()

So funktioniert das ProgrammLED = 4T1 = 16T2 = 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ßer-dem 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) .

Die beiden Taster dimmen die LED .

9 . Tag

23

Warum 50 Hertz die ideale Frequenz für PWM ist Das menschliche Auge nimmt Lichtwechsel schneller als 20 Hertz nicht wahr . Da das Wechselstrom-netz in Europa eine Frequenz von 50 Hertz nutzt, blinken viele Beleuchtungskörper mit dieser Fre-quenz . 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 Objekt-namen 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 entspre-chen, 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() GPIO.cleanup()

Beim Drücken der Tastenkombination [Strg]+[C] auf der Tastatur wird vor dem Zurücksetzen der GPIO-Pins das PWM-Signal beendet .

24

10 . Tag


LEDs mit App dimmenDas 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

Das ProgrammDas Dimmen der LEDs erfolgt über eine App . Für das Hoch- und Runter-dimmen 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.pyimport RPi.GPIO as GPIOimport time

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


while pwm<100: pwm += 5 p.ChangeDutyCycle(pwm) time.sleep(0.1)

p.stop()GPIO.cleanup()

Für das Runterdimmen gibt es das Programm 10pwm_ab.py:

#!/usr/bin/python#10pwm_ab.pyimport RPi.GPIO as GPIOimport time

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


while pwm>0: pwm -= 5 p.ChangeDutyCycle(pwm) time.sleep(0.1)


Die beiden LEDs werden über eine mobile App

gedimmt .

10 . Tag

25

Die AppSollten 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 .


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 .


Öffnen Sie die Datei index.php aus dem Verzeichnis tag10 per Eingabe von nano index.php im LXTermi-nal . 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 http://localhost/tag10/index.php .

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 .


Ö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.pywww-data ALL=(ALL) NOPASSWD: /var/www/html/tag10/10pwm_ab.py



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 http://<IP-Adresse Raspberry Pi/tag10/index.php auf, und schon können Sie das Licht dimmen .

Nun können Sie das Licht über das Smartphone dimmen .

26

11 . Tag

Heute im Adventskalender• 1 Servo

Servo steuernEin Servo ist ein kleiner Motor, der einen Servoarm oder andere beweg-liche Teile in eine bestimmte Position dreht . Die meisten Servos haben einen Drehbereich von 180 Grad, machen also nicht wie klassische Moto-ren viele Umdrehungen in Folge .

Bauteile: 1 Servo, 1 Pinleiste (3 Pins), 3 GPIO-Verbindungskabel

Das Servo wird in diesem Experiment ohne Steckbrett über GPIO-Verbin-dungskabel 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 .

Das ProgrammScratch bietet spezielle Codes zur Servosteuerung, in anderen Program-miersprachen wird dies über PWM-Signale gelöst .

Das Programm 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 . Das Programm muss anschließend über das grüne Fähnchen neu aktiviert werden, um das Servo wieder steuern zu können .

Servo mit einem Scratch-Programm steuern .

11 . Tag

27

12 . Tag

Heute im Adventskalender• 1 Servoarm mit Montageschrauben

Schrauben Sie den Servoarm mit der kurzen Schraube von oben auf das Servo .

Servo dreht mit PythonDas 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 GPIO-Verbin-dungskabel

Achten Sie beim Schaltungsaufbau genau auf die im Bild gezeigten Rei-hen auf dem Steckbrett . Das +3,3-V-Signal des Servos wird gleichzeitig als High-Signal für die Taster verwendet .

Das ProgrammDas Programm 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 .


servoPIN = 18t1 = 16t2 = 7pwm = 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:

Das Servo wird über zwei Taster gesteuert .

12 . Tag

28

p.stop() GPIO.cleanup()

So funktioniert das ProgrammservoPIN = 18t1 = 16t2 = 7pwm = 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 Zit-tern des Servos verhindert . Dies kann vorkommen, da ein softwaregeneriertes PWM-Signal immer gering-fü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 .

29

13 . Tag

Heute im Adventskalender• 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 steuernAn diesem Tag kommt die Schaltung aus Tag 11 zum Einsatz . Die Steuerung des Servos erfolgt dabei über eine mobile App .

Bauteile: 1 Servo, 1 Pinleiste (3 Pins), 3 GPIO-Verbindungskabel

Das ProgrammDas Drehen des Servos erfolgt über eine App . Für die Links- und Rechts-drehung 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.pyimport RPi.GPIO as GPIOimport time

servoPIN = 18pwm = 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()GPIO.cleanup()

Für die Drehung nach rechts nutzen Sie das Programm 13servo_re.py:

#!/usr/bin/python#13servo_re.pyimport RPi.GPIO as GPIOimport time




Zur Umsetzung der App müssen Sie wieder die gleichen vier Schritte wie bei der App an Tag 7 gehen .

Die Schaltung haben Sie bereits vorgestern aufgebaut .

13 . Tag

30


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 .


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

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 http://localhost/tag13/index.php .

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 .


Ö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


sudo visudo


www-data ALL=(ALL) NOPASSWD: /var/www/html/tag13/13servo_li.pywww-data ALL=(ALL) NOPASSWD: /var/www/html/tag13/13servo_re.py



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 http://<IP-Adresse Raspberry Pi/tag13/index.php auf, und schon können Sie das Servo dre-hen .Nun können Sie den Servo über das Smartphone steuern .

31

14 . Tag

Heute im Adventskalender• 1 20-MOhm-Widerstand (rot-schwarz-blau)

• 1 Pinleiste (3 Pins)

Sensorkontakt aus KneteAmpeln, 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 Experi-ment des 14 . Tags steuert ein Zufallsspiel über einen einfachen Sensor-kontakt .

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 GPIO-Verbindungskabel, 5 Pinleisten (3 Pins), 1 Knetekontakt

So funktionieren SensorkontakteDer 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 Sensorkon-takt, wird das schwache High-Signal von dem deutlich stärkeren Low-Pegel der Hand überlagert und zieht den GPIO-Pin auf Low-Pegel .

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 . Holz-fuß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 herge-stellt .

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 „Wackelkon-takt“ . 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 Masse-konkakt 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 .

14 . Tag

32

Das ProgrammDas Programm 14knete01 lässt drei LEDs in kurzen Abständen abwech-selnd 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 GPIO-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 Kne-tekontakt 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 .

Das Programm 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 Anwei-sung 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 Pro-gramm 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 aktuel-len 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 .

Das Programm 14knete01 lässt drei LEDs in kurzen Abständen abwechselnd

blinken .

33

15 . Tag

Heute im Adventskalender• 1 RGB-LED mit eingebauten Vorwiderständen

RGB-FarbspieleDas Experiment des 15 . Tags lässt eine RGB-LED automatisch nacheinan-der in verschiedenen Farben aufleuchten .

Bauteile: 1 Steckbrett, 1 RGB-LED mit eingebauten Vorwiderständen, 4 GPIO-Verbindungskabel, 3 Pinleisten (3 Pins)

Das ProgrammDas Programm 15rgbled01 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 .

Das Programm 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 inter-aktiv 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 eingeschal-tet . 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 .

RGB-LED an den GPIO-Pins 23, 24, 25 .

15 . Tag

34

16 . Tag


RGB-FarbmischungDas 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)

Das ProgrammDas Programm 16rgbled02 verändert die drei Farben beider RGB-LEDs jeweils zyklisch über PWM-Signale . Dabei werden unterschiedliche Zyk-luszeiten verwendet, um verschiedene, scheinbar unregelmäßige Farb-verläufe zu erzeugen .

Das Programm 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 .

Das Programm verwendet zwölf Variablen, die alle auf der Bühne ange-zeigt 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 Zehn-telsekunden, r2z, g2z und b2z enthalten die entsprechenden Werte für die zweite RGB-LED . Diese Zeiten können interaktiv über Regler einge-stellt 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 .

Zwei RGB-LEDs zeigen verschiedene Farbverläufe .

Das Programm 16rgbled02 steuert zwei RGB-LEDs über PWM .

16 . Tag

35

17 . Tag

Heute im Adventskalender• 1 LED blau mit eingebautem Vorwiderstand

• 1 Ausschneidevorlage für Anzeigeinstrument auf der Rückseite

Analoge Anzeige mit ServoDas Experiment des 17 . Tags nutzt das Servo als analoges Anzeige-instrument, um die Position einer Figur auf der Scratch-Bühne anzuzei-gen . Zusätzlich wird die Position durch vier farbige LEDs angezeigt .

Bauteile: 1 Steckbrett, 1 Servo, 1 LED rot mit eingebautem Vorwider-stand, 1 LED gelb mit eingebautem Vorwiderstand, 1 LED grün mit eingebautem Vorwiderstand, 1 LED blau mit eingebautem Vorwider-stand, 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 .

Der Zeiger und die Skala für das Servo .

Das ProgrammIm Programm 17servo02 bewegt der Benutzer interaktiv eine Figur auf der Scratch-Bühne . Deren Position wird mit einem Servo und vier LEDs angezeigt .

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 .

Servo und vier LEDs .

17 . Tag

36

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 Umrech-nung .

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 .

Das Programm 17servo02 steuert vier LEDs und ein Servo

anhand der Position einer Figur .

37

18 . Tag


Drehbare WeihnachtspyramideDie 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 Pyra-mide 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)

Das ProgrammDas Programm 18pyramide01 besteht aus zwei unabhängigen Programm-blö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 .

Das Programm 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 eingestell-ten Zeit leuchten die drei LEDs jeweils nacheinander . Das Umschalten auf eine andere LED erfolgt ohne Wartezeit . So leuchtet immer eine LED .

Servo und drei LEDs, ohne Steckbrett direkt am Raspberry Pi angeschlossen .

18 . Tag

38

19 . Tag


Drehbare Weihnachtspyramide mit Taster steuernDas 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 Vorwider-stand, 1 LED grün mit eingebautem Vorwiderstand, 1 Taster, 16 GPIO-Verbindungskabel, 5 Pinleisten (3 Pins)

Achten Sie auf den genauen Aufbau . Der Taster und das Servo verwenden die gleiche Kontaktreihe für das +5-V-Signal .

Das ProgrammDas Programm 19pyramide05.py dreht die Pyramide auf dem Servo abwechselnd in beiden Richtungen hin und her . Die LEDs leuchten nach-einander als Lauflicht . Ein Druck auf den Taster kehrt die Richtung des Lauflichts um .


LED = [[17, 22, 10],[10, 22, 17]]x = 0t1 = 8servoPIN = 21

GPIO.setmode(GPIO.BCM)GPIO.setup(t1, GPIO.IN, GPIO.PUD_DOWN)GPIO.setup(servoPIN, GPIO.OUT)

pwm = 2.5a = 2.5p = 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) 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()

LEDs auf der drehenden Weihnachtspyramide mit einem Taster auf dem Steckbrett .

19 . Tag

39

GPIO.cleanup()

So funktioniert das ProgrammLED = [[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 wei-tere 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 .

40

20 . Tag


Drehbare Weihnachtspyramide mit App-SteuerungAm heutigen Tag wird die Weihnachtspyramide mit einer mobilen App gesteuert .

Bauteile: 1 Servo, 1 LED rot mit eingebautem Vorwiderstand, 1 LED gelb mit eingebautem Vorwider-stand, 1 LED grün mit eingebautem Vorwiderstand, 15 GPIO-Verbindungskabel, 3 Pinleisten (3 Pins)

Das ProgrammDas 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.pyimport RPi.GPIO as GPIOimport time



Für die Drehung der Pyramide nach rechts nutzen Sie das Programm 20servo_re.py:

#!/usr/bin/python#20servo_re.pyimport RPi.GPIO as GPIOimport time



Für die Schaltung des Lauflichts nutzen Sie das Programm 20pyramide_lauflicht.py:

#!/usr/bin/python#20pyramide_lauflicht.pyimport RPi.GPIO as GPIOimport time

LED = [17, 22, 10]GPIO.setmode(GPIO.BCM)

Servo und drei LEDs, ohne Steckbrett direkt am Raspberry Pi angeschlossen .

20 . Tag

41

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)

GPIO.cleanup()

Für das Einschalten des Blinkens nutzen Sie das Programm 20pyramide_blink.py:

#!/usr/bin/python#20pyramide_blink.pyimport RPi.GPIO as GPIOimport time

LED = [17, 22, 10]GPIO.setmode(GPIO.BCM)


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)

GPIO.cleanup()


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 http://localhost/tag20/index.php .

42

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 .


Öffnen Sie hierfür erneut das LXTerminal und wechseln Sie über cd /var/www/html/tag20 in das Ver-zeichnis von Tag 20 . Geben Sie den Skripten das Ausführungsrecht:

chmod a+x 20*.py


sudo visudo


www-data ALL=(ALL) NOPASSWD: /var/www/html/tag20/20servo_li.pywww-data ALL=(ALL) NOPASSWD: /var/www/html/tag20/20servo_re.pywww-data ALL=(ALL) NOPASSWD: /var/www/html/tag20/20pyramide_lauflicht.pywww-data ALL=(ALL) NOPASSWD: /var/www/html/tag20/20pyramide_blink.pySpeichern Sie die Datei über [Strg]+[O] und schließen Sie sie mit [Strg]+[X] .


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 http://<IP-Adresse Raspberry Pi/tag20/index.php auf, und schon können Sie die Weihnachts-pyramide steuern .

Nun können Sie die Pyramide und die LEDs über das Smartphone

steuern .

43

21 . Tag

Heute im Adventskalender• 1 20-MOhm-Widerstand

Weihnachtspyramide mit KnetesteuerungIm 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 GPIO-Verbindungskabel, 5 Pinleisten (3 Pins), 2 Knetekontakte

Das ProgrammDas Programm 21knete03.py zeigt, wie Knetekontakte mit Python ange-sprochen werden . Berührt man den einen Knetekontakt, blinken die LEDs als Lauflicht, berührt man den anderen, blinken alle drei gleichzeitig .


LED = [17, 22, 10]k1 = 13k2 = 20

GPIO.setmode(GPIO.BCM)GPIO.setup(k1, GPIO.IN)GPIO.setup(k2, GPIO.IN)


try: while True: while GPIO.input(k1) == False: for i in LED: GPIO.output(i, True) time.sleep(0.1) GPIO.output(i, False)

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: GPIO.cleanup()

Zwei Knetekontakte steuern drei LEDs auf der Weihnachtspyramide .

21 . Tag

44

So funktioniert das ProgrammLED = [17, 22, 10]k1 = 13k2 = 20

Die GPIO-Pins für die LEDs werden wieder als Liste gespeichert, die Pins der Knetekontakte in den Varia-blen 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 Knetekon-takte berührt wird . Innerhalb der ersten while-Schleife läuft eine for-Schleife, die die drei LEDs nachein-ander 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 gleichzeiti-ges Blinken aller drei LEDs .

45

22 . Tag

Heute im Adventskalender• 1 Pinleiste (3 Pins)

Drehbare Weihnachtspyramide mit Knete steuernDas 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 GPIO-Verbindungskabel angeschlossen .

Bauteile: 1 Servo, 1 Steckbrett, 1 LED rot mit eingebautem Vorwider-stand, 1 LED gelb mit eingebautem Vorwiderstand, 1 LED grün mit ein-gebautem Vorwiderstand, 1 20-MOhm-Widerstand (rot-schwarz-blau), 17 GPIO-Verbindungskabel, 6 Pinleisten (3 Pins), 1 Knetekontakt

Das ProgrammDas Programm 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 losgelas-sen wurde .

22 . Tag

Drehbare Weihnachtspyramide mit einem Knetekontakt steuern .

46

Bedingt durch die relativ langsame Drehung des Servos, hören die LEDs beim Loslassen des Knetekon-takts 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 .

Das Programm 22pyramide02 steuert die Pyramide mit einem Knetekontakt .

47

23 . Tag


RGB-Farbspiele mit PythonDas Experiment des 23 . Tags lässt drei RGB-LEDs mithilfe von PWM-Signa-len automatisch in verschiedenen Farben leuchten .

Bauteile: 1 Steckbrett, 3 RGB-LEDs mit eingbauten Vorwiderständen, 10 GPIO-Verbindungskabel, 5 Pinleisten (3 Pins)

Das ProgrammDas Programm 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/pythonimport RPi.GPIO as GPIOimport timeimport 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) 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)

Drei RGB-LEDs mit Vorwiderständen .

23 . Tag

48

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() GPIO.cleanup()

So funktioniert das Programmimport 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 mit-hilfe 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 .

49

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() GPIO.cleanup()

Bricht der Benutzer mit der Tastenkombination [Strg]+[C] das Programm ab, werden alle neun PWM-Signale gestoppt und die GPIO-Pins zurückgesetzt .

50

24 . Tag

Heute im Adventskalender• 1 Downloadcode

• 1 Ausschneidevorlage für Anzeigeinstrument auf der Rückseite

Uhr für Wartezeit bis zum nächsten AdventskalenderEine 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 www.buch.cd 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 .

Die Skala für die zwölf Monate .

Das ProgrammDas Programm 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/pythonimport RPi.GPIO as GPIOimport timeimport subprocess

servoPIN = 21GPIO.setmode(GPIO.BCM)

GPIO.setup(servoPIN, GPIO.OUT)p = GPIO.PWM(servoPIN, 50) p.start(0)

zeit = time.localtime()m = zeit.tm_monpwm = (m/12*10)+2.5p.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"])

24 . Tag

Servo zur Steuerung der Uhr .

51

else: subprocess.Popen(["omxplayer", "lied5.mp3"])


So funktioniert das Programmimport 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.5p.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 Medien-player 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"])

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!

Liebe Kunden!

Dieses Produkt wurde in Übereinstimmung mit den geltenden europäischen Richtlinien hergestellt und trägt daher das CE-Zeichen . Der bestimmungsgemäße Gebrauch ist in der beiliegenden Anleitung

beschrieben .

Bei jeder anderen Nutzung oder Veränderung des Produktes sind allein Sie für die Einhaltung der geltenden Regeln verantwortlich . Bauen Sie die Schaltungen deshalb genau so auf, wie es in der Anlei-

tung beschrieben wird . Das Produkt darf nur zusammen mit dieser Anleitung weitergegeben werden .

Das Symbol der durchkreuzten Mülltonne bedeutet, dass dieses Produkt getrennt vom Hausmüll als Elektroschrott dem Recycling zugeführt werden muss . Wo Sie die nächstgelegene kostenlose Annah-

mestelle finden, sagt Ihnen Ihre kommunale Verwaltung .

Warnung! Augenschutz und LEDs:

Blicken Sie nicht aus geringer Entfernung direkt in eine LED, denn ein direkter Blick kann Netzhautschäden verursachen! Dies gilt besonders für helle LEDs im klaren Gehäuse sowie in besonderem Maße

für Power-LEDs . Bei weißen, blauen, violetten und ultravioletten LEDs gibt die scheinbare Helligkeit einen falschen Eindruck von der tatsächlichen Gefahr für Ihre Augen . Besondere Vorsicht ist bei der

Verwendung von Sammellinsen geboten . Betreiben Sie die LEDs so, wie in der Anleitung vorgesehen, nicht aber mit größeren Strömen .

© 2017 Franzis Verlag GmbH, Richard-Reitzner-Allee 2, 85540 Haar

Alle Rechte vorbehalten, auch die der fotomechanischen Wiedergabe und der Speicherung in elektronischen Medien . Das Erstellen und Verbreiten von Kopien auf Papier, auf Datenträgern oder im Inter-

net, insbesondere als PDF, ist nur mit ausdrücklicher Genehmigung des Verlags gestattet und wird widrigenfalls strafrechtlich verfolgt .

Die meisten Produktbezeichnungen von Hard- und Software sowie Firmennamen und Firmenlogos, die in diesem Werk genannt werden, sind in der Regel gleichzeitig auch eingetragene Warenzeichen

und sollten als solche betrachtet werden . Der Verlag folgt bei den Produktbezeichnungen im Wesentlichen den Schreibweisen der Hersteller .

Bibliografische Information der Deutschen Bibliothek

Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte Daten sind im Internet über http://dnb .ddb .de abrufbar .

Alle in diesem Buch vorgestellten Schaltungen und Programme wurden mit der größtmöglichen Sorgfalt entwickelt, geprüft und getestet . Trotzdem können Fehler im Buch und in der Software nicht

vollständig ausgeschlossen werden . Verlag und Autor haften in Fällen des Vorsatzes oder der groben Fahrlässigkeit nach den gesetzlichen Bestimmungen . Im Übrigen haften Verlag und Autor nur nach

dem Produkthaftungsgesetz wegen der Verletzung des Lebens, des Körpers oder der Gesundheit oder wegen der schuldhaften Verletzung wesentlicher Vertragspflichten . Der Schadensersatzanspruch für

die Verletzung wesentlicher Vertragspflichten ist auf den vertragstypischen, vorhersehbaren Schaden begrenzt, soweit nicht ein Fall der zwingenden Haftung nach dem Produkthaftungsgesetz gegeben ist .

Vorsichtsmaßnahmen Auf keinen Fall irgendwelche GPIO-Pins miteinander verbinden und abwarten, was passiert . Nicht alle GPIO-Pins lassen sich frei programmieren . Einige 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 Raspberry Pi komplett zerstören . Verbin-det man über einen Schalter oder eine LED zwei Pins miteinander, muss immer ein Schutzwiderstand dazwischengeschaltet werden . Für Logiksignale immer Pin 1 verwenden, der +3,3 V liefert und bis 50 mA belastet werden kann . Pin 6 ist die Masseleitung für Logiksignale . Pin 2 liefert +5 V zur Stromversorgung externer Hardware . Hier kann so viel Strom entnommen werden, wie das USB-Netzteil des Rasp-berry Pi liefert . Dieser Pin darf aber nicht mit einem GPIO-Eingang verbunden werden .

Die wichtigsten Bauteile kurz...

Documents

Transcript of Die wichtigsten Bauteile kurz...