CODING WORLD RASP JP SEN AKT Instructions [de]

Für einige Sensoren müsst ihr SPI an eurem Raspberry Pi aktivieren. SPI ist
ein Komunkitionsprotokoll mit dem Daten von einem Gerät oder Sensor an
ein andere Gerät wie dem Raspberry Pi gesendet werden können. Damit der
Pi nicht zu lange beim Laden braucht ist dieses aber nicht Standardmäßig
dabei. Wir können es aber einfach beim Raspberry Pi Aktivieren. Dazu
müsst ihr den Pi starten und raspi config über das Terminal öffnen.

Für die Folgende Punkte könnt ihr einfach den Bildern folgen. Ihr können
euch mit den Pfeiltasten bewegen und mit der Enter Taste die einzelnen
Menü Punkte bestätigen.

$ sudo raspi-config

1

Bash

→ cw42.de//1

Sensor Kit

Jetzt mit Finish startet sich euer Pi neu. SPI sollte dann konfiguriert sein. Mit
dem folgenden Befehl könnt ihr das sonst auch noch mal nachprüfen:

$ lsmod | grep spi_

1

Bash

→ cw42.de//2

Sensor Kit

Es sollte jetzt bei euch etwas angezeigt werden was mit spi_ anfängt.

Python 2 Bibliothek Installieren

Damit wir jetzt auch vernünftig mit SPI Verbindungen arbeiten können gibt
es noch eine Python Bilbiothek die wir installieren:

SPI für den RFID Reader RC522 und den
Raspberry Pi aktivieren

Teilweise kann es unter Raspbian in der Version "jessie" zu Problem mit der
der SPI Komunikation kommen weil einige Module im Kernel nicht richtig
konfiguiert wurden. Mittlerweile gibt es eine neue Kernel Vision diese musst
du aber erst installieren. Dafür kannst du einfach den folgenden Schritten
folgen:

1. Updates Pakete und Paketquellen

1. Kernel Update

1. SPI Aktivieren (wie im ersten Teil beschrieben)

$ sudo apt-get install python2.7-dev

1

$ git clone https://github.com/Gadgetoid/py-spidev

1

$ cd py-spidev

1

$ sudo python setup.py install

1

$ sudo apt-get update && sudo apt-get upgrade

1

$ sudo rpi-update

1

Bash

Bash

Bash

Bash

Bash

Bash

→ cw42.de//3

Sensor Kit

sudo raspi-config

2. Neustarten

1. Config Text Verändern

Folgende Zeile hinzufügen:

1. Neustarten

1. Kontrollieren ob das SPI aktiviert ist

gpio readall

In der Ausgabe sollte folgendes zu finden sein: 24 | 1 | ALT0 | CE0 |

10 | 8 Wichtig ist das ALT0 angezeigt wird und nicht In oder OUT .

Sollte letzteres der Fall sein müsst ihr die Schritte nochmal wiederhohlen weil
es ein Fehler gab.

Jetzt sollte der Pi fertig konfiguriert sein!

MCP3025208 Analoge Werte am
Raspberry Pi Messen

Mit dem Raspberry Pi haben wir ein mächtigen Computer und können mit
den GPIO Pins einfach auf die Umwelt zugreifen und dort Daten lesen. Wir

$ sudo reboot

1

$ sudo nano /boot/config.txt

1

dtoverlay=spi0-hw-cs

1

$ sudo reboot

1

Bash

Bash

Bash

→ cw42.de//4

Sensor Kit

haben aber ein Problem, nämlich dass wir nur digitale Daten lesen können.
Digitale Daten sind dabei nur eine 0 oder 1. Heißt, wenn wir mit Sensoren
arbeiten, einen hohen oder einen niedrigen Strom haben. Ein Beispiel ist
dabei ein Taster. Wenn Strom fließt, messen wir eine 1 und wenn kein Strom
fließt, messen wir eine 0. Andere Sensoren übermitteln aber analoge Werte.
Diese befinden sich zwischen 0 und 1. Um diese auszulesen, wird ein ADC
gebraucht. Ein Analog zu Digital Konverter. Mit dem MCP3008 haben wir
genau so ein Gerät. Über SPI können wir es an den Raspberry Pi
anschließen und haben dann die Möglichkeit bis zu acht analoge
Anschlüsse auszulesen.

→ cw42.de//5

Sensor Kit

Die untere Seite erkennst du an der halbrunden Anordnung. CH0 - CH7 sind
die analogen Eingänge, die wir benutzen werden.

VDD: Spannung, die der MCP3008 für den Betrieb braucht
V_REF: Ist die höchste Spannung, welche die analogen Anschlüsse
bekommen. Diese werden gebraucht, um richtige Werte zu messen
AGND: Masse für die analogen Anschlüsse
CLK: Abkürzung für Clock (Uhr). Koordiniert die Geschwindigkeitszeit
D_OUT: Ausgang zur SPI Schnittstelle am Raspberry Pi
D_IN: Eingang zur SPI Schnittstelle am Raspberry Pi
CS/SHDN: Abkürzung für Cable Select. Mit dem SPI lassen sich
verschiedene Geräte gleichzeitig ansteuern
DGND: Masse für den MCP3008

Wie gesagt brauchen wir SPI, wenn du das noch nicht aktiviert hast, gibt es
hier eine Anleitung dafür:

SPI Aktivieren

Nachdem wir die Software Grundlagen hinter uns haben, geht es darum, die
Hardware richtig anzuschließen.

Die halbrunde Nase zeigt in diesem Fall nach unten. Stecke den MCP3008
am besten über den mittleren Kanal des Breadboards, also zwischen e und
f.

→ cw42.de//6

Sensor Kit

Anschlüsse Raspberry Pi Anschlüsse MCP3008

GND DGND

GPIO 8N CS/SHD

GPIO 10 D_IN

GPIO 9 D_OUT

GPIO 11 CLK

GND AGND

V_REF 3,3V

VDD 3,3V

$ nano mcp.py

1

#!/usr/bin/python

import spidev
import time
import os
import RPi.GPIO as gpio

# SPI Verbindung herstellen

spi = spidev.SpiDev()
spi.open(0,0)

# Liest Daten vom MCP3008

def analogEingang(channel):

adc = spi.xfer2([1,(8+channel)<<4,0])

1
2
3
4
5
6
7
8

9
10
11
12
13

Bash

Python

→ cw42.de//7

Sensor Kit

Jetzt musst du nur noch das Programm ausführen

Wichtig ist, dass du das Programm mit Rootrechten ausführst und daran
denkst, dass es sich dabei um ein Python2 Programm handelt. Wenn jetzt
keine Werte ausgegeben werden, sollte dich das nicht wundern, denn du
hast ja auch noch nichts angeschlossen, was sinnvolle Werte ausgeben
könnte ;)

Also schnell weiter zum ersten Sensor!

Hier werden wir die richtige Zeitzone für dich und deinen Pi einstellen.

Die Momentan eingestellte Uhrzeit kannst du mit

Dort wählst du unter 4 "Internationalisation Options" aus.

data = ((adc[1]&3) << 8) + adc[2]
return data

while True:

print("0: "+str(analogEingang(0)))
print("1: "+str(analogEingang(1)))
print("2: "+str(analogEingang(2)))
print("3: "+str(analogEingang(3)))
print("4: "+str(analogEingang(4)))
print("5: "+str(analogEingang(5)))
print("6: "+str(analogEingang(6)))
time.sleep(0.2)

14
15
16
17
18
19
20
21
22
23
24
25

$ sudo python mcp.py

1

$ date
``` herausfinden.

Wenn du noch im Konfigurationsmenü bist, gib einfach folgenden Terminal Befehl ein:
```bash

sudo raspi-config

1

2

3

4

5

6

Bash

Bash

→ cw42.de//8

Sensor Kit

Dann unter unter "I3 Change Timezone"

Da wir uns in Europa befinden wählst du dann "Europe" aus. (Wenn du eine
andere Zeit einstellen möchtest, musst ab jetzt auch andere
Kontinennte/Städe auswählen)

In unseren Falle kommt danach die Auswahl von Berlin für die Deutsche
Zeitzone. Das musst du dann nur noch mit "OK" Bestätigen.

→ cw42.de//9

Sensor Kit

Wenn du dann auf Finish gehst, wird dir im Terminal unter "Local Time ist
now" die aktualisierte Lokale Zeit angezeigt.

So kannst du ganz einfach die Lokale Zeit auf deinem Raspberry Pi
einstellen und beliebig verändern!

→ cw42.de//10

Sensor Kit

Mit dem Joystick kannst du einfach verschiedene Positionen messen. Es gibt
dabei 3 verschiedene Werte die Interessant sind mit VRx und VRy kannst
messen wo sich der Joystick befindet.

Zum Anschließen, für dieses Projekt brauchst du einen angeschlossenen

MCP3008.

Anschlüsse MCP3008/Pi Anschlüsse Joystick

GND GND

→ cw42.de//11

Sensor Kit

3,3V VCC / 5V

VRy CH0

VRx CH1

SW GPIO 16

Wenn beide werte ungefähr bei 500 sind befindet sich der Joystick in der

#!/usr/bin/python

import spidev
import time
import os
import RPi.GPIO as gpio

# SPI Verbindung herstellen

spi = spidev.SpiDev()
spi.open(0,0)

btnSW = 16
gpio.setmode(gpio.BCM)
gpio.setup(btnSW, gpio.IN,pull_up_down=gpio.PUD_UP)

# Liest Daten vom MCP3008

def analogEingang(channel):

adc = spi.xfer2([1,(8+channel)<<4,0])
data = ((adc[1]&3) << 8) + adc[2]
return data

while True:

print("VRy: "+str(analogEingang(0)))
print("VRx: "+str(analogEingang(1)))
print("SW: "+str(gpio.input(btnSW)))
time.sleep(0.2)

1

2

3

4

5

6

7

8

9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Python

→ cw42.de//12

Sensor Kit

Ausgangsposition ganz Oben. Wenn du den Joystick zur Seite Runterdrück
wo sich die Kabel befinden (Seite 1) dann sollte der Wert von VRy ungefähr
0 sein. Wenn der Joystick sich auf der Seite 3 befinden liegt der Wert bei ca.

1024. Das Gleiche ist auch mit den Werten bei VRx. Wenn der Joystick auf
der Seite von 2 ist liegt der Wert bei Quaise 0 und bei Seite 4 bei ca. 1024.
Wenn der Joystick z.B. in die Ecke runter gedrückt wer zwischen Seite und 2
sollte beide Werte ca. 0 liegen. Dadurch lässt sich messen so sich der
Joystick befindet. Mit SW lässt sich messen ob der Joystick runtergedrückt
wurde. Da es sich dabei um einen Taster handelt können wir den ganz
Normal an einem GPIO Pin anschließen.

Mit diesem Sensor können wir herausfinden ob es bei uns in der Nähe ein
Feuer gibt. Dabei kann das Gerät nicht direkt ein Feuer messen sondern nur
ob es so ein Objekt gibt welches Licht in diesem Bereich abgibt. Es gibt
dabei einen Analogen Pin und einen Digitalen Pin am Sensor. Der Analoge
gibt an wie hoch die gemessene Intensität ist und der Digitale Pin springt ab
einem bestimmt wert auf 1 Sagt damit das ein Feuer gemessen wurde. Wie
fein gemessen wird kann an dem Potentiometer beeinflusst werden welches
sich am Blauen Kasten auf den Sensor befindet.

Achte immer auf die Sicherheit wenn du mit Feuer arbeitest. Du solltest dich
nicht nur auf den Sensor verlassen in Brandschutz fällen

Zum Anschließen, für dieses Projekt brauchst du einen angeschlossenen

MCP3008.

Anschlüsse MCP3008/Pi Anschlüsse Joystick

→ cw42.de//13

Sensor Kit

GND GND

3,3V +

AO CH0

DO GPIO 16

Hierbei handelt es sich nicht um einen Sensor sondern um einen Aktor. Was
bedeutet wir messen keine Daten sondern können die Umwelt verändern. Da
sich Nr. 3 und Nr. 9 so sehr ähneln behandeln wir diese zusammen. Der

#!/usr/bin/python

import spidev
import time
import os
import RPi.GPIO as gpio

# SPI Verbindung herstellen

spi = spidev.SpiDev()
spi.open(0,0)

btnAO = 16
gpio.setmode(gpio.BCM)
gpio.setup(btnAO, gpio.IN,pull_up_down=gpio.PUD_UP)

# Liest Daten vom MCP3008

def analogEingang(channel):

adc = spi.xfer2([1,(8+channel)<<4,0])
data = ((adc[1]&3) << 8) + adc[2]
return data

while True:

print("DO: "+str(analogEingang(0)))
print("AO: "+str(gpio.input(btnAO)))
time.sleep(0.2)

1

2

3

4

5

6

7

8

9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Python

→ cw42.de//14

Sensor Kit

Aufbau ist simpel. Mit den 3 Pins die mit r,g und b beschriftet sind kann eine
Farbe zum leuchten gebracht werden. die SMD RGB LED (Nr. 9)
unterscheidet sich vor allem durch die Größe und von der Pinnumerierung
zur normalen RGB LED (Nr. 3) die mehr Platz beansprucht.

Diese kann auch einfach an den Raspberry Pi angeschlossen

| Anschlüsse PI | Anschlüsse RGB LED | | GPIO 14 | rot | | GPIO 15 | grün | |
GPIO 18 | blau | | GND | GND / - |

import RPi.GPIO as gpio
import time

gpio.setmode(gpio.BCM)

red = 14
green = 15
blue = 18

gpio.setup(red, gpio.OUT)

1

2

3

4

5

6

7

8

9
10

Python

→ cw42.de//15

Sensor Kit

Ein Relay ist ein Schaltelement mit dem sich der Stromfluss kontrollieren
lässt. Im Inneren befindet sich ein Elektromagnet der intern einen Schalter
umlegen kann und dadurch den Stromfluss Konzentrieren kann. Dadurch
können deutlich höhere Spannungen als bei einem Transistor geschaltet
werden.

Bitte arbeite nur mit hohen Spannungen wenn du dich damit auskennst!

Auf der einen Seite gibt es die Kontroll Pins. Mit diesen Pins kannst du das
Relay schalten. Auf der gegenüberliegenden Seite gibt es 3

gpio.setup(green, gpio.OUT)
gpio.setup(blue, gpio.OUT)

while True: # Diese Schleife läuft für immer

gpio.output(red, gpio.HIGH) # rot an
time.sleep(0.5)
gpio.output(red, gpio.LOW) # rot aus

gpio.output(green, gpio.HIGH) # grün an
time.sleep(0.5)
gpio.output(green, gpio.LOW) # grün aus

gpio.output(blue, gpio.HIGH) # blau an
time.sleep(0.5)
gpio.output(blue, gpio.LOW) # blau aus

11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

→ cw42.de//16

Sensor Kit

Schraubklemmen. Dort kann der Schaltstromkreis angeschlossen werden.
Die Schraubklemmen können mit einem Schlitz Schraubenzieher fixiert und
gelöst werden. Mit diesen Schraubklemmen kannst du Kabelenden oder
Jumpel Kabel fixieren.

Anschlüsse am Pi Anschlüsse Relay

5V + Relay

GND - Relay

GPIO 14 S Relay

3,3V COM Relay

NC Relay -> Langes Bein LED

GND Kurzes Bein LED

import RPi.GPIO as gpio
import time

gpio.setmode(gpio.BCM)

relay = 14

gpio.setup(red, gpio.OUT)

while True: # Diese Schleife läuft für immer

gpio.output(relay, gpio.HIGH) # relay geschaltet
time.sleep(2)

1

2

3

4

5

6

7

8

9
10
11
12

Python

→ cw42.de//17

Sensor Kit

Wenn du das Programm jetzt startet solltest du ein Klicken vom Relay hören
wenn es sich schaltet. Dann sollte die LED immer für 2 Sekunden lang
aufleuchten. Wenn das Relay geschaltet wird, also eine Spannung am S Pin
des Relays anliegt, gibt es eine Verbindung zwischem dem COM und NO
verbindung der Schraubklemme. Am COM haben wir 3,3V vom Raspberry Pi
anschlossen und von NO gibt es eine Verbindung zur LED. Der Stromfluss
der LED wird dadurch, durch das LED kontrolliert.

Das ist natürlich nur eine Beispiel Schaltung, natürlich kann bei einem Relay
auch eine externe Stromquelle benutzt werden.

Mit dem Linearen Hall Sensor können wir messen ob sich ein Magnet in der
nähe Befindet. Wie genau der Hall Sensor und der Hall Effeckt könnt ihr hier
nachlesen, das ist uns dann doch etwas zu Physisch. Trotzdem können wir
die Hall Sonde für tolle Sachen nutzen und das nicht nur um ein Magnetfeld
zu messen. Da wir messen können ob ein Magnet in der nähe ist bzw. wie
weit ein Magnet entfernt ist lässt sich damit z.B. Messen ob ein Fenster oder
eine Tür geöffnet oder geschlossen ist. Alles was es dafür noch braucht ist
ein Magnet auf der Gegenseite.

Zum Anschließen, für dieses Projekt brauchst du einen angeschlossenen

MCP3008.

Pi/MCP3008 Sensor

gpio.output(relay, gpio.LOW) # relay geschaltet
time.sleep(1)

13
14

→ cw42.de//18

Sensor Kit

CH0 AO

GND Pi G

+ Pi 5V

GPIO 16 DO

Wenn ihr einen Magnet nun in die nähe Bewegt, sollte sich die Messwerte
verändern. Dazu sollte die LED auf dem Sensor aufblinken.

import spidev
import time
import os
import RPi.GPIO as gpio

digital = 16

gpio.setmode(gpio.BCM)
gpio.setup(digital, gpio.IN)

# SPI Verbindung herstellen

spi = spidev.SpiDev()
spi.open(0,0)

# Liest Daten vom MCP3008

def analogEingang(channel):

adc = spi.xfer2([1,(8+channel)<<4,0])
data = ((adc[1]&3) << 8) + adc[2]
return data

while True:

print("AO: "+str(analogEingang(0)))
print("DO: "+str(gpio.input(digital)))
time.sleep(0.2)

1

2

3

4

5

6

7

8

9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Python

→ cw42.de//19

Sensor Kit

Bei dem 18B20 Modul handelt es sich um einen digitalen Temperatur
Sensor. Wir haben schon eine sehr ausführliche Anleitung für das Arbeiten
mit dem selben Sensor nur ohne Modul. Deswegen gibt es hier nur einmal
anschließen und Aufbau des Sensors und unten dann ein Link zum
Programmcode und zur Programmierung.

![18B20 Modul ])http://image.codingworld.eu/storage/980/show)

Anschlüsse am Pi Anschlüsse am Sensor

GND GND

3,3V 3,3 V

GPIO4 Data

Programmcode Temperatur Sensor

Der Berührungssensor kann das was drin steht, eine Berührung messen.
Dafür musst du einfach nur mit deinem Finger den Sensor Kopf berühren.

→ cw42.de//20

Sensor Kit

Anschlüsse am Raspberry Pi Sensor

GND G

3,3V +

GPIO 14 DO

#!/usr/bin/python

import RPi.GPIO as gpio
import time

touchSensor = 14
gpio.setmode(gpio.BCM)
gpio.setup(touchSensor, gpio.IN)

while True:

if(gpio.input(touchSensor) == 1):
print("Touch")
time.sleep(0.2)

1

2

3

4

5

6

7

8

9
10
11
12

Python

→ cw42.de//21

Sensor Kit

Der Bewegungssensor

Der PIR ist ein Sensor, der Infrarotstrahlung erfassen und somit
Bewegungen erkennen kann. Das Tolle daran ist, dass dieser Sensor so
auch Bewegungen registrieren kann, wenn gar kein Licht vorhanden ist.
Infrarotstrahlung ist nämlich nichts anderes als Wärmestrahlung. Da die
meisten Lebewesen irgendwie Wärme ausstrahlen, können wir mit diesem
Sensor prüfen, ob verdeckt operierende Geheimagenten-Ninjas in unsere
Umgebung spionieren.

Bevor wir den Sensor anschließen und programmieren, wäre es sehr hilfreich
zu wissen, wie dieser überhaupt funktioniert. Oder glaubst du, da würden
kleine Wesen drin sitzen, die 24/7 nach Bewegung Ausschau halten und
das im Zweifelsfall an den Raspberry Pi mitteilen? Nein, das gibt es, zum
Glück, nicht! Der Sensor misst wie viele Infrarotstrahlen aus den
unterschiedlichen Gegenden zu ihm kommen. Das kann der Sensor
messen, da diese den Stromfluss in dem Sensor beeinflussen. Wir müssen
uns zum Glück nicht um das Auslesen dieser Messungen kümmern. Der
Sensor macht das von alleine. Aber wie wird jetzt die Bewegung gemessen?

→ cw42.de//22

Sensor Kit

Bewegung (von Menschen) verändert die Menge der Infrarotstrahlen, die der
Sensor misst. Das heißt, wenn sich von dem einen auf den anderen Moment
etwas ändert, hat der Sensor eine Bewegung erkannt und teilt das mit.
Gleichzeitig ist der Sensor aber schon so schlau, das er kleine
Veränderungen im Zimmer, zum Beispiel einen langsamen Anstieg der
Temperatur, einfach ignoriert, da das sehr vermutlich keine bewegenden
Menschen sind. Aber wie bekommen wir jetzt konkret mit, wenn der Sensor
gemessen hat, dass sich etwas bewegt? Über den Data Pin kann der Sensor
nur das Signal 'keinen Strom' oder 'Strom' senden. Eine Bewegung wird
dann erkannt, wenn nach 'keinen Strom', Strom durch den Sensor fließt.
Also auf 0 eine 1 bei der Messung folgt.

Anschließen

Anschlüsse am Pi Anschlüsse am Sensor

5V VCC

GPIO 4 Data

GND GND

$ nano pir.py

1

import RPi.GPIO as gpio

1

Bash

Python

→ cw42.de//23

Sensor Kit

Schritt für Schritt

In den ersten beiden Zeilen importieren wir die benötigten Bibliotheken.

In Zeile 5 speichern wir in der Variablen pir ab, dass wir den GPIO Pin 4 mit

import time

gpio.setmode(gpio.BCM)
pir = 4
gpio.setup(pir,gpio.IN)

jetzigerStatus = 0
vorherigerStatus = 0

try:

while gpio.input(pir)==1:
jetzigerStatus = 0
print("Bereit zum messen")
while True :
jetzigerStatus = gpio.input(pir)
if jetzigerStatus == 1 and vorherigerStatus == 0:
print("Es gibt Bewegung")
vorherigerStatus = 1
elif jetzigerStatus == 0 and vorherigerStatus == 1
print("Bereit zum Messen")
vorherigerStatus = 0
time.sleep(0.01)

except KeyboardInterrupt:

print("Beendet")
gpio.cleanup()

2

3

4

5

6

7

8

9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

$ sudo python3 pir.py

1

Bash

→ cw42.de//24

Sensor Kit

dem Data Anschluss am Sensor verbunden haben.

In Zeile 6 legen wir fest, dass wir am GPIO Pin 4 den Input messen wollen
und keinen Output geben werden.

Bevor wir mit dem richtigen Auslesen des Sensors anfangen können,
müssen wir erst noch zwei Variablen definieren und beide auf 0 setzen.
Einmal jetzigerStatus und vorherigerStatus. Wie oben schon erklärt, wissen
wir nur, ob sich etwas bewegt hat, wenn wir zuerst keinen Strom (0) und
dann Strom (1) vom Sensor messen.

In Zeile 11 kommt auch wieder try vor. Es wird also alles ausgeführt, was
eingerückt ist, solange nicht die except Bedingungen in Zeile 25 eingetreten
ist. Wenn das der Fall ist, wird alles ausgeführt, was in Zeile 26 und 27 steht.
Dann geben wir nur eine kleine Benachrichtigung für den User aus, dass das
Programm beendet wurde und räumen dann noch einmal die GPIO
Belegungen auf.

In Zeile 12 lesen wir solange den Input vom Sensor, bis wir Strom (1)
messen. Dadurch wissen wir, dass der Sensor bereit ist zum Messen und
legen den jetzigerStatus noch einmal auf 0.

Nach der Nachricht an den Benutzer in Zeile 14, dass wir jetzt wirklich
messen, machen wir das auch mit der While-Schleife in Zeile 15. Diese ist
so eingestellt, dass sie solange läuft, bis das Programm beendet wird. In
Zeile 16 wird der Variablen jetzigerStatus der Wert zugewiesen, den wir vom
Sensor mit gpio.input() messen. Das kann wieder nur eine 1 oder eine 0
sein.
In Zeile 17 startet die if Abfrage. Wenn die Variable jetzigerStatus 1 ist und
die andere Variable vorherigerStatus 0, wissen wir, dass es eine Bewegung
gab. Momentan geben wir einfach nur in Zeile 18 eine Nachricht aus. Hier
könnten wir aber zum Beispiel auch eine Funktion ausführen. Dann ist
wichtig, dass wir die Variable vorherigerStatus auf 1 setzen, damit wir
wissen, dass wir etwas gemessen haben und jetzt wieder darauf warten
müssen, dass der Sensor sich wieder "erholt". Das ist der Fall, wenn die
Bedingung in Zeile 20 erfüllt ist. Dann muss natürlich die Variable
vorherigerStatus gleich 0 sein. Nach der if Abfrage lassen wir das ganze
Programm für zehn Millisekunden pausieren, denn selbst wenn wir den
Sensor schneller abfragen, werden sich die Werte nicht verbessern.

→ cw42.de//25

Sensor Kit

Du bist dran: Jetzt kannst du messen, wenn sich Menschen im Raum
bewegen! Wie wär's mit einer Alarmanlage oder einem Selfi-Bewegungs­Automaten?

Bei dem SW-420 handelt es sich um einen Modul mit dem sich Bewegung
messen kann. Im inneren befinden sich ein kleiner Metallball der eine Interne
Schaltung verbinden kann so das Strom fließt. Das heißt wir können 2
Zustände messen. Entweder ist der Metall-Ball in der richten Position oder er
ist es nicht.

Anschlüsse Pi Anschlüsse Sensor

GPIO 14 Langes Bein SW-420

GNd Kurzes Bein SW-420

import RPi.GPIO as gpio
import time

digital = 14

gpio.setmode(gpio.BCM)
gpio.setup(digital, gpio.IN)

try:

1

2

3

4

5

6

7

8

9

Python

→ cw42.de//26

Sensor Kit

Ein Beispiel

Anschlüss Pi Anschlüsse Sensoren/Aktoren

GPIO 14 Langes Bein SW-420

GND Kurzes Bein

GPIO 15 B - RGB LED

GND GND - RGB LED

while True:
print(gpio.input(digital) == 1):
time.sleep(0.2)

except KeyboardInterrupt:

gpio.cleanup()

10
11
12
13
14

import RPi.GPIO as gpio
import time

digital = 14
led = 15

gpio.setmode(gpio.BCM)
gpio.setup(digital, gpio.IN)

1

2

3

4

5

6

7

8

Python

→ cw42.de//27

Sensor Kit

Mit diesem Sensor kannst du einfach die Luftfeuchtigkeit und die
Lufttemperatur messen. Dabei ist das besondere das der Sensor einen
besonderen Komunikations Pin hat. Dieser wird teilweise Signal oder Data
genannt

gpio.setup(led, gpio.OUT)

led = gpio.PWM(led, 100)

bright = 0

led.start(bright)

try:

while True:
if(gpio.input(digital) == 1):
if(bright < 95):
bright += 5
else:
if(bright > 0):
bright -= 5
led.ChangeDutyCycle(bright)
print("DO: "+str(bright))
time.sleep(0.2)

except KeyboardInterrupt:

led.stop()
gpio.cleanup()

9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

→ cw42.de//28

Sensor Kit

Wir haben für den Sensor ohne das Modul schone eine Anleitung. Beim
Anschließen könnt ihr euch die Wiederstände sparen, den diese sind schon
auf dem Modul drauf. Und der Signal Pin wird im nachfolgenden Data Pin
genannt. Der Rest bleibt aber der Gleiche.

Installation Anleitung

Der Kugelschalter ist ähnlich aufgebaut wie die SW-420. Im Inneren befindet
sich eine Kugel die bei der richtigen Position einen Stromkreis schließt.
Wenn das der Fall ist, kann Strom fließen, welchen wir wieder messen
können. So lässt sich z.B. sagen in welcher Position sich der Sensor gerade
befindet.

Anschlüsse Raspberr Pi Anschlüsse Sensor

GND GND

3,3V +

GPIO 14 Signal

Wenn der Sensor Senkrecht auf dem Tisch steht sollte bei euch eine 1
kommen. Wenn ihr den Sensor Umdreht eine 0 . Heißt nur wenn der Sensor

#!/usr/bin/python

import RPi.GPIO as gpio
import time

sensor = 14
gpio.setmode(gpio.BCM)
gpio.setup(sensor, gpio.IN)

while True:

print(gpio.input(sensor))
time.sleep(0.2)

1

2

3

4

5

6

7

8

9
10
11

Python

→ cw42.de//29

Sensor Kit

mit den Anschlüssen nach unten steht kann Strom fließen.

Mit dem Photoresistor habt ihr eine einfache Möglichkeit festzustellen wie
Hell es gerade ist. Dabei gibt der Sensor keine Helligkeit im Lux Format an.
Durch das messen und anpassen lässt sich so feststellen wie Hell es im
Verhältnis ist.

Zum Anschließen, für dieses Projekt brauchst du einen angeschlossenen

MCP3008.

![http://image.codingworld.eu/storage/1015/show]

Anschlüsse Pi Anschlüsse Sensor

CH0 Signal

3,3V +

GND GND

import spidev
import time
import os
import RPi.GPIO as gpio

# SPI Verbindung herstellen

1

2

3

4

5

6

Python

→ cw42.de//30

Sensor Kit

Bei normaler Zimmer Helligkeit kommen wir ungefähr auf einen Wert von
400-600. Bei direkten Anleuchten mit einer Taschenlampe auf ca. 20 und
beim Kompletten Verdunkeln (mit einem Daumen) auf ca. 850. Diese Werte
solltet ihr auf eure Begebenheiten anpassen.

Mit dem Photointerrupter können wir wieder die Helligkeitmessen.

Anschlüsse Raspberry Anschlüsse Sensor

GND -

5V +

CH1 Signal

spi = spidev.SpiDev()
spi.open(0,0)

# Liest Daten vom MCP3008

def analogEingang(channel):

adc = spi.xfer2([1,(8+channel)<<4,0])
data = ((adc[1]&3) << 8) + adc[2]
return data

while True:

print("Helligkeit: "+str(analogEingang(0)))
time.sleep(0.2)

7

8

9
10
11
12
13
14
15
16
17
18

import spidev
import time
import os
import RPi.GPIO as gpio

# SPI Verbindung herstellen

spi = spidev.SpiDev()
spi.open(0,0)

1

2

3

4

5

6

7

8

Python

→ cw42.de//31

Sensor Kit

Bei dem Reedschalter handelt es sich um einen kleiner Schalter Modul.
Wenn man sich den Sensor ansieht gibt es in dem Glasrörchen immer zwei
Metallplatten die sich sich Fasst berühren. Im Normalen zustand berühren
sich diese beiden Plättchen nicht und es fließt kein Strom. Mit einem
Magneten lassen sich aber diese beiden Plättchen berühren. So lassen sich
Beispielweise Magnetische Felder erkennen.

| Anschlüsse Pi | Anschlüsse Sensor | | GND | - GND | | 3,3V | + | | GPIO 14 |
Signal / S |

Bei einigen Sensoren wird im Normalzustand eine 0 und bei anderen 1 eine
ausgegeben. Das kannst du einfach durch testen herausfinden.

Mit dem Passiv Buzzer können einfach Töne erzeugt werden. Die erzeugten

# Liest Daten vom MCP3008

def analogEingang(channel):

adc = spi.xfer2([1,(8+channel)<<4,0])
data = ((adc[1]&3) << 8) + adc[2]
return data

while True:

print("0: "+str(analogEingang(0)))
time.sleep(1)

9
10
11
12
13
14
15
16
17
18

#!/usr/bin/python

import RPi.GPIO as gpio
import time

reedSensor = 14
gpio.setmode(gpio.BCM)
gpio.setup(reedSensor, gpio.IN)

while True:

print(gpio.input(reedSensor))
time.sleep(0.2)

1

2

3

4

5

6

7

8

9
10
11

Python

→ cw42.de//32

Sensor Kit

Töne sind aber weitem nicht so vielseitig wie bei einem normalen
lautsprecher, dafür lassen sich diese einfach erzeugen.

| Anschlüsse Pi | Anschlüsse Buzzer | | GND | GND - | | GPIO 14 | Signal |

#!/usr/bin/python

import RPi.GPIO as gpio
import time

buzz = 14
gpio.setmode(gpio.BCM)
gpio.setup(buzz, gpio.OUT)

def sound():

gpio.output(buzz, gpio.HIGH)
time.sleep(0.001)
gpio.output(buzz, gpio.LOW)
time.sleep(0.001)

while True:

print(60)
for i in range(60):
sound()
time.sleep(0.5)
print(80)
for i in range(80):
sound()
time.sleep(0.5)
print(100)
for i in range(100):
sound()
time.sleep(0.5)
print(120)
for i in range(120):
sound()
time.sleep(1)

1

2

3

4

5

6

7

8

9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Python

→ cw42.de//33

Sensor Kit

Klopfsensor:

Anschlüsse Pi Anschlüsse Sensor

GND -

3,3V +

GPIO14 S

import RPi.GPIO as gpio
import time

sensor = 14
previous_state = 0

gpio.setmode(gpio.BCM)
gpio.setup(sensor, gpio.IN)

try:

while True:
if(gpio.input(sensor) == 0 ):
print("bewegung")

1

2

3

4

5

6

7

8

9
10
11
12
13

Python

→ cw42.de//34

Sensor Kit

except KeyboardInterrupt:

gpio.cleanup()

14
15

→ cw42.de//35

Sensor Kit