Joy-it SENKit X40 User guide [de]

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0

Sehr geehrter Kunde,
vielen Dank, dass Sie sich für unser Produkt entschieden haben.
Dieses hochwertige Sensor Kit wurde speziell für die gängigsten Open-Source Plattformen in

Deutschland entwickelt. Es ist zu folgenden Einplatinen Computern kompatibel:
Raspberry Pi (alle Modelle), Arduino, Banana PI, Cubieboard, Cubietruck, Beaglebone, pcDuino

und vielen weiteren Mikrocontroller-Systemen (Atmega, MicroChip PIC, STM32 usw.).
Die folgende Anleitung beinhaltet nicht nur die technische Beschreibung der einzelnen Sensoren,

wie z.B. die Pin-Belegung oder den jeweils verwendeten Chipsatz, sondern gibt auch einen Ein­blick in die Funktionsweise der jeweiligen Sensormodule.

Um Sie bei Ihren eigenen Projekten zu unterstützen, haben wir im Zuge dieser Anleitung jeweils
ein Code-Beispiel für die meistgenutzten Systeme Raspberry Pi (geschrieben in Python) und
Arduino (geschrieben in C++) für jeden einzelnen Sensor bereitgestellt, um die Vorgehensweise
der Programmierung mit den Sensoren am leichtesten zu verdeutlichen. Sie finden diese direkt
als Code integriert in dieser Anleitung oder direkt unter den jeweiligen Beispiel als Download. Sie
finden zudem die immer aktuellste Fassung der Beispiele unter unserem SensorKit X40 Wiki:

http://sensorkit.joy-it.net/
Hierdurch können auch Programmieranfänger ganz leicht eigene Versuche, Projekte und Experi-

mente entwickeln und durchführen.
So haben Sie im Handumdrehen die Möglichkeit Ihren Herzschlag zu prüfen oder die Raumtem-

peratur und Luftfeuchtigkeit in Ihrer Umgebung zu messen.
Speziell für den Raspberry Pi liegen dem Set ein Analog-Digital Konverter [KY-053] und ein

Voltage Translator [KY-051] bei - durch diese werden zwei große Einschränkungen des
Raspberry Pi (kein ADC / 3,3V Spannungslevel), wenn es um Interaktion mit analogen Signalen
und Sensoren allgemein geht, beseitigt.

Sie können die Sensoren entweder fest verlöten oder auf ein Breadboard stecken, um an ver­schiedenen Schaltungen oder Experimenten zu arbeiten.

Wir wünschen Ihnen viel Freude mit dem Sensorkit X40

Ihr Joy-IT Team

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 2 von 227

Index

 Temperatur Sensor ModulKY-001

 Erschütterungs-Schalter ModulKY-002

 Hall Magnetfeld-Sensor ModulKY-003

 Taster-ModulKY-004

Index

Klicken Sie auf die Beschreibung des jeweiligen Sensors, um auf die entsprechende Unterseite zu gelangen

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 3 von 227

Index

 Infrarot Transmitter ModulKY-005

 Passives Piezo-Buzzer ModulKY-006

 RGB LED SMD ModulKY-009

 Lichtschranken-ModulKY-010

 2-Farben [Rot+Grün] 5mm LED ModulKY-011

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 4 von 227

Index

 Aktives Piezo-Buzzer ModulKY-012

 Temperatur-Sensor ModulKY-013

 Kombi-Sensor Temperatur+FeuchtigkeitKY-015

 RGB 5mm LED ModulKY-016

 Neigungsschalter ModulKY-017

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 5 von 227

Index

 Fotowiderstand ModulKY-018

 5V Relais ModulKY-019

 Neigungs-Schalter ModulKY-020

 Mini Magnet Reed ModulKY-021

 Infrarot Receiver ModulKY-022

 Joystick Modul (XY-Achsen)KY-023

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 6 von 227

Index

 Linear magnetic Hall SensorKY-024

 Reed ModulKY-025

 Flamen-Sensor ModulKY-026

 Magic Light Cup ModulKY-027

 Temperatur Sensor Modul (Thermistor)KY-028

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 7 von 227

Index

 2-Farben [Rot+Grün] 3mm LED ModulKY-029

 Klopf-Sensor ModulKY-031

 Hindernis Detektor ModulKY-032

 Tracking Sensor ModulKY-033

 7 Farben LED Flash-ModulKY-034

 Bihor Magnet Sensor ModulKY-035

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 8 von 227

Index

 Metall-Touchsensor ModulKY-036

 Mikrofon Sensor Modul [hohe Empfindlichkeit]KY-037

 Mikrofon Sound Sensor ModulKY-038

 Herzschlag Sensor ModulKY-039

 Kodierter Drehschalter (Rotary Encoder)KY-040

 UltraschallabstandssensorKY-050

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 9 von 227

Index

 Voltage Translator / Level ShifterKY-051

 Drucksensor / Temperatursensor [BMP180]KY-052

 Analog Digital ConverterKY-053

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 10 von 227

KY-001 Temperatur Sensor Modul

KY-001 Temperatur Sensor Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 2

5 One-Wire Konfiguration Raspberry Pi .................................................................................................................. 3

6 Codebeispiel Raspberry Pi ................................................................................................................................... 3

Bild

Technische Daten / Kurzbeschreibung

Chipsatz: DS18B20 | Kommunikationsprotokoll: 1-Wire

9- 12Bit genaue Temperaturmessung im Meßbereich von –55°C bis +125°C

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0  Seite 11 von 227

KY-001 Temperatur Sensor Modul

Pin-Belegung

Codebeispiel Arduino

Für das folgende Codebeispiel werden zwei zusätzliche Libraries benötigt:

- [OneWire Library] von | veröffentlicht unter der MIT LicensePaul Stoffregen

- [Dallas Temperature Control Library] von | veröffentlicht unter LGPLMiles Burton

Beide Libraries sind im Paket enthalten und müssen vor dem Start der Arduino IDE in den "library"-Ordner
kopiert werden.

Diesen finden Sie standardmäßig unter dem folgenden Pfad Ihrer Windows-Installation:

C:\Benutzer\[Benutzername]\Dokumente\Arduino\libraries

// Benötigte Libraries werden importiert
#include <DallasTemperature.h>
#include <OneWire.h>

// Hier wird der Eingangs-Pin deklariert, an dem das Sensor-Modul angeschlossen ist
#define KY001_Signal_PIN 4

// Libraries werden konfiguriert
OneWire oneWire(KY001_Signal_PIN);
DallasTemperature sensors(&oneWire);

void setup() {

// Initialisierung Serielle Ausgabe
Serial.begin(9600);
Serial.println("KY-001 Temperaturmessung");

// Sensor wird initialisiert
sensors.begin();

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 12 von 227

KY-001 Temperatur Sensor Modul

}

//Hauptprogrammschleife
void loop()
{
// Temperaturmessung wird gestartet...
sensors.requestTemperatures();
// ... und gemessene Temperatur ausgeben
Serial.print("Temperatur: ");
Serial.print(sensors.getTempCByIndex(0));
Serial.write(176); // UniCode-Angabe eines char-Symbols für das "°-Symbol"
Serial.println("C");

delay(1000); // 5s Pause bis zur nächsten Messung
}

Anschlussbelegung Arduino:

Sensor Signal = [Pin 4]

Sensor+V = [Pin 5V]

Sensor - = [Pin GND]

Beispielprogramm Download

KY-001-TemperaturSensor.zip

One-Wire Konfiguration Raspberry Pi

Damit der Raspberry Pi mit dem One-Wire Bus, mit der Sensor DS18B20 seine Messdaten digital sendet,
kommunizieren kann, muss dieser vorerst aktiviert werden. Hierbei muss die Datei "/boot/config.txt" editiert
und um folgende Zeile ergänzt werden:

dtoverlay=w1-gpio,gpiopin=4

Die Datei können Sie editieren, indem Sie den Befehl...

sudo nano /boot/config.txt

... in die Konsole eingeben. Mit der Tastenkombination [STRG+X] können Sie das Editieren beenden und mit
[STRG+Y] abspeichern.

Nachdem Sie den Raspberry Pi mittels...

sudo reboot

... neugestartet haben, können Sie das untenstehende Beispiel anwenden.

Codebeispiel Raspberry Pi

Programmierbeispiel in der Programmiersprache Python

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 13 von 227

KY-001 Temperatur Sensor Modul

# coding=utf-8
# Benoetigte Module werden importiert und eingerichtet
import glob
import time
from time import sleep
import RPi.GPIO as GPIO

# An dieser Stelle kann die Pause zwischen den einzelnen Messungen eingestellt werden
sleeptime = 1

# Der One-Wire EingangsPin wird deklariert und der integrierte
#PullUp-Widerstand aktiviert GPIO.setmode(GPIO.BCM)
GPIO.setup(4, GPIO.IN, pull_up_down=GPIO.PUD_UP)

# Nach Aktivierung des Pull-UP Widerstandes wird gewartet,
# bis die Kommunikation mit dem DS18B20 Sensor aufgebaut ist
print 'Warte auf Initialisierung...'

base_dir = '/sys/bus/w1/devices/'
while True:
try:
device_folder = glob.glob(base_dir + '28*')[0]
break
except IndexError:
sleep(0.5)
continue
device_file = device_folder + '/w1_slave'

# Funktion wird definiert, mit dem der aktuelle Messwert am Sensor
# ausgelesen werden kann
def TemperaturMessung():
f = open(device_file, 'r')
lines = f.readlines()
f.close()
return lines

# Zur Initialisierung, wird der Sensor einmal "blind" ausgelesen
TemperaturMessung()

# Die Temperaturauswertung: Beim Raspberry Pi werden erkennte one-Wire Slaves im Ordner
# /sys/bus/w1/devices/ einem eigenen Unterordner zugeordnet. In diesem Ordner befindet
# sich die Datei w1-slave # in dem Die Daten, die über dem One-Wire Bus gesendet wurden gespeichert.
# In dieser Funktion werden diese Daten analysiert und die Temperatur herausgelesen und ausgegeben

def TemperaturAuswertung():
lines = TemperaturMessung()
while lines[0].strip()[-3:] != 'YES':
time.sleep(0.2)
lines = TemperaturMessung()
equals_pos = lines[1].find('t=')
if equals_pos != -1:
temp_string = lines[1][equals_pos+2:]
temp_c = float(temp_string) / 1000.0
return temp_c

# Hauptprogrammschleife
# Die gemessene Temperatur wird in die Konsole ausgegeben - zwischen den einzelnen Messungen
# ist eine Pause, deren Länge mit der Variable "sleeptime" eingestellt werden kann

try:
while True:
print '---------------------------------------'
print "Temperatur:", TemperaturAuswertung(), "°C"
time.sleep(sleeptime)

except KeyboardInterrupt:
GPIO.cleanup()

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 14 von 227

KY-001 Temperatur Sensor Modul

Anschlussbelegung Raspberry Pi:

Signal = GPIO4 [Pin 7]

+V = 3,3V [Pin 1]

GND = Masse [Pin 6]

Beispielprogramm Download

KY-001_RPi_TemperaturSensor.zip

Zu starten mit dem Befehl:

sudo python KY-001_RPi_TemperaturSensor.py

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 15 von 227

KY-002 Erschütterungs-Schalter Modul

KY-002 Erschütterungs-Schalter Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 2

5 Codebeispiel Raspberry Pi ................................................................................................................................... 3

Bild

Technische Daten / Kurzbeschreibung

Bei Erschütterung wird der Kontakt zwischen den zwei Eingangspins geschlossen

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 16 von 227

KY-002 Erschütterungs-Schalter Modul

Pin-Belegung

Codebeispiel Arduino

Hier bei handelt es sich um ein Beispielprogramm, welches eine LED zum Leuchten bringt, wenn am Sensor
ein Signal detektiert wurde. Als LED können z.B. auch unter anderem die Module KY-011, KY-016 oder KY­029 verwendet werden.

int Led = 13 ;// Deklaration des LED-Ausgangspin
int Sensor = 10; // Deklaration des Sensor-Eingangspin
int val; // Temporaere Variable

void setup ()
{
pinMode (Led, OUTPUT) ; // Initialisierung Ausgangspin
pinMode (Sensor, INPUT) ; // Initialisierung Sensorpin
digitalWrite(Sensor, HIGH); // Aktivierung interner Pull-Up Widerstand
}

void loop ()
{
val = digitalRead (Sensor) ; // Das gegenwärtige Signal am Sensor wird ausgelesen

if (val == HIGH) // Falls ein Signal erkannt werden konnte, wird die LED eingeschaltet.
{
digitalWrite (Led, LOW);
}
else
{
digitalWrite (Led, HIGH);
}
}

Anschlussbelegung Arduino:

LED + = [Pin 13]

LED - = [Pin GND]

Sensor Signal = [Pin 10]

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 17 von 227

KY-002 Erschütterungs-Schalter Modul

Sensor+V = [Pin 5V]

Sensor - = [Pin GND]

Beispielprogramm Download

SensorTest_Arduino.zip

Codebeispiel Raspberry Pi

Programmierbeispiel in der Programmiersprache Python

Anschlussbelegung Raspberry Pi:

Signal = GPIO24 [Pin 18]

+V = 3,3V [Pin 1]

GND = Masse [Pin 6]

Beispielprogramm Download

SensorTest_RPi.zip

Zu starten mit dem Befehl:

sudo python SensorTest_RPi.py

# Benoetigte Module werden importiert und eingerichtet
import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

# Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist.
# Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert GPIO_PIN = 24
GPIO.setup(GPIO_PIN, GPIO.IN, pull_up_down = GPIO.PUD_UP)

print "Sensor-Test [druecken Sie STRG+C, um den Test zu beenden]"

# Diese AusgabeFunktion wird bei Signaldetektion ausgefuehrt
def ausgabeFunktion(null):
print("Signal erkannt")

# Beim Detektieren eines Signals (fallende Signalflanke) wird die Ausgabefunktion ausgeloest

GPIO.add_event_detect(GPIO_PIN, GPIO.FALLING, callback=ausgabeFunktion, bouncetime=100)

# Hauptprogrammschleife
try:
while True:
time.sleep(1)

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 18 von 227

KY-003 Hall Magnetfeld-Sensor Modul

KY-003 Hall Magnetfeld-Sensor Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 2

5 Codebeispiel Raspberry Pi ................................................................................................................................... 3

Bild

Technische Daten / Kurzbeschreibung

Chipsatz: A3141

Sensortyp: Hall Effect Transistor/Schalter

Der Transistor schaltet durch, falls das Modul in ein Magnetfeld gehalten wird. Dies kann dann am
Signalausgang als analoger Spannungswert ausgelesen werden.

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 19 von 227

KY-003 Hall Magnetfeld-Sensor Modul

Pin-Belegung

Codebeispiel Arduino

Hier bei handelt es sich um ein Beispielprogramm, welches eine LED zum Leuchten bringt, wenn am Sensor
ein Signal detektiert wurde. Als LED können z.B. auch unter anderem die Module KY-011, KY-016 oder KY­029 verwendet werden.

int Led = 13 ;// Deklaration des LED-Ausgangspin
int Sensor = 10; // Deklaration des Sensor-Eingangspin
int val; // Temporaere Variable

void setup ()
{
pinMode (Led, OUTPUT) ; // Initialisierung Ausgangspin
pinMode (Sensor, INPUT) ; // Initialisierung Sensorpin
digitalWrite(Sensor, HIGH); // Aktivierung interner Pull-Up Widerstand
}

void loop ()
{
val = digitalRead (Sensor) ; // Das gegenwärtige Signal am Sensor wird ausgelesen

if (val == HIGH) // Falls ein Signal erkannt werden konnte, wird die LED eingeschaltet.
{
digitalWrite (Led, LOW);
}
else
{
digitalWrite (Led, HIGH);
}
}

Anschlussbelegung Arduino:

LED + = [Pin 13]

LED - = [Pin GND]

Sensor Signal = [Pin 10]

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 20 von 227

KY-003 Hall Magnetfeld-Sensor Modul

Sensor+V = [Pin 5V]

Sensor - = [Pin GND]

Beispielprogramm Download

SensorTest_Arduino.zip

Codebeispiel Raspberry Pi

Programmierbeispiel in der Programmiersprache Python

Anschlussbelegung Raspberry Pi:

Signal = GPIO24 [Pin 18]

+V = 3,3V [Pin 1]

GND = Masse [Pin 6]

Beispielprogramm Download

SensorTest_RPi.zip

Zu starten mit dem Befehl:

sudo python SensorTest_RPi.py

# Benoetigte Module werden importiert und eingerichtet
import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

# Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist.
# Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert GPIO_PIN = 24
GPIO.setup(GPIO_PIN, GPIO.IN, pull_up_down = GPIO.PUD_UP)

print "Sensor-Test [druecken Sie STRG+C, um den Test zu beenden]"

# Diese AusgabeFunktion wird bei Signaldetektion ausgefuehrt
def ausgabeFunktion(null):
print("Signal erkannt")

# Beim Detektieren eines Signals (fallende Signalflanke) wird die Ausgabefunktion ausgeloest

GPIO.add_event_detect(GPIO_PIN, GPIO.FALLING, callback=ausgabeFunktion, bouncetime=100)

# Hauptprogrammschleife
try:
while True:
time.sleep(1)

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 21 von 227

KY-004 Taster-Modul

KY-004 Taster-Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 2

5 Codebeispiel Raspberry Pi ................................................................................................................................... 3

Bild

Technische Daten / Kurzbeschreibung

Beim Drücken des Tasters, werden zwei Signalausgänge miteinander kurzgeschlossen.

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 22 von 227

KY-004 Taster-Modul

Pin-Belegung

Codebeispiel Arduino

Hier bei handelt es sich um ein Beispielprogramm, welches eine LED zum Leuchten bringt, wenn am Sensor
ein Signal detektiert wurde. Als LED können z.B. auch unter anderem die Module KY-011, KY-016 oder KY­029 verwendet werden.

int Led = 13 ;// Deklaration des LED-Ausgangspin
int Sensor = 10; // Deklaration des Sensor-Eingangspin
int val; // Temporaere Variable

void setup ()
{
pinMode (Led, OUTPUT) ; // Initialisierung Ausgangspin
pinMode (Sensor, INPUT) ; // Initialisierung Sensorpin
digitalWrite(Sensor, HIGH); // Aktivierung interner Pull-Up Widerstand
}

void loop ()
{
val = digitalRead (Sensor) ; // Das gegenwärtige Signal am Sensor wird ausgelesen

if (val == HIGH) // Falls ein Signal erkannt werden konnte, wird die LED eingeschaltet.
{
digitalWrite (Led, LOW);
}
else
{
digitalWrite (Led, HIGH);
}
}

Anschlussbelegung Arduino:

LED + = [Pin 13]

LED - = [Pin GND]

Sensor Signal = [Pin 10]

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 23 von 227

KY-004 Taster-Modul

Sensor+V = [Pin 5V]

Sensor - = [Pin GND]

Beispielprogramm Download

SensorTest_Arduino.zip

Codebeispiel Raspberry Pi

Programmierbeispiel in der Programmiersprache Python

Anschlussbelegung Raspberry Pi:

Signal = GPIO24 [Pin 18]

+V = 3,3V [Pin 1]

GND = Masse [Pin 6]

Beispielprogramm Download

SensorTest_RPi.zip

Zu starten mit dem Befehl:

sudo python SensorTest_RPi.py

# Benoetigte Module werden importiert und eingerichtet
import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

# Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist.
#Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert GPIO_PIN = 24
GPIO.setup(GPIO_PIN, GPIO.IN, pull_up_down = GPIO.PUD_UP)

print "Sensor-Test [druecken Sie STRG+C, um den Test zu beenden]"

# Diese AusgabeFunktion wird bei Signaldetektion ausgefuehrt
def ausgabeFunktion(null):
print("Signal erkannt")

# Beim Detektieren eines Signals (fallende Signalflanke) wird die Ausgabefunktion ausgeloest

GPIO.add_event_detect(GPIO_PIN, GPIO.FALLING, callback=ausgabeFunktion, bouncetime=100)

# Hauptprogrammschleife
try:
while True:
time.sleep(1)

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 24 von 227

KY-005 Infrarot Transmitter Modul

KY-005 Infrarot Transmitter Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 2

4.1 Codebeispiel ON/OFF .................................................................................................................................. 2

4.2 Codebeispiel Fernbedienung ...................................................................................................................... 3

5 Codebeispiel Raspberry Pi ................................................................................................................................... 5

5.1 Codebeispiel ON/OFF .................................................................................................................................. 5

5.2 Codebeispiel Fernbedienung ...................................................................................................................... 6

5.3 Lirc Installation ........................................................................................................................................... 6

5.4 IR-Receiver Test ......................................................................................................................................... 8

5.5 Fernbedienung anlernen ............................................................................................................................ 9

5.6 Befehle senden mit dem Infrarot Transmitter .......................................................................................... 10

Bild

Technische Daten / Kurzbeschreibung

Eine Leuchtdiode, die im infraroten Bereich ausstrahlt. Je nach Eingangsspannung, werden Vorwiderstände
benötigt

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 25 von 227

Vf= 1,1V

If= 20mA

emittierende Wellenlänge: 940nm

(nicht sichtbares Licht)

Vorwiderstände:

Rf (3,3V) = 120Ω

[z.B. beim Einsatz mit ARM CPU-Kern basierten Mikrokontrollern wie ]Raspberry-Pi

Rf (5V) = 220Ω

[z.B. beim Einsatz mit Atmel Atmega basierten Mikrokontrollern wie ]Arduino

Pin-Belegung

*Auf der Platine gibt es die Möglichkeit den jeweils benötigten Widerstand direkt aufzulöten. In dem Falle
kann dann der mittlere Pin genutz werden, der dann den Widerstand beihnaltet.

Codebeispiel Arduino

Codebeispiel ON/OFF

Diese Codebeispiel zeigt auf, wie eine LED mittels eines definierbaren Ausgangspins abwechselnd für
VierSekunden ein- und danach zwei Sekunden ausgeschaltet werden kann.

KY-005 Infrarot Transmitter Modul

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 26 von 227

KY-005 Infrarot Transmitter Modul

Beispielprogramm Download:

LedTestArduino_4On_2Off.zip

Codebeispiel Fernbedienung

Mithilfe der beiden Sensormodule KY-005 und KY-022 lässt sich ein Infrarot-Fernbedienung + Infrarot
Receiver System aufbauen. Hierzu werden neben den zwei Modulen auch zwei einzelne Arduinos benötigt.
Der eine fungiert hierbei dann als Sender und der andere empfängt die Signale und gibt diese dann in der
seriellen Konsole aus.

Für das folgende Codebeispiel wirdeine zusätzliche Library benötigt:

- [Arduino-IRremote] von | veröffentlicht unter LGPLKen Shirriff

Die Library istim Paket enthalten und muss vor dem Start der Arduino IDE in den "library"-Ordner kopiert
werden.

Diesen finden Sie standardmäßig unter dem folgenden Pfad Ihrer Windows-Installation:

C:\Benutzer\[Benutzername]\Dokumente\Arduino\libraries

Bei Infrarot-Sendesystemen, gibt es verschiedene Protokolle, in denen die Daten versendet werden können.
In dem folgenden Beispiel wird für das versenden das RC5 Protokoll verwendet - die verwendete Library
"Arduino-IRremote" kümmert sich eigenständig um die Konvertierung in die richtige Datenfolge. Es gibt
innerhalb der Library jedoch auch andere Protokolle/Kodierungen - diese sind in der Dokumentation/Code
der Library gekennzeichnet.

Code für den Empfänger:

// Arduino-IRremote Iibrary wird hinzugefuegt
#include <IRremote.h>

// Hier kann der entsprechende Eingangspin für den Signalausgang
// des KY-022 deklariert werden

int Led = 13;

void setup ()
{
pinMode (Led, OUTPUT); // Initialisierung Ausgangspin für die LED
}

void loop () //Hauptprogrammschleife
{
digitalWrite (Led, HIGH); // LED wird eingeschaltet
delay (4000); // Wartemodus für 4 Sekunden
digitalWrite (Led, LOW); // LED wird ausgeschaltet
delay (2000); // Wartemodus für weitere zwei Sekunden in denen die LED dann ausgeschaltet ist
}

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 27 von 227

KY-005 Infrarot Transmitter Modul

Code für den Sender:

Beispielprogramm Download:

Arduino_Fernbedienung.zip

Anschlussbelegung Arduino 1 [Empfänger]:

KY-022

Signal = [Pin 11]

int RECV_PIN = 11;

// Arduino-IRremote Library wird initialisiert
IRrecv irrecv(RECV_PIN);
decode_results results;

void setup()
{
Serial.begin(9600);
irrecv.enableIRIn(); // Infrarot-Receiver wird gestartet
}

// Hauptprogrammschleife
void loop() {

// Es wird geprüft ob am Recveiver ein Signal eingegangen ist
if (irrecv.decode(&results)) {
// Bei Signaleingang wird das empfangene und dekodierte Signal
// in der serriellen Konsole ausgegeben
Serial.println(results.value, HEX);
irrecv.resume();
}
}

//Arduino-IRremote Library wird hinzugefügt...
#include <IRremote.h>

//...und hier initialisiert
IRsend irsend;

// Die Einstellungen für den Ausgang werden von der Library übernommen
// Die entsprechenden Ausgänge unterscheiden sich je nach verwendeten Arduino
// Arduino UNO: Ausgang = D3
// Arduino MEGA: Ausgang = D9
// Eine komplette Auflistung der entsprechenden Ausgänge finden Sie unter
// http://z3t0.github.io/Arduino-IRremote/
void setup()
{
}

// Hauptprogrammschleife
void loop() {

// Der Sender verschickt in diesem Beispiel das Signal A90 (in hexdezimaler Form) in der Kodierung "RC5"
// Dieses wird dreimal hintereinander gesendet und danach eine Pause für 5 Sekunden eingelegt

for (int i = 0; i < 3; i++) {

 // [0xA90] zu versendetes Signal | [12] Bit-Länge des zu versendeten Signals (hex A90=1010 1001 0000)

irsend.sendRC5(0xA90, 12);
delay(40);
}
delay(5000); //Zwischen den Sendeimpulsen gibt es eine Pause von 5 Sekunden
}

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 28 von 227

KY-005 Infrarot Transmitter Modul

+V = [Pin 5V]

GND = [Pin GND]

Anschlussbelegung Arduino 2 [Sender]:

KY-005

Signal = [Pin 3 (Arduino Uno) | Pin 9 (Arduino Mega)]

GND+Widerstand = [Pin GND*]

GND = [Pin GND]

*Nur wenn Vorwiderstand auf dem Modul verlötet wurde und nicht vor dem Modul geschaltet ist

Codebeispiel Raspberry Pi

Es sind zwei Anwendungsbeispiele für dieses Sensormodul hier vorgestellt. Eines, welches die Infrarot­Transmitter Diode kurz ein und wieder ausschaltet (emittierendes Licht nicht sichtbar - kann z.B. durch eine
Handykamera gesehen werden), sowie ein direktes Anwendungsbeispiel für den Raspberry Pi, wo er als
entweder Infrarot Receiver für Fernbedienungen zum Steuern von z.B. der Mediencenter-Software OpenElec
oder als Infrarot-Transmitter zur Software-gesteuerten Fernbedienung programmiert werden kann.

Codebeispiel ON/OFF

Programmierbeispiel in der Programmiersprache Python

Anschlussbelegung Raspberry Pi:

Sensor Signal = GPIO24 [Pin 18]

GND+Widerstand = GND* [Pin 9]

# Benoetigte Module werden importiert und eingerichtet
import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

# Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist.
#Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert LED_PIN = 24
GPIO.setup(LED_PIN, GPIO.OUT, initial= GPIO.LOW)

print "LED-Test [druecken Sie STRG+C, um den Test zu beenden]"

# Hauptprogrammschleife
try:
while True:
print("LED 4 Sekunden an")
GPIO.output(LED_PIN,GPIO.HIGH) #LED wird eingeschaltet
time.sleep(4) #Wartemodus fuer 4 Sekunden
print("LED 2 Sekunden aus")
GPIO.output(LED_PIN,GPIO.LOW) #LED wird ausgeschaltet
time.sleep(2) #Wartemodus fuer weitere zwei Sekunden,

    # in denen die LED Dann ausgeschaltet ist

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 29 von 227

KY-005 Infrarot Transmitter Modul

Sensor GND = Masse [Pin 6]

*Nur wenn Vorwiderstand auf dem Modul verlötet wurde und nicht vor dem Modul geschaltet ist

Beispielprogramm Download

LedTest_RPi_4On_2Off.zip

Zu starten mit dem Befehl:

sudo python LedTest_RPi_4On_2Off.py

Codebeispiel Fernbedienung

Der Raspberry Pi besitzt mit seiner fortschrittlichen Prozessorarchitektur den Vorteil gegenüber dem
Arduino, dass dieser ein komplettes Linux-Betriebssystem betreiben kann. Mit Hilfe eines Infrarot-Receivers
können somit nicht nur einfache Datensignale ausgetaucht, sondern es können auch komplette Software­Programme wie z.B. die Mediencenter Software OpenElec per Fernbedienung bedient werden.

Für die Einrichtung eines Infrarot-Steuerungssystem, bietet sich unter Linux bietet die Software "lirc" an
(veröffentlicht unter der LGPL - ). Im Folgenden zeigen wir auf, wie lirc eingerichtet, eine Website
Fernbedienung angelernt werden kann und per Infrarotdiode die erlernten Signale per Infrarot versendet
werden können (um z.B. aus dem Raspberry Pi eine per Software steuerbare Infrarot Fernbedienung zu
machen).

Zu diesem Zwecke werden die Module KY-005 als Infrarot-Transmitter und KY-022 als Infrarot Receiver
angewendet.

Anschlussbelegung Raspberry Pi:

KY-005

Signal = GPIO17 [Pin 11]

GND+Widerstand = GND* [Pin 9]

GND = GND [Pin 6]

*Nur wenn Vorwiderstand auf dem Modul verlötet wurde und nicht vor dem Modul geschaltet ist

KY-022

Signal = GPI18 [Pin 12]

+V = 3,3V [Pin 17]

GND = GND [Pin 25]

Lirc Installation

Als erstes öffnen wir auf dem Desktop ein Terminal oder verbinden wir uns per SSH mit dem Raspberry Pi.
Dort geben Sie den folgenden Befehl ein, um lirc auf den Raspberry Pi zu installieren:

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 30 von 227

KY-005 Infrarot Transmitter Modul

sudo apt-get install lirc -y

[Hierzu muss der Raspberry Pi mit dem Internet verbunden sein]

Damit das lirc Modul direkt zum Start des Betriebssystem verfügbar ist, müssen folgende Zeilen am Ende
der Datei "/boot/config.txt" hinzugefügt werden:

dtoverlay=lirc-rpi,gpio_in_pin=18,gpio_out_pin=17,gpio_in_pull=up

Hierbei definiert "gpio_in_pin=18" den Eingangspin für den IR-Receiver, sowie "gpio_out_pin=17" den
Ausgangspin für den IR-Transmitter.

Die Datei kann mit folgenden Befehl editiert werden:

sudo nano /boot/config.txt

Mit der Tastenfolge [Strg+X -> Y -> Enter] kann die Datei, nach dem hinzufügen der Zeile am unteren Ende,
gespeichert und geschlossen werden.

Auch die Datei "/etc/lirc/hardware.conf" muss modifiziert werden. Hierbei ist der Befehl...

sudo nano /etc/lirc/hardware.conf

... zu verwenden. Hier müssen die die folgenden Zeilen modifiziert werden. An den entsprechenden Stellen
muss dann ...

DRIVER="UNCONFIGURED"

--->>
DRIVER="default"

DEVICE=""

--->>
DEVICE="/dev/lirc0"

MODULES=""

--->>
MODULES="lirc_rpi"

...geändert werden.

Die modifizierte Datei muss dann wie folgt aussehen:

# /etc/lirc/hardware.conf
#
# Arguments which will be used when launching lircd
LIRCD_ARGS=""

#Don't start lircmd even if there seems to be a good config file

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 31 von 227

KY-005 Infrarot Transmitter Modul

#Don't start lircmd even if there seems to be a good config file
#START_LIRCMD=false

#Don't start irexec, even if a good config file seems to exist.
#START_IREXEC=false

#Try to load appropriate kernel modules
LOAD_MODULES=true

# Run "lircd --driver=help" for a list of supported drivers.
DRIVER="default"
# usually /dev/lirc0 is the correct setting for systems using udev
DEVICE="/dev/lirc0"
MODULES="lirc_rpi"

# Default configuration files for your hardware if any
LIRCD_CONF=""
LIRCMD_CONF=""

Danach starten wir den Raspberry Pi mit dem folgenden Befehl neu:

sudo reboot

IR-Receiver Test

Um den angeschlossenen Receiver zu testen, muss vorab lirc mit dem Befehl...

sudo /etc/init.d/lirc stop

beendet werden. Danach kann mit...

mode2 -d /dev/lirc0

...getestet werden, ob am Raspberry Pi Signale detektiert werden können. Hierzu nehmen Sie eine Infrarot
Fernbedienung und drücken eine beliebige Taste - es sollten Zeilen in der folgenden Form auftauchen:

space 95253
pulse 9022
space 2210
pulse 604
space 95246
pulse 9019
space 2211
pulse 601
space 95252
pulse 9019
space 2210
pulse 603
space 95239
pulse 9020
space 2208
pulse 603
...

Mit dem Befehl...

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 32 von 227

KY-005 Infrarot Transmitter Modul

sudo /etc/init.d/lirc start

... kann der lirc-Dienst wieder gestartet werden.

Fernbedienung anlernen

Um eine Infrarot-Fernbedienung im lirc System zu registrieren, muss für die Fernbedienung die Datei "/etc
/lirc/lircd.conf" konfiguriert werden. In dieser sind die jeweiligen Zuordnungen von Befehl zu empfangenen
Infrarot-Codes gespeichert.

Um eine entsprechend richtig formatierte lircd.conf erstellen zu können, gibt es in der lirc-Software einen
Assistenten, der die Datei automatisch erstellt. Die Vorgehensweise für diese Konfiguration ist wie folgt:

Zu aller erst, muss der lirc-Service beendet werden

sudo /etc/init.d/lirc stop

Mit dem folgenden Befehl starten wir dann den Assistenten:

irrecord -d /dev/lirc0 ~/MeineFernbedienung.conf

Dieser Assistent führt vorab eine erste Initialisierung der Fernbedienung durch - in dieser müssen mehrere
Tasten abwechselnd gedrückt werden, damit das lirc System die entsprechende Kodierung der
Fernbedienung erlernen kann. Bitte folgen Sie dazu die entsprechenden Anweisungen des Assistenten. Nach
der Initialisierung fragt dann der Assistent nach dem Namen der Knopfzuordnung, die mit einem neuen
Infrarotcode aufgezeichnet werden soll. Sie können sich hierzu die Knopfzuordnungen aus der folgenden
Datei auswählen

FernbedienungsCodes.txt

Diese müssen dann in den Assistenten eingegeben und mit Enter bestätigt werden. Hiernach startet dann
die Aufzeichnung des Infrarot-Codes, für die ausgewählte Taste.

Beispiel: [KEY_0] eingeben -> mit Enter bestätigen -> Taste "0" auf der Fernbedienung drücken -> warten
bis der Assistent die Aufnahme bestätigt.

Sollen keine weiteren Tasten angelernt werden, so kann der Assistent mit der Enter-Taste beendet werden.
Hiernach ist die Konfigurationsdatei erstellt, jedoch muss noch ein Name für die aufgezeichnete
Fernbedienung vergeben werden. Hierzu öffnen wir die Datei im Editor mit:

sudo nano ~/MeineFernbedienung.conf

Hier kann dann die Zeile 17 von

name /home/pi/MeineFernbedienung.conf

in

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 33 von 227

KY-005 Infrarot Transmitter Modul

name MeineFernbedienung

geändert werden. Beachten Sie hierbei keine Leerzeichen und Sonderzeichen innerhalb des Namens zu
verwenden. Mit der Tastenfolge [Strg+X -> Y -> Enter] kann die Datei, nach dem hinzufügen der Zeile am
unteren Ende, gespeichert und geschlossen werden.

Nach erstellen der Konfigurationsdatei können Sie vorab für die original lircd.conf mit folgenden Befehl ein
Backup erstellen:

sudo mv /etc/lirc/lircd.conf /etc/lirc/lircd.conf.bak

und mit dem Befehl...

sudo cp ~/MeineFernbedienung.conf /etc/lirc/lircd.conf

...wird die vorab neu erstellte Konfigurationsdatei für das lirc-System eingesetzt.

Nun kann mit...

sudo /etc/init.d/lirc start

...das lirc System wieder gestartet werden.

Ab nun ist die neu angelernte Fernbedienung im System registriert und kann in kompatibler Software , wie z.
B. dem Mediencenter OpenElec verwendet werden. Alternativ kann mit dem Befehl...

irw

...die Zuordnungen und die Funktion der Fernbedienung getestet werden.

Will man die Fernbedienung nun z.B. in OpenElec verwenden, kann es je nach Konfiguration der
Mediensoftware sein, dass lirc in den Optionen von OpenElec vorab noch aktiviert werden muss.

Befehle senden mit dem Infrarot Transmitter

Möchte man mit dem Raspberry Pi nun Geräte wie z.B. den Fernseher per Infrarot steuern, so können nun
die vorab angelernten Befehle mit Hilfe des Infrarot Transmitters wieder versendet werden. So lässt sich z.B.
eine Software gesteuerte Infrarot-Steuerung aufbauen oder einzelne Geräte mittels Netzwerk/Internet ein
und Ausschalten.

Zuerst überprüfen wir mit folgendem Befehl...

irsend LIST MeineFernbedienung ""

...welche Zuordnungen für die jeweilige gespeicherte Fernbedienung verfügbar sind.

Nun können wir z.B. den Befehl [KEY_0] versenden, indem wir den folgenden Befehl verwenden:

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 34 von 227

KY-005 Infrarot Transmitter Modul

irsend SEND_ONCE MeineFernbedienung KEY_0

Auf dem Fernseher bzw. dem entsprechenden Empfänger-Endgerät, sollte sich nun eine Reaktion zeigen. Zu
dem o.g. Befehl gibt es auch die Variation, dass das Signal wiederholend ausgegeben wird

irsend SEND_START MeineFernbedienung KEY_0

Hier nach wird der gesendete Code [KEY_0] so oft wiederholt bis mit...

irsend SEND_STOP MeineFernbedienung KEY_0

...wieder beendet wird. Dies wird z.B. bei Befehlen wie "Lautstärke Hoch" oder "Helligkeit runter"
angewendet.

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 35 von 227

KY-006 Passives Piezo-Buzzer Modul

KY-006 Passives Piezo-Buzzer Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 2

5 Codebeispiel Raspberry Pi ................................................................................................................................... 3

Bild

Technische Daten / Kurzbeschreibung

Mit PWM-Signalen verschiedener Frequenzen angesteuert, können mit dem passiven Piezo-Buzzer
verschiedene Töne erzeugt werden.

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 36 von 227

KY-006 Passives Piezo-Buzzer Modul

Pin-Belegung

Codebeispiel Arduino

Hier bei handelt es sich um ein Beispielprogramm, welches amBuzzer ein Alarmsignal mittels einer
Rechteckspannung erzeugt.

int buzzer = 8 ; // Deklaration des Buzzer-Ausgangspin

void setup ()
{
pinMode (buzzer, OUTPUT) ;// Initialisierung als Ausgangspin
}

void loop ()
{
unsigned char i;
while (1)
{
// In diesem Programm wird der Buzzer abwechselnd mit zwei verschiedenen
// Frequenzen angesteuert. Das Signal hierbei besteht aus einer Rechteckspannung.
// Das an- und ausmachen am Buzzer generiert dann einen Ton,
// der in etwa der Frequenz entspricht.
// Die Frequenz definiert sich dadurch, wie lang jeweils die An- und Ausphase sind

//Frequenz 1
for (i = 0; i <80; i++)
{
digitalWrite (buzzer, HIGH) ;
delay (1) ;
digitalWrite (buzzer, LOW) ;
delay (1) ;
}
//Frequenz 2
for (i = 0; i <100; i++)
{
digitalWrite (buzzer, HIGH) ;

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 37 von 227

KY-006 Passives Piezo-Buzzer Modul

delay (2) ;
digitalWrite (buzzer, LOW) ;
delay (2) ;
}
}
}

Anschlussbelegung Arduino:

Sensor Signal = [Pin 8]

Sensor - = [Pin GND]

Beispielprogramm Download

KY-006_Buzzer.zip

Codebeispiel Raspberry Pi

Programmierbeispiel in der Programmiersprache Python

Das Beispielprogramm nutzt Software-PWM, um am Ausgangspin eine Rechteckspannung mit definierbarer
Frequenz zu erstellen.

Durch das An- und Ausschalten wird am Buzzer ein Ton erzeugt, der in etwa der Frequenz der
Rechteckspannung entspricht.

# Benoetigte Module werden importiert und eingerichtet
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)

Anschlussbelegung Raspberry Pi:

Signal = GPIO24 [Pin 18]

+V = 3,3V [Pin 1]

# Hier wird der Ausgangs-Pin deklariert, an dem der Buzzer angeschlossen ist.
GPIO_PIN = 24
GPIO.setup(GPIO_PIN, GPIO.OUT)

# Das Software-PWM Modul wird initialisiert - hierbei wird die Frequenz 500Hz als Startwert genommen

Frequenz = 500 #In Hertz
pwm = GPIO.PWM(GPIO_PIN, Frequenz)
pwm.start(50)

# Das Programm wartet auf die Eingabe einer neuen PWM-Frequenz vom Benutzer.
# Bis dahin wird der Buzzer mit der vorher eingegebenen Freuqenz betrieben (Startwert 500Hz)

try:
while(True):
print "----------------------------------------"
print "Aktuelle Frequenz: %d" % Frequenz
Frequenz = input("Bitte neue Frequenz eingeben (50-5000):")
pwm.ChangeFrequency(Frequenz)

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 38 von 227

KY-006 Passives Piezo-Buzzer Modul

GND = Masse [Pin 6]

Beispielprogramm Download

KY-006-RPI_PWM.zip

Zu starten mit dem Befehl:

sudo python KY-006-RPI_PWM.py

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 39 von 227

KY-009 RGB LED SMD Modul

KY-009 RGB LED SMD Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 2

5 Codebeispiel Raspberry Pi ................................................................................................................................... 4

Bild

Technische Daten / Kurzbeschreibung

LED-Modul welche eine rote, blaue und grüne LED beinhaltet. Diese sind mittels gemeinsamer Kathode
miteinander verbunden. Je nach Eingangsspannung, werden Vorwiderstände benötigt

Vf [ ]= 1,8VRot

Vf [ , ]= 2,8VGruen Blau

If= 20mA

Vorwiderstände:

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 40 von 227

KY-009 RGB LED SMD Modul

Rf (3,3V) [ ]= 100ΩGrün

Rf (3,3V) [ ]= 180ΩRot

Rf (3,3V) [ ]= 100ΩBlau

[z.B. beim Einsatz mit ARM CPU-Kern basierten Mikrokontrollern wie ]Raspberry-Pi

Rf (5V) [ ] = 100ΩGrün

Rf (5V) [ ] = 180ΩRot 

Rf (5V) [ ] = 100ΩBlau 

[z.B. beim Einsatz mit Atmel Atmega basierten Mikrokontrollern wie ]Arduino

Pin-Belegung

Codebeispiel Arduino

Codebeispiel ON/OFF

Dieses Codebeispiel zeigt auf, wie die integrierten LEDs mittels eines definierbaren Ausgangspins
abwechselnd, in 3 Sekunden Takt, angeschaltet werden können.

int Led_Rot = 10;
int Led_Gruen = 11;
int Led_Blau = 12;

void setup ()
{
// Initialisierung Ausgangspins für die LEDs
pinMode (Led_Rot, OUTPUT);
pinMode (Led_Gruen, OUTPUT);
pinMode (Led_Blau, OUTPUT);
}

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 41 von 227

KY-009 RGB LED SMD Modul

}

Beispielprogramm ON/OFF Download:

KY-009_LED_ON-OFF.zip

Codebeispiel PWM

Mittels Puls-Weiten-Modulation [PWM] lässt sich die Helligkeit einer LED regulieren - dabei wird die LED in
bestimmten Zeitintervallen ein und ausgeschaltet, wobei das Verhältnis der Einschalt- und Ausschaltzeit
einer relativen Helligkeit entspricht - aufgrund der Trägheit des menschlichen Sehvermögens, interpretieren
die menschlichen Augen ein solches Ein-/Ausschaltverhalten als Helligkeitsänderung. Nähere Informationen
zu diesem Thema finden Sie in diesem [ ].Artikel von mikrokontroller.net

In diesem Modul sind mehrere LEDs integriert - durch die Überlagerung von unterschiedlichen
Helligkeitsstufen lassen sich somit verschiedene Farben kreieren. Dieses wird im folgenden Codebeispiel
gezeigt.

void loop () //Hauptprogrammschleife
{
digitalWrite (Led_Rot, HIGH); // LED wird eingeschaltet
digitalWrite (Led_Gruen, LOW); // LED wird eingeschaltet
digitalWrite (Led_Blau, LOW); // LED wird eingeschaltet
delay (3000); // Wartemodus für 3 Sekunden

digitalWrite (Led_Rot, LOW); // LED wird eingeschaltet
digitalWrite (Led_Gruen, HIGH); // LED wird eingeschaltet
digitalWrite (Led_Blau, LOW); // LED wird eingeschaltet
delay (3000); // Wartemodus für weitere drei Sekunden in denen die LEDs dann umgeschaltet werden

digitalWrite (Led_Rot, LOW); // LED wird eingeschaltet
digitalWrite (Led_Gruen, LOW); // LED wird eingeschaltet
digitalWrite (Led_Blau, HIGH); // LED wird eingeschaltet
delay (3000); // Wartemodus für weitere drei Sekunden in denen die LEDs dann umgeschaltet werden
}

int Led_Rot = 10;
int Led_Gruen = 11;
int Led_Blau = 12;

int val;

void setup () {
// Initialisierung Ausgangspins für die LEDs
pinMode (Led_Rot, OUTPUT);
pinMode (Led_Gruen, OUTPUT);
pinMode (Led_Blau, OUTPUT);
}
void loop () {
// Innerhalb einer For-Schleife werden den drei LEDs verschiedene PWM-Werte uebergeben
// Dadurch entsteht ein Farbverlauf, in dem sich durch das Vermischen unterschiedlicher
// Helligkeitstufen der beiden integrierten LEDs, unterschiedliche Farben entstehen
for (val = 255; val> 0; val--)
{
analogWrite (Led_Blau, val);
analogWrite (Led_Gruen, 255-val);
analogWrite (Led_Rot, 128-val);
delay (1);
}
// In der zweiten For-Schleife wird der Farbverlauf rückwärts durchgegangen
for (val = 0; val <255; val++)
{
analogWrite (Led_Blau, val);

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 42 von 227

KY-009 RGB LED SMD Modul

{
analogWrite (Led_Blau, val);
analogWrite (Led_Gruen, 255-val);
analogWrite (Led_Rot, 128-val);
delay (1);
}
}

Beispielprogramm PWMDownload:

KY-009_PWM.zip

Anschlussbelegung Arduino:

LED Rot = [Pin 10]
LED Grün = [Pin 11]
LED Blau = [Pin 12]
Sensor GND = [Pin GND]

Codebeispiel Raspberry Pi

Codebeispiel ON/OFF

Dieses Codebeispiel zeigt auf, wie die integrierten LEDs mittels eines definierbaren Ausgangspins
abwechselnd, in 3 Sekunden Takt, angeschaltet werden können.

# Benoetigte Module werden importiert und eingerichtet
import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

# Hier werden die Ausgangs-Pin deklariert, an dem die LEDs angeschlossen sind.
LED_ROT = 6
LED_GRUEN = 5
LED_BLAU = 4

GPIO.setup(LED_ROT, GPIO.OUT, initial= GPIO.LOW)
GPIO.setup(LED_GRUEN, GPIO.OUT, initial= GPIO.LOW)
GPIO.setup(LED_BLAU, GPIO.OUT, initial= GPIO.LOW)

print "LED-Test [druecken Sie STRG+C, um den Test zu beenden]"

# Hauptprogrammschleife
try:
while True:
print("LED ROT 3 Sekunden an")
GPIO.output(LED_ROT,GPIO.HIGH) #LED wird eingeschaltet
GPIO.output(LED_GRUEN,GPIO.LOW) #LED wird eingeschaltet
GPIO.output(LED_BLAU,GPIO.LOW) #LED wird eingeschaltet
time.sleep(3) # Wartemodus fuer 4 Sekunden
print("LED GRUEN 3 Sekunden an")
GPIO.output(LED_ROT,GPIO.LOW) #LED wird eingeschaltet
GPIO.output(LED_GRUEN,GPIO.HIGH) #LED wird eingeschaltet
GPIO.output(LED_BLAU,GPIO.LOW) #LED wird eingeschaltet
time.sleep(3) #Wartemodus fuer 3 Sekunden
print("LED BLAU 3 Sekunden an")
GPIO.output(LED_ROT,GPIO.LOW) #LED wird eingeschaltet
GPIO.output(LED_GRUEN,GPIO.LOW) #LED wird eingeschaltet
GPIO.output(LED_BLAU,GPIO.HIGH) #LED wird eingeschaltet

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 43 von 227

KY-009 RGB LED SMD Modul

time.sleep(3) #Wartemodus fuer 3 Sekunden

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Beispielprogramm ON/OFF Download

KY009_RPi_ON-OFF.zip

Zu starten mit dem Befehl:

sudo python KY009_RPI_ON-OFF.py

Codebeispiel PWM

Mittels Puls-Weiten-Modulation [PWM] lässt sich die Helligkeit einer LED regulieren - dabei wird die LED in
bestimmten Zeitintervallen ein und ausgeschaltet, wobei das Verhältnis der Einschalt- und Ausschaltzeit
einer relativen Helligkeit entspricht - aufgrund der Trägheit des menschlichen Sehvermögens, interpretieren
die menschlichen Augen ein solches Ein-/Ausschaltverhalten als Helligkeitsänderung. Nähere Informationen
zu diesem Thema finden Sie in diesem [ ].Artikel von mikrokontroller.net

In diesem Modul sind mehrere LEDs integriert - durch die Überlagerung von unterschiedlichen
Helligkeitsstufen lassen sich somit verschiedene Farben kreieren. Dieses wird im folgenden Codebeispiel
gezeigt.Im Raspberry Pi ist nur ein Hardware-PWM Channel uneingeschränkt auf die GPIO-Pins
hinausgeführt, weswegen im vorliegenden Beispiel auf Software-PWM zurückgegriffen wird.

# Benoetigte Module werden importiert und eingerichtet
import random, time
import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)

# Hier werden die Ausgangs-Pin deklariert, an dem die LEDs angeschlossen sind.
LED_Rot = 6
LED_Gruen = 5
LED_Blau = 4

# Set pins to output mode
GPIO.setup(LED_Rot, GPIO.OUT)
GPIO.setup(LED_Gruen, GPIO.OUT)
GPIO.setup(LED_Blau, GPIO.OUT)

Freq = 100 #Hz

# Die jeweiligen Farben werden initialisiert.
ROT = GPIO.PWM(LED_Rot, Freq)
GRUEN = GPIO.PWM(LED_Gruen, Freq)
BLAU = GPIO.PWM(LED_Blau, Freq)
ROT.start(0)
GRUEN.start(0)
BLAU.start(0)

# Diese Funktion generiert die eigentliche Farbe
# Mittels der jeweiligen Farbvariable, kann die Farbintensitaet geaendert werden
# Nachdem die Farbe eingestellt wurde, wird mittels "time.sleep" die Zeit definiert,
# wie lang die besagte Farbe angezeigt werden soll

def LED_Farbe(Rot, Gruen,Blau, pause):

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 44 von 227

KY-009 RGB LED SMD Modul

Beispielprogramm PWMDownload:

KY-009_RPi_PWM.zip

Zu starten mit dem Befehl:

sudo python KY-009_RPi_PWM.py

Anschlussbelegung Raspberry Pi:

LEDRot = GPIO6 [Pin 22]
LEDGrün = GPIO5 [Pin 18]
LEDBlau = GPIO4 [Pin 16]
Sensor GND = Masse [Pin 6]

ROT.ChangeDutyCycle(Rot)
GRUEN.ChangeDutyCycle(Gruen)
BLAU.ChangeDutyCycle(Blau)
time.sleep(pause)

ROT.ChangeDutyCycle(0)
GRUEN.ChangeDutyCycle(0)

print "LED-Test [druecken Sie STRG+C, um den Test zu beenden]"

# Hauptprogrammschleife:
# Diese hat die Aufgabe fuer jede einzelne Farbe eine eigene Variable zu erstellen
# und mittels einer For-Schleife die Farbintensitaet jeder einzelnen Farbe von 0-100% zu druchlaufen

# Durch die Mischungen der verschiedenen Helligkeitsstufen der jeweiligen Farben
# entsteht somit ein Farbverlauf

try:
while True:
for x in range(0,2):
for y in range(0,2):
for z in range(0,2):
print (x,y,z)
for i in range(0,101):
LED_Farbe((x*i),(y*i),(z*i),.02)

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 45 von 227

KY-010 Lichtschranken-Modul

KY-010 Lichtschranken-Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 2

5 Codebeispiel Raspberry Pi ................................................................................................................................... 3

Bild

Technische Daten / Kurzbeschreibung

Die Verbindung zwischen zwei Eingangspins wird unterbrochen, falls die Lichtschranke im Schalter ebenfalls
unterbrochen wird.

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 46 von 227

KY-010 Lichtschranken-Modul

Pin-Belegung

Codebeispiel Arduino

Hier bei handelt es sich um ein Beispielprogramm, welches eine LED zum Leuchten bringt, wenn am Sensor
ein Signal detektiert wurde. Als LED können z.B. auch unter anderem die Module KY-011, KY-016 oder KY­029 verwendet werden.

int Led = 13 ;// Deklaration des LED-Ausgangspin
int Sensor = 10; // Deklaration des Sensor-Eingangspin
int val; // Temporaere Variable

void setup ()
{
pinMode (Led, OUTPUT) ; // Initialisierung Ausgangspin
pinMode (Sensor, INPUT) ; // Initialisierung Sensorpin
}

void loop ()
{
val = digitalRead (Sensor) ; // Das gegenwärtige Signal am Sensor wird ausgelesen

if (val == HIGH) // Falls ein Signal erkannt werden konnte, wird die LED eingeschaltet.
{
digitalWrite (Led, HIGH);
}
else
{
digitalWrite (Led, LOW);
}
}

Anschlussbelegung Arduino:

LED + = [Pin 13]

LED - = [Pin GND]

Sensor Signal = [Pin 10]

Sensor+V = [Pin 5V]

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 47 von 227

KY-010 Lichtschranken-Modul

Sensor - = [Pin GND]

Beispielprogramm Download

SensorTest_Arduino_inverted.zip

Codebeispiel Raspberry Pi

Programmierbeispiel in der Programmiersprache Python

Anschlussbelegung Raspberry Pi:

Signal = GPIO24 [Pin 18]

+V = 3,3V [Pin 1]

GND = Masse [Pin 6]

Beispielprogramm Download

SensorTest_RPi_inverted.zip

Zu starten mit dem Befehl:

sudo python SensorTest_RPi_inverted.py

# Benoetigte Module werden importiert und eingerichtet
import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

# Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist.
#Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert GPIO_PIN = 24
GPIO.setup(GPIO_PIN, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)

print "Sensor-Test [druecken Sie STRG+C, um den Test zu beenden]"

# Diese AusgabeFunktion wird bei Signaldetektion ausgefuehrt
def ausgabeFunktion(null):
print("Signal erkannt")

# Beim Detektieren eines Signals (steigende Signalflanke) wird die Ausgabefunktion ausgeloest

GPIO.add_event_detect(GPIO_PIN, GPIO.RISING, callback=ausgabeFunktion, bouncetime=100)

# Hauptprogrammschleife
try:
while True:
time.sleep(1)

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 48 von 227

KY-011 2-Farben - Rot+Grün- 5mm LED Modul

KY-011 2-Farben - Rot+Grün- 5mm LED Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 2

5 Codebeispiel Raspberry Pi ................................................................................................................................... 4

Bild

Technische Daten / Kurzbeschreibung

LED-Modul welche eine rote und grüne LED beinhaltet. Diese sind mittels gemeinsamer Kathode miteinander
verbunden. Je nach Eingangsspannung, werden Vorwiderstände benötigt

Vf [typ]= 2,0-2,5V

If= 20mA

Vorwiderstände:

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 49 von 227

KY-011 2-Farben - Rot+Grün- 5mm LED Modul

Rf (3,3V) [ ]= 120ΩGrün

Rf (3,3V) [ ]= 120ΩRot

[z.B. beim Einsatz mit ARM CPU-Kern basierten Mikrokontrollern wie ]Raspberry-Pi

Rf (5V) [ ] = 220ΩGrün

Rf (5V) [ ] = 220ΩRot 

[z.B. beim Einsatz mit Atmel Atmega basierten Mikrokontrollern wie ]Arduino

Pin-Belegung

Codebeispiel Arduino

Codebeispiel ON/OFF

Dieses Codebeispiel zeigt auf, wie die integrierten LEDs mittels eines definierbaren Ausgangspins
abwechselnd, in 3 Sekunden Takt, angeschaltet werden können.

int Led_Rot = 10;
int Led_Gruen = 11;

void setup ()
{
// Initialisierung Ausgangspins für die LEDs
pinMode (Led_Rot, OUTPUT);
pinMode (Led_Gruen, OUTPUT);
}

void loop () //Hauptprogrammschleife
{
digitalWrite (Led_Rot, HIGH); // LED wird eingeschaltet
digitalWrite (Led_Gruen, LOW); // LED wird eingeschaltet

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 50 von 227

KY-011 2-Farben - Rot+Grün- 5mm LED Modul

Beispielprogramm ON/OFF Download:

KY-011_LED_ON-OFF.zip

Codebeispiel PWM

Mittels Puls-Weiten-Modulation [PWM] lässt sich die Helligkeit einer LED regulieren - dabei wird die LED in
bestimmten Zeitintervallen ein und ausgeschaltet, wobei das Verhältnis der Einschalt- und Ausschaltzeit
einer relativen Helligkeit entspricht - aufgrund der Trägheit des menschlichen Sehvermögens, interpretieren
die menschlichen Augen ein solches Ein-/Ausschaltverhalten als Helligkeitsänderung. Nähere Informationen
zu diesem Thema finden Sie in diesem [ ].Artikel von mikrokontroller.net

In diesem Modul sind mehrere LEDs integriert - durch die Überlagerung von unterschiedlichen
Helligkeitsstufen lassen sich somit verschiedene Farben kreieren. Dieses wird im folgenden Codebeispiel
gezeigt.

Beispielprogramm PWMDownload:

KY-011_PWM.zip

Anschlussbelegung Arduino:

delay (3000); // Wartemodus für 3 Sekunden

digitalWrite (Led_Rot, LOW); // LED wird eingeschaltet
digitalWrite (Led_Gruen, HIGH); // LED wird eingeschaltet
delay (3000); // Wartemodus für weitere zwei Sekunden in denen die LEDs dann umgeschaltet sind
}

int Led_Rot = 10;
int Led_Gruen = 11;

int val;

void setup () {
// Initialisierung Ausgangspins für die LEDs
pinMode (Led_Rot, OUTPUT);
pinMode (Led_Gruen, OUTPUT);
}
void loop () {

// Innerhalb einer For-Schleife werden den beiden LEDs verschiedene PWM-Werte uebergeben
// Dadurch entsteht ein Farbverlauf, in dem sich durch das Vermischen unterschiedlicher
// Helligkeitstufen der beiden integrierten LEDs, unterschiedliche Farben entstehen

for (val = 255; val> 0; val--)
{
analogWrite (Led_Gruen, val);
analogWrite (Led_Rot, 255-val);
delay (15);
}
// In der zweiten For-Schleife wird der Farbverlauf rückwärts durchgegangen
for (val = 0; val <255; val++)
{
analogWrite (Led_Gruen, val);
analogWrite (Led_Rot, 255-val);
delay (15);
}
}

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 51 von 227

KY-011 2-Farben - Rot+Grün- 5mm LED Modul

LED Grün = [Pin 10]
LED Rot = [Pin 11]
Sensor GND = [Pin GND]

Codebeispiel Raspberry Pi

Codebeispiel ON/OFF

Dieses Codebeispiel zeigt auf, wie die integrierten LEDs mittels eines definierbaren Ausgangspins
abwechselnd, in 3 Sekunden Takt, angeschaltet werden können.

Beispielprogramm ON/OFF Download

KY011_RPI_ON-OFF.zip

Zu starten mit dem Befehl:

sudo python KY011_RPI_ON-OFF.py

Codebeispiel PWM

Mittels Puls-Weiten-Modulation [PWM] lässt sich die Helligkeit einer LED regulieren - dabei wird die LED in
bestimmten Zeitintervallen ein und ausgeschaltet, wobei das Verhältnis der Einschalt- und Ausschaltzeit
einer relativen Helligkeit entspricht - aufgrund der Trägheit des menschlichen Sehvermögens, interpretieren
die menschlichen Augen ein solches Ein-/Ausschaltverhalten als Helligkeitsänderung. Nähere Informationen
zu diesem Thema finden Sie in diesem [ ].Artikel von mikrokontroller.net

# Benoetigte Module werden importiert und eingerichtet
import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

# Hier werden die Ausgangs-Pin deklariert, an dem die LEDs angeschlossen sind.
LED_ROT = 5
LED_GRUEN = 4
GPIO.setup(LED_ROT, GPIO.OUT, initial= GPIO.LOW)
GPIO.setup(LED_GRUEN, GPIO.OUT, initial= GPIO.LOW)

print "LED-Test [druecken Sie STRG+C, um den Test zu beenden]"

# Hauptprogrammschleife
try:
while True:
print("LED ROT 3 Sekunden an")
GPIO.output(LED_ROT,GPIO.HIGH) #LED wird eingeschaltet
GPIO.output(LED_GRUEN,GPIO.LOW) #LED wird eingeschaltet
time.sleep(3) # Wartemodus fuer 4 Sekunden
print("LED GRUEN 3 Sekunden an")
GPIO.output(LED_ROT,GPIO.LOW) #LED wird eingeschaltet
GPIO.output(LED_GRUEN,GPIO.HIGH) #LED wird eingeschaltet

 #Wartemodus fuer weitere zwei Sekunden, in denen die LED Dann ausgeschaltet ist
time.sleep(3)

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 52 von 227

KY-011 2-Farben - Rot+Grün- 5mm LED Modul

In diesem Modul sind mehrere LEDs integriert - durch die Überlagerung von unterschiedlichen
Helligkeitsstufen lassen sich somit verschiedene Farben kreieren. Dieses wird im folgenden Codebeispiel
gezeigt.Im Raspberry Pi ist nur ein Hardware-PWM Channel uneingeschränkt auf die GPIO-Pins
hinausgeführt, weswegen im vorliegenden Beispiel auf Software-PWM zurückgegriffen wird.

Beispielprogramm PWMDownload:

KY011_RPI_PWM.zip

# Benoetigte Module werden importiert und eingerichtet
import random, time
import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)

# Hier werden die Ausgangs-Pin deklariert, an dem die LEDs angeschlossen sind.
LED_Rot = 5
LED_Gruen = 4

# Set pins to output mode
GPIO.setup(LED_Rot, GPIO.OUT)
GPIO.setup(LED_Gruen, GPIO.OUT)

Freq = 100 #Hz

# Die jeweiligen Farben werden initialisiert.
ROT = GPIO.PWM(LED_Rot, Freq)
GRUEN = GPIO.PWM(LED_Gruen, Freq)
ROT.start(0)
GRUEN.start(0)

# Diese Funktion generiert die eigentliche Farbe
# Mittels der jeweiligen Farbvariable, kann die Farbintensitaet geaendert werden
# Nachdem die Farbe eingestellt wurde, wird mittels "time.sleep" die Zeit definiert,
# wie lang die besagte Farbe angezeigt werden soll

def LED_Farbe(Rot, Gruen, pause):
ROT.ChangeDutyCycle(Rot)
GRUEN.ChangeDutyCycle(Gruen)
time.sleep(pause)

ROT.ChangeDutyCycle(0)
GRUEN.ChangeDutyCycle(0)

print "LED-Test [druecken Sie STRG+C, um den Test zu beenden]"

# Hauptprogrammschleife:
# Diese hat die Aufgabe fuer jede einzelne Farbe eine eigene Variable zu erstellen
# und mittels einer For-Schleife die Farbintensitaet jeder einzelnen Farbe von 0-100% zu durchlaufen

# Durch die Mischungen der verschiedenen Helligkeitsstufen der jeweiligen Farben
# entsteht somit ein Farbverlauf

try:
while True:
for x in range(0,2):
for y in range(0,2):
print (x,y)
for i in range(0,101):
LED_Farbe((x*i),(y*i),.02)

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 53 von 227

KY-011 2-Farben - Rot+Grün- 5mm LED Modul

Zu starten mit dem Befehl:

sudo python KY011_RPI_PWM.py

Anschlussbelegung Raspberry Pi:

LEDGruen = GPIO4 [Pin 16]
LEDRot = GPIO5 [Pin 18]

Sensor GND = Masse [Pin 6]

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 54 von 227

KY-012 Aktives Piezo-Buzzer Modul

KY-012 Aktives Piezo-Buzzer Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 2

5 Codebeispiel Raspberry Pi ................................................................................................................................... 3

Bild

Technische Daten / Kurzbeschreibung

Mit Spannung betrieben, erzeugt der aktive Buzzer einen Ton mit der Frequenz von 2,5kHz

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 55 von 227

KY-012 Aktives Piezo-Buzzer Modul

Pin-Belegung

Codebeispiel Arduino

Das aktive Buzzer-Modul benötigt, im Gegensatz zum passiven Modul (KY-006) keine Rechteckspannung um
einen Ton zu erzeugen - wird an seinem Signal-Pin eine Spannung von min. 3,3V angelegt, so wird im Buzzer
die benötigte Rechteckspannung selbstständig erzeugt.

Dieses Codebeispiel zeigt auf, wie der Buzzermittels eines definierbaren Ausgangspins abwechselnd für
VierSekunden ein- und danach zwei Sekunden ausgeschaltet werden kann.

Anschlussbelegung Arduino:

Sensor Signal = [Pin 13]

Sensor[N.C] =

Sensor GND = [Pin GND]

Beispielprogramm Download:

KY-0012_AktiverBuzzer.zip

int Buzzer = 13;

void setup ()
{
pinMode (Buzzer, OUTPUT); // Initialisierung Ausgangspin für den Buzzer
}

void loop () //Hauptprogrammschleife
{
digitalWrite (Buzzer, HIGH); // Buzzer wird eingeschaltet
delay (4000); // Wartemodus für 4 Sekunden
digitalWrite (Buzzer, LOW); // Buzzer wird ausgeschaltet
delay (2000); // Wartemodus für weitere zwei Sekunden in denen die LED dann ausgeschaltet ist
}

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 56 von 227

KY-012 Aktives Piezo-Buzzer Modul

Codebeispiel Raspberry Pi

Programmierbeispiel in der Programmiersprache Python

Das aktive Buzzer-Modul benötigt, im Gegensatz zum passiven Modul (KY-006) keine Rechteckspannung um
einen Ton zu erzeugen - wird an seinem Signal-Pin eine Spannung von min. 3,3V angelegt, so wird im Buzzer
die benötigte Rechteckspannung selbstständig erzeugt.

Dieses Codebeispiel zeigt auf, wie der Buzzermittels eines definierbaren Ausgangspins abwechselnd für
VierSekunden ein- und danach zwei Sekunden ausgeschaltet werden kann.

Anschlussbelegung Raspberry Pi:

Sensor Signal = GPIO24 [Pin 18]

Sensor [N.C] =

Sensor GND = Masse [Pin 6]

Beispielprogramm Download

LedTest_RPi_4On_2Off.zip

Zu starten mit dem Befehl:

sudo python LedTest_RPi_4On_2Off.py

# Benoetigte Module werden importiert und eingerichtet
import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

# Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist.
Buzzer_PIN = 24
GPIO.setup(Buzzer_PIN, GPIO.OUT, initial= GPIO.LOW)

print "Buzzer-Test [druecken Sie STRG+C, um den Test zu beenden]"

# Hauptprogrammschleife
try:
while True:
print("Buzzer 4 Sekunden an")
GPIO.output(Buzzer_PIN,GPIO.HIGH) #Buzzer wird eingeschaltet
time.sleep(4) #Wartemodus für 4 Sekunden
print("Buzzer 2 Sekunden aus")
GPIO.output(Buzzer_PIN,GPIO.LOW) #Buzzer wird ausgeschaltet

 #Wartemodus für weitere zwei Sekunden, in denen die LED Dann ausgeschaltet ist
time.sleep(2)

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 57 von 227

KY-013 Temperatur-Sensor Modul

KY-013 Temperatur-Sensor Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 3

4 Codebeispiel Arduino ........................................................................................................................................... 4

5 Codebeispiel Raspberry Pi ................................................................................................................................... 4

Bild

Technische Daten / Kurzbeschreibung

Temperaturmessbereich: -55°C / +125°C

Dieses Modul beinhaltet einen NTC Thermistor—dieser hat bei höherer Temperatur einen immer weniger
werdenden Widerstandswert.

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 58 von 227

KY-013 Temperatur-Sensor Modul

Diese Änderung des Widerstands lässt sich mathematisch annähern und in einen linearen Verlauf
umrechnen und denTemperaturkoeffizienten (Abhängigkeit von Widerstandsänderung zur
Temperaturänderung) bestimmen.Mittels diesen lässt sich somit dann immer die aktuelle Temperatur
errechnen, wenn man den aktuellen Widerstand kennt.

Dieser Widerstand lässt sich mit Hilfe eines Spannungsteilers bestimmen, wo sich eine bekannte Spannung
übereinenbekannten und einen unbekannten (veränderlichen) Widerstand aufteilt. Mittels dieser
gemessenen Spannung lässt sich dann der Widerstand berechnen - die genaue Berechnung ist in den unten
stehenden Codebeispielen enthalten.

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 59 von 227

KY-013 Temperatur-Sensor Modul

Pin-Belegung

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 60 von 227

KY-013 Temperatur-Sensor Modul

Codebeispiel Arduino

Das Programm misst den aktuellen Spannungswert am NTC, berechnet die Temperatur und übersetzt das
Ergebnis in °C für die serielle Ausgabe

Anschlussbelegung Arduino:

Sensor +V = [Pin 5V]
Sensor GND = [Pin GND]
Sensor Signal = [Pin A5]

Beispielprogramm Download

KY-013_TemperaturSensor.zip

Codebeispiel Raspberry Pi

!! !! !! !!Achtung Analoger Sensor Achtung

#include <math.h>

int sensorPin = A5; // Hier wird der Eingangs-Pin deklariert

// Diese Funktion übersetzt den aufgenommenen analogen Messwert
// in die entsprechende Temperatur in °C und gibt diesen aus
double Thermistor(int RawADC)
{

double Temp;
Temp = log(10000.0 * ((1024.0 / RawADC - 1)));
Temp = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Temp * Temp )) * Temp );
Temp = Temp - 273.15; // Konvertierung von Kelvin in Celsius
return Temp;

}

// Serielle Ausgabe in 9600 Baud
void setup()
{
Serial.begin(9600);
}

// Das Programm misst den aktuellen Spannungswert am NTC
// und übersetzt das Ergebnis in °C für die serielle Ausgabe
void loop()
{
int readVal = analogRead(sensorPin);
double temp = Thermistor(readVal);

// Ausgabe auf die serielle Schnittstelle
Serial.print("Aktuelle Temperatur ist:");
Serial.print(temp);
Serial.print(char(186)); //Ausgabe <°> Symbol
Serial.println("C");
Serial.println("---------------------------------------");

delay(500);
}

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 61 von 227

KY-013 Temperatur-Sensor Modul

Der Raspberry Pi besitzt im Gegensatz zum Arduino keine analogen Eingänge bzw. es ist kein ADC (analog
digital Converter) im Chip des Raspberry Pi's integriert. Dies schränkt den Raspberry Pi ein, wenn man
Sensoren einsetzen möchte, wo nicht digital Werte ausgegeben werden [Spannungswert überschritten ->
digital EIN | Spannungswert unterschritten -> digital AUS | Beispiel: Knopf gedrückt [ ] Knopf losgelassen [EIN

]], sondern es sich hier um einen kontinuierlichen veränderlichen Wert handeln sollte (Beispiel: AUS

Potentiometer -> Andere Position = Anderer Spannungswert)

Um diese Problematik zu umgehen, besitzt unser mit dem ein Modul mit 16 Bit

Sensorkit X40

KY-053

genauen ADC, welches Sie am Raspberry nutzen können, um diesen um 4 analoge Eingänge erweitern zu
können. Dieses wird per I2C an den Raspberry Pi angeschlossen, übernimmt die analoge Messung und gibt
den Wert digital an den Raspberry Pi weiter.

Somit empfehlen wir, bei analogen Sensoren dieses Sets das KY-053 Modul mit dem besagten ADC
dazwischenzuschalten. Nähere Informationen finden Sie auf der Informationsseite zum  Analog KY-053

Digital Converter

!! !! !! !!Achtung Analoger Sensor Achtung

Das Programm nutzt zur Ansteuerung des ADS1115 ADC die entsprechenden ADS1x15 und I2C Python­Libraries der Firma Adafruit. Diese wurden unter dem folgenden Link [https://github.com/adafruit/Adafruit-

] unter der BSD-Lizenz [ ] veröffentlicht. Die benötigten Libraries sind im Raspberry-Pi-Python-Code Link

unteren Download-Paket enthalten.

Das Programm misst mit Hilfe des ADS1115 ADC den aktuellen Spannungswert am ADC, berechnet daraus
den aktuellen Widerstand des NTC, berechnet mit Hilfe vorab für diesen Sensor bestimmter Werte die
Temperatur und gibt diese in die Konsole aus.

# coding=utf-8
#!/usr/bin/python

# Dieser Code nutzt die ADS1115 und die I2C Python Library fuer den Raspberry Pi
# Diese ist unter folgendem Link unter der BSD Lizenz veroeffentlicht
# [https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code]
from Adafruit_ADS1x15 import ADS1x15
from time import sleep

# Weitere benoetigte Module werden importiert und eingerichtet
import time, signal, sys, os, math
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)

# Benutzte Variablen werden initialisiert
delayTime = 0.2

# Adresszuweisung ADS1x15 ADC

####################################################################################################
### Copyright by Joy-IT
### Published under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License

### Commercial use only after permission is requested and granted
###
### KY-013 Temperatur Sensor - Raspberry Pi Python Code Example
### #################################################################################################

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 62 von 227

KY-013 Temperatur-Sensor Modul

except KeyboardInterrupt:
GPIO.cleanup()

Anschlussbelegung Raspberry Pi:

Sensor

+V = 3,3V [Pin 1 (RPi)]
GND = Masse [Pin 06 (RPi)]

ADS1015 = 0x00 # 12-bit ADC
ADS1115 = 0x01 # 16-bit

# Verstaerkung (Gain) wird ausgewaehlt
gain = 4096 # +/- 4.096V
# gain = 2048 # +/- 2.048V
# gain = 1024 # +/- 1.024V
# gain = 512 # +/- 0.512V
# gain = 256 # +/- 0.256V

# Abtasterate des ADC (SampleRate) wird ausgewaehlt
# sps = 8 # 8 Samples pro Sekunde
# sps = 16 # 16 Samples pro Sekunde
# sps = 32 # 32 Samples pro Sekunde
# sps = 64 # 64 Samples pro Sekunde
# sps = 128 # 128 Samples pro Sekunde
# sps = 250 # 250 Samples pro Sekunde
# sps = 475 # 475 Samples pro Sekunde
sps = 860 # 860 Samples pro Sekunde

# ADC-Channel (1-4) wird ausgewaehlt
adc_channel = 0 # Channel 0
# adc_channel = 1 # Channel 1
# adc_channel = 2 # Channel 2
# adc_channel = 3 # Channel 3

# Hier wird der ADC initialisiert - beim KY-053 verwendeten ADC handelt es sich um einen ADS1115 Chipsatz

adc = ADS1x15(ic=ADS1115)

####################################################################################################

# ########
# Hauptprogrammschleife
# ########
# Das Programm misst mit Hilfe des ADS1115 ADC den aktuellen Spannungswert am ADC,
# berechnet daraus den aktuellen Widerstand des NTC, berechnet mit Hilfe vorab für diesen Sensor bestimmter Werte

# die Temperatur und gibt diese in die Konsole aus

try:
while True:
#Aktuelle Werte werden aufgenommen...
voltage = adc.readADCSingleEnded(adc_channel, gain, sps)
# ... umgerechnet ...
temperatur = math.log((10000/voltage)*(3300-voltage))
temperatur = 1/(0.001129148+(0.000234125+(0.0000000876741*temperatur*temperatur))*temperatur);
temperatur = temperatur - 273.15;
# ... und ausgegeben
print "Temperatur:", temperatur,"°C"

print "---------------------------------------"

# Delay
time.sleep(delayTime)

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 63 von 227

KY-013 Temperatur-Sensor Modul

analoges Signal = Analog 0 [Pin A0 (ADS1115 - KY-053)]

ADS1115 - KY-053:

VDD = 3,3V [Pin 17]
GND = Masse [Pin 09]
SCL = GPIO03 / SCL [Pin 05]
SDA = GPIO02 / SDA [Pin 03]

A0 = s.o. [Sensor: analoges Signal]

Beispielprogramm Download

KY-013_RPi_TemperaturSensor.zip

Zu starten mit dem Befehl:

sudo python KY-013_RPi_TemperaturSensor.py

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 64 von 227

KY-015 Kombi-Sensor Temperatur+Feuchtigkeit

KY-015 Kombi-Sensor Temperatur+Feuchtigkeit

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Software-Beispiel Arduino .................................................................................................................................... 2

5 Software-Beispiel Raspberry Pi ............................................................................................................................ 3

Bild

Technische Daten / Kurzbeschreibung

Chipsatz: DHT11 | Kommunikationsprotokoll: 1-Wire Messbereich Luftfeuchtigkeit: 20-90%RH Messbereich
Temperatur: 0-50°C

Vorteile dieses Sensors ist die Kombination von Temperaturmessung und Luftfeuchtigkeitsmessung in einer
kompakten Bauform - der Nachteil ist jedoch die geringe Abtastrate der Messung, so dass nur jede 2
Sekunden ein neues Messergebnis zur Verfügung steht - dieser Sensorist somit sehr gut für Langzeit­Messungen geeignet.

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 65 von 227

KY-015 Kombi-Sensor Temperatur+Feuchtigkeit

Pin-Belegung

Software-Beispiel Arduino

Dieser Sensor gibt sein Messergebnis nicht als analoges Signal auf einen Ausgangspin aus, sondern
kommuniziert diesen digital kodiert.

Zur Ansteuerung dieses Sensormoduls gibt es mehrere Möglichkeiten - als besonders zugänglich hat sich die
Adafruit_DHT Library erwiesen, die die Firma Adafruit unter dem folgenden unter der OpenSource Link MIT-

veröffentlicht hat.Lizenz

Das unten stehende Beispiel verwendet diese besagte Library - hierzu empfehlen wir diese von Github
herunterzuladen, zu entpacken und im Arduino-Library-Ordner, welcher sich standardmäßig unter (C:
\Benutzer\[Benutzername]\Dokumente\Arduino\libraries) befindet, zu kopieren, damit diese für dieses
Codebeispiel und folgende Projekte zur Verfügung steht. Alternativ ist diese auch im unten stehenden
Download Paket ebenfalls enthalten.

// Adafruit_DHT Library wird eingefügt
#include "DHT.h"

// Hier kann der jeweilige EingangsPin deklariert werden
#define DHTPIN 2

// Der Sensor wird initialisiert
#define DHTTYPE DHT11 // DHT 11
DHT dht(DHTPIN, DHTTYPE);

void setup()
{
Serial.begin(9600);
Serial.println("KY-015 Test - Temperatur und Luftfeuchtigkeits-Test:");

// Messung wird gestartet
dht.begin();
}

// Hauptprogrammschleife
// Das Programm startet die Messung und liest die gemessenen Werte aus
// Zwischen den Messungen wird eine Pause von 2 Sekunden eingelegt,

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 66 von 227

KY-015 Kombi-Sensor Temperatur+Feuchtigkeit

// Zwischen den Messungen wird eine Pause von 2 Sekunden eingelegt,
// damit beim nächsten Druchlauf eine neue Messung erfasst werden kann.

void loop() {

// Zwei Sekunden Pause zwischen den Messungen
delay(2000);

// Luftfeuchtigkeit wird gemessen
float h = dht.readHumidity();
// Temperatur wird gemessen
float t = dht.readTemperature();

// Hier wird überprüft, ob die Messungen fehlerfrei druchgelaufen sind
// Bei Detektion eines Fehlers, wird hier eine Fehelrmeldung ausgegeben
if (isnan(h) || isnan(t)) {
Serial.println("Fehler beim Auslesen des Sensors");
return;
}

// Ausgabe in die serrielle Konsole
Serial.println("-----------------------------------------------------------");
Serial.print("Luftfeuchtigkeit: ");
Serial.print(h);
Serial.print(" %\t");
Serial.print("Temperatur: ");
Serial.print(t);
Serial.print(char(186)); //Ausgabe <°> Symbol
Serial.println("C ");
Serial.println("-----------------------------------------------------------");
Serial.println(" ");
}

Bitte beachten Sie, dass der Sensor nur etwa alle 2 Sekunden ein neues Messergebnis zur
Verfügung stellt; also eher für Langzeit-Aufnahmen ausgelegt ist

Beispielprogramm Download:

KY-015-Kombi-Sensor_Temperatur_Feuchtigkeit.zip

Anschlussbelegung Arduino:

GND = [Pin GND]

+V = [Pin 5V]

Signal = [Pin D2]

Software-Beispiel Raspberry Pi

Das Programm nutzt zur Ansteuerung des DHT11-Sensors, der auf diesem Sensor-Modul verbaut ist, die
entsprechende Adafruit_Python_DHTLibrary der Firma Adafruit. Diese wurden unter dem folgenden Link
unter der veröffentlicht.MIT OpenSource-Lizenz

Diese muss vorab erst installiert werden. Hierzu muss folgendermaßen vorgegangen werden:

Zuerst muss, falls dies nicht auf dem Raspberry Pi geschehen ist, die GitHub-Software installiert werden:

sudo apt-get install git

Hierzu muss der Raspberry Pi mit dem Internet verbunden sein. Mit dem Befehl...

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 67 von 227

KY-015 Kombi-Sensor Temperatur+Feuchtigkeit

git clone https://github.com/adafruit/Adafruit_Python_DHT.git

... kann die aktuelle Version der Adafruit_BM085 Library heruntergeladen und entpackt werden

Danach wechseln wir mit...

cd Adafruit_Python_BMP/

... in den heruntergeladenen Ordner und intallieren mit...

sudo python setup.py install

... die Library. Hiernach kann die Library genutzt werden.

Damit der Raspberry Pi mit dem Sensor auf dem I2C-Bus kommunizieren kann, muss auch vorab die I2C­Funktion beim Raspberry Pi aktiviert werden. Hierzu müssen folgende Zeilen am Ende der Datei "/boot
/config.txt" hinzugefügt werden:

dtparam=i2c_arm=on

Die Datei kann mit folgenden Befehl editiert werden:

sudo nano /boot/config.txt

Mit der Tastenfolge [Strg+X -> Y -> Enter] kann die Datei, nach dem hinzufügen der Zeile am unteren Ende,
gespeichert und geschlossen werden.

Außerdem werden zusätzliche Bibliotheken benötigt, um I2C innerhalb Python nutzen zu können. Um diese
zu installieren muss folgender Befehl in die Konsole eingegeben werden:

sudo apt-get install python-smbus i2c-tools -y

Hiernach kann das folgende Python-Code Beispiel verwendet werden. Das Programm startet die Messung
am Sensor und gibt die gemessenen Werte fürden Luftdruck, der Temperatur und der Höhe überm
Meeresspiegel aus.

#!/usr/bin/python
# coding=utf-8

# Benoetigte Module werden importiert und eingerichtet
import RPi.GPIO as GPIO
import Adafruit_DHT
import time

# Die Pause von zwei Sekunden zwischen den Messungen wird hier eingestellt
sleeptime = 2

# Sensor should be set to Adafruit_DHT.DHT11,
# Adafruit_DHT.DHT22, or Adafruit_DHT.AM2302.
DHTSensor = Adafruit_DHT.DHT11

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 68 von 227

KY-015 Kombi-Sensor Temperatur+Feuchtigkeit

Bitte beachten Sie, dass der Sensor nur etwa alle 2 Sekunden ein neues Messergebnis zur
Verfügung stellt; also eher für Langzeit-Aufnahmen ausgelegt ist

Anschlussbelegung Raspberry Pi:

GND = GND [Pin 06]

+V = 3,3V [Pin 01]

Signal = GPIO23 [Pin 16]

Beispielprogramm Download

KY-015-RPi_Kombi-Sensor_Temperatur_Feuchtigkeit.zip

Zu starten mit dem Befehl:

sudo python KY-015-RPi_Kombi-Sensor_Temperatur_Feuchtigkeit.py

# Hier kann der Pin deklariert werden, an dem das Sensormodul angeschlossen ist
GPIO_Pin = 23

print('KY-015 Sensortest - Temperatur und Luftfeuchtigkeit')

try:
while(1):
# Messung wird gestartet und das Ergebnis in die entsprechenden Variablen geschrieben

Luftfeuchte, Temperatur = Adafruit_DHT.read_retry(DHTSensor, GPIO_Pin)

print("-----------------------------------------------------------------")
if Luftfeuchte is not None and Temperatur is not None:

# Das gemessene Ergebnis wird in der Konsole ausgegeben
print('Temperatur = {0:0.1f}°C | rel. Luftfeuchtigkeit = {1:0.1f}%'.format(Temperatur, Luftfeuchte))

# Da der Raspberry Pi aufgrund des Linux-Betriebsystems für Echtzeitanwendungen benachteiligt ist,
# kann es sein, dass aufgrund von Timing Problemen die Kommunikation scheitern kann.
# In dem Falle wird eine Fehlermeldung ausgegeben - ein Ergebnis sollte beim nächsten Versuch vorliegen
else:
print('Fehler beim Auslesen - Bitte warten auf nächsten Versuch!')
print("-----------------------------------------------------------------")
print("")

time.sleep(sleeptime)

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:

GPIO.cleanup()

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 69 von 227

KY-016 RGB 5mm LED Modul

KY-016 RGB 5mm LED Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 2

5 Codebeispiel Raspberry Pi ................................................................................................................................... 4

Bild

Technische Daten / Kurzbeschreibung

LED-Modul welche eine rote, blaue und grüne LED beinhaltet. Diese sind mittels gemeinsamer Kathode
miteinander verbunden. Je nach Eingangsspannung, werden Vorwiderstände benötigt

Vf [ ]= 1,8VRot

Vf [ , ]= 2,8VGruen Blau

If= 20mA

Vorwiderstände:

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 70 von 227

KY-016 RGB 5mm LED Modul

Rf (3,3V) [ ]= 100ΩGrün

Rf (3,3V) [ ]= 180ΩRot

Rf (3,3V) [ ]= 100ΩBlau

[z.B. beim Einsatz mit ARM CPU-Kern basierten Mikrokontrollern wie ]Raspberry-Pi

Rf (5V) [ ] = 100ΩGrün

Rf (5V) [ ] = 180ΩRot 

Rf (5V) [ ] = 100ΩBlau 

[z.B. beim Einsatz mit Atmel Atmega basierten Mikrokontrollern wie ]Arduino

Pin-Belegung

Codebeispiel Arduino

Codebeispiel ON/OFF

Dieses Codebeispiel zeigt auf, wie die integrierten LEDs mittels eines definierbaren Ausgangspins
abwechselnd, in 3 Sekunden Takt, angeschaltet werden können.

int Led_Rot = 10;
int Led_Gruen = 11;
int Led_Blau = 12;

void setup ()
{
// Initialisierung Ausgangspins für die LEDs
pinMode (Led_Rot, OUTPUT);
pinMode (Led_Gruen, OUTPUT);
pinMode (Led_Blau, OUTPUT);
}

void loop () //Hauptprogrammschleife
{
digitalWrite (Led_Rot, HIGH); // LED wird eingeschaltet

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 71 von 227

KY-016 RGB 5mm LED Modul

Beispielprogramm ON/OFF Download:

KY-016_LED_ON-OFF.zip

Codebeispiel PWM

Mittels Puls-Weiten-Modulation [PWM] lässt sich die Helligkeit einer LED regulieren - dabei wird die LED in
bestimmten Zeitintervallen ein und ausgeschaltet, wobei das Verhältnis der Einschalt- und Ausschaltzeit
einer relativen Helligkeit entspricht - aufgrund der Trägheit des menschlichen Sehvermögens, interpretieren
die menschlichen Augen ein solches Ein-/Ausschaltverhalten als Helligkeitsänderung. Nähere Informationen
zu diesem Thema finden Sie in diesem [ ].Artikel von mikrokontroller.net

In diesem Modul sind mehrere LEDs integriert - durch die Überlagerung von unterschiedlichen
Helligkeitsstufen lassen sich somit verschiedene Farben kreieren. Dieses wird im folgenden Codebeispiel
gezeigt.

digitalWrite (Led_Gruen, LOW); // LED wird eingeschaltet
digitalWrite (Led_Blau, LOW); // LED wird eingeschaltet
delay (3000); // Wartemodus für 3 Sekunden

digitalWrite (Led_Rot, LOW); // LED wird eingeschaltet
digitalWrite (Led_Gruen, HIGH); // LED wird eingeschaltet
digitalWrite (Led_Blau, LOW); // LED wird eingeschaltet
delay (3000); // Wartemodus für weitere drei Sekunden in denen die LEDs dann umgeschaltet werden

digitalWrite (Led_Rot, LOW); // LED wird eingeschaltet
digitalWrite (Led_Gruen, LOW); // LED wird eingeschaltet
digitalWrite (Led_Blau, HIGH); // LED wird eingeschaltet
delay (3000); // Wartemodus für weitere drei Sekunden in denen die LEDs dann umgeschaltet werden

}

int Led_Rot = 10;
int Led_Gruen = 11;
int Led_Blau = 12;

int val;

void setup () {
// Initialisierung Ausgangspins für die LEDs
pinMode (Led_Rot, OUTPUT);
pinMode (Led_Gruen, OUTPUT);
pinMode (Led_Blau, OUTPUT);
}
void loop () {
// Innerhalb einer For-Schleife werden den drei LEDs verschiedene PWM-Werte uebergeben

// Dadurch entsteht ein Farbverlauf, in dem sich durch das Vermischen unterschiedlicher
// Helligkeitstufen der beiden integrierten LEDs, unterschiedliche Farben entstehen

for (val = 255; val> 0; val--)
{
analogWrite (Led_Blau, val);
analogWrite (Led_Gruen, 255-val);
analogWrite (Led_Rot, 128-val);
delay (1);
}
// In der zweiten For-Schleife wird der Farbverlauf rückwärts durchgegangen
for (val = 0; val <255; val++)
{

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 72 von 227

KY-016 RGB 5mm LED Modul

analogWrite (Led_Blau, val);
analogWrite (Led_Gruen, 255-val);
analogWrite (Led_Rot, 128-val);
delay (1);
}
}

Beispielprogramm PWMDownload:

KY-016_PWM.zip

Anschlussbelegung Arduino:

LED Rot = [Pin 10]
LED Grün = [Pin 11]
LED Blau = [Pin 12]
Sensor GND = [Pin GND]

Codebeispiel Raspberry Pi

Codebeispiel ON/OFF

Dieses Codebeispiel zeigt auf, wie die integrierten LEDs mittels eines definierbaren Ausgangspins
abwechselnd, in 3 Sekunden Takt, angeschaltet werden können.

# Benoetigte Module werden importiert und eingerichtet
import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

# Hier werden die Ausgangs-Pin deklariert, an dem die LEDs angeschlossen sind.
LED_ROT = 6
LED_GRUEN = 5
LED_BLAU = 4

GPIO.setup(LED_ROT, GPIO.OUT, initial= GPIO.LOW)
GPIO.setup(LED_GRUEN, GPIO.OUT, initial= GPIO.LOW)
GPIO.setup(LED_BLAU, GPIO.OUT, initial= GPIO.LOW)

print "LED-Test [druecken Sie STRG+C, um den Test zu beenden]"

# Hauptprogrammschleife
try:
while True:
print("LED ROT 3 Sekunden an")
GPIO.output(LED_ROT,GPIO.HIGH) #LED wird eingeschaltet
GPIO.output(LED_GRUEN,GPIO.LOW) #LED wird eingeschaltet
GPIO.output(LED_BLAU,GPIO.LOW) #LED wird eingeschaltet
time.sleep(3) # Wartemodus fuer 4 Sekunden
print("LED GRUEN 3 Sekunden an")
GPIO.output(LED_ROT,GPIO.LOW) #LED wird eingeschaltet
GPIO.output(LED_GRUEN,GPIO.HIGH) #LED wird eingeschaltet
GPIO.output(LED_BLAU,GPIO.LOW) #LED wird eingeschaltet
time.sleep(3) #Wartemodus fuer 3 Sekunden
print("LED BLAU 3 Sekunden an")
GPIO.output(LED_ROT,GPIO.LOW) #LED wird eingeschaltet
GPIO.output(LED_GRUEN,GPIO.LOW) #LED wird eingeschaltet
GPIO.output(LED_BLAU,GPIO.HIGH) #LED wird eingeschaltet

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 73 von 227

KY-016 RGB 5mm LED Modul

time.sleep(3) #Wartemodus fuer 3 Sekunden

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Beispielprogramm ON/OFF Download

Zu starten mit dem Befehl:

sudo python KY016_RPI_ON-OFF.py

Codebeispiel PWM

Mittels Puls-Weiten-Modulation [PWM] lässt sich die Helligkeit einer LED regulieren - dabei wird die LED in
bestimmten Zeitintervallen ein und ausgeschaltet, wobei das Verhältnis der Einschalt- und Ausschaltzeit
einer relativen Helligkeit entspricht - aufgrund der Trägheit des menschlichen Sehvermögens, interpretieren
die menschlichen Augen ein solches Ein-/Ausschaltverhalten als Helligkeitsänderung. Nähere Informationen
zu diesem Thema finden Sie in diesem [ ].Artikel von mikrokontroller.net

In diesem Modul sind mehrere LEDs integriert - durch die Überlagerung von unterschiedlichen
Helligkeitsstufen lassen sich somit verschiedene Farben kreieren. Dieses wird im folgenden Codebeispiel
gezeigt.Im Raspberry Pi ist nur ein Hardware-PWM Channel uneingeschränkt auf die GPIO-Pins
hinausgeführt, weswegen im vorliegenden Beispiel auf Software-PWM zurückgegriffen wird.

# Benoetigte Module werden importiert und eingerichtet
import random, time
import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)

# Hier werden die Ausgangs-Pin deklariert, an dem die LEDs angeschlossen sind.
LED_Rot = 6
LED_Gruen = 5
LED_Blau = 4

# Set pins to output mode
GPIO.setup(LED_Rot, GPIO.OUT)
GPIO.setup(LED_Gruen, GPIO.OUT)
GPIO.setup(LED_Blau, GPIO.OUT)

Freq = 100 #Hz

# Die jeweiligen Farben werden initialisiert.
ROT = GPIO.PWM(LED_Rot, Freq)
GRUEN = GPIO.PWM(LED_Gruen, Freq)
BLAU = GPIO.PWM(LED_Blau, Freq)
ROT.start(0)
GRUEN.start(0)
BLAU.start(0)

# Diese Funktion generiert die eigentliche Farbe
# Mittels der jeweiligen Farbvariable, kann die Farbintensitaet geaendert werden
# Nachdem die Farbe eingestellt wurde, wird mittels "time.sleep" die Zeit definiert,
# wie lang die besagte Farbe angezeigt werden soll

def LED_Farbe(Rot, Gruen,Blau, pause):
ROT.ChangeDutyCycle(Rot)

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 74 von 227

KY-016 RGB 5mm LED Modul

Beispielprogramm PWMDownload:

KY-016_RPi_PWM.zip

Zu starten mit dem Befehl:

sudo python KY-016_RPi_PWM.py

Anschlussbelegung Raspberry Pi:

LEDRot = GPIO6 [Pin 22]
LEDGrün = GPIO5 [Pin 18]
LEDBlau = GPIO4 [Pin 16]
Sensor GND = Masse [Pin 6]

GRUEN.ChangeDutyCycle(Gruen)
BLAU.ChangeDutyCycle(Blau)
time.sleep(pause)

ROT.ChangeDutyCycle(0)
GRUEN.ChangeDutyCycle(0)

print "LED-Test [druecken Sie STRG+C, um den Test zu beenden]"

# Hauptprogrammschleife:
# Diese hat die Aufgabe fuer jede einzelne Farbe eine eigene Variable zu erstellen
# und mittels einer For-Schleife die Farbintensitaet jeder einzelnen Farbe von 0-100% zu druchlaufen

# Durch die Mischungen der verschiedenen Helligkeitsstufen der jeweiligen Farben
# entsteht somit ein Farbverlauf

try:
while True:
for x in range(0,2):
for y in range(0,2):
for z in range(0,2):
print (x,y,z)
for i in range(0,101):
LED_Farbe((x*i),(y*i),(z*i),.02)

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 75 von 227

KY-017 Neigungsschalter Modul

KY-017 Neigungsschalter Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 2

5 Codebeispiel Raspberry Pi ................................................................................................................................... 3

Bild

Technische Daten / Kurzbeschreibung

Je nach Neigung, schließt ein Schalter die Eingangspins kurz.

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 76 von 227

KY-017 Neigungsschalter Modul

Pin-Belegung

Codebeispiel Arduino

Hier bei handelt es sich um ein Beispielprogramm, welches eine LED zum Leuchten bringt, wenn am Sensor
ein Signal detektiert wurde. Als LED können z.B. auch unter anderem die Module KY-011, KY-016 oder KY­029 verwendet werden.

int Led = 13 ;// Deklaration des LED-Ausgangspin
int Sensor = 10; // Deklaration des Sensor-Eingangspin
int val; // Temporaere Variable

void setup ()
{
pinMode (Led, OUTPUT) ; // Initialisierung Ausgangspin
pinMode (Sensor, INPUT) ; // Initialisierung Sensorpin
}

void loop ()
{
val = digitalRead (Sensor) ; // Das gegenwärtige Signal am Sensor wird ausgelesen

if (val == HIGH) // Falls ein Signal erkannt werden konnte, wird die LED eingeschaltet.
{
digitalWrite (Led, LOW);
}
else
{
digitalWrite (Led, HIGH);
}
}

Anschlussbelegung Arduino:

LED + = [Pin 13]

LED - = [Pin GND]

Sensor Signal = [Pin 10]

Sensor+V = [Pin 5V]

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 77 von 227

KY-017 Neigungsschalter Modul

Sensor - = [Pin GND]

Beispielprogramm Download

SensorTest_Arduino_withoutPullUP.zip

Codebeispiel Raspberry Pi

Programmierbeispiel in der Programmiersprache Python

Anschlussbelegung Raspberry Pi:

Signal = GPIO24 [Pin 18]

+V = 3,3V [Pin 1]

GND = Masse [Pin 6]

Beispielprogramm Download

SensorTest_RPi_withoutPullUP.zip

Zu starten mit dem Befehl:

sudo python SensorTest_RPi_withoutPullUP.py

# Benoetigte Module werden importiert und eingerichtet
import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

# Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist.
# Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert GPIO_PIN = 24
GPIO.setup(GPIO_PIN, GPIO.IN)

print "Sensor-Test [druecken Sie STRG+C, um den Test zu beenden]"

# Diese AusgabeFunktion wird bei Signaldetektion ausgefuehrt
def ausgabeFunktion(null):
print("Signal erkannt")

# Beim Detektieren eines Signals (fallende Signalflanke) wird die Ausgabefunktion ausgeloest

GPIO.add_event_detect(GPIO_PIN, GPIO.FALLING, callback=ausgabeFunktion, bouncetime=100)

# Hauptprogrammschleife
try:
while True:
time.sleep(1)

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 78 von 227

KY-018 Fotowiderstand Modul

KY-018 Fotowiderstand Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 3

5 Codebeispiel Raspberry Pi ................................................................................................................................... 3

Bild

Technische Daten / Kurzbeschreibung

Beinhaltet einen LDR-Widerstand, dessen Widerstandswert bei hellerer Umgebung kleiner wird.

Dieser Widerstand lässt sich mit Hilfe eines Spannungsteilers bestimmen, wo sich eine bekannte Spannung
übereinenbekannten und einen unbekannten (veränderlichen) Widerstand aufteilt. Mittels dieser
gemessenen Spannung lässt sich dann der Widerstand berechnen - die genaue Berechnung ist in den unten
stehenden Codebeispielen enthalten.

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 79 von 227

KY-018 Fotowiderstand Modul

Pin-Belegung

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 80 von 227

KY-018 Fotowiderstand Modul

Codebeispiel Arduino

Das Programm misst den aktuellen Spannungswert am Sensor, berechnet aus diesen und dem bekannten
Serienwiderstand den aktuellen Widerstandswert des Sensors und gibt die Ergebnisse auf der serielle
Ausgabe aus.

Anschlussbelegung Arduino:

Sensor GND = [Pin GND]

Sensor +V = [Pin 5V]

Sensor Signal = [Pin A5]

Beispielprogramm Download

Single_Analog_Sensor.zip

Codebeispiel Raspberry Pi

!! !! !! !!Achtung Analoger Sensor Achtung

Der Raspberry Pi besitzt im Gegensatz zum Arduino keine analogen Eingänge bzw. es ist kein ADC (analog
digital Converter) im Chip des Raspberry Pi's integriert. Dies schränkt den Raspberry Pi ein, wenn man
Sensoren einsetzen möchte, wo nicht digital Werte ausgegeben werden [Spannungswert überschritten ->
digital EIN | Spannungswert unterschritten -> digital AUS | Beispiel: Knopf gedrückt [ ] Knopf losgelassen [EIN

]], sondern es sich hier um einen kontinuierlichen veränderlichen Wert handeln sollte (Beispiel: AUS

Potentiometer -> Andere Position = Anderer Spannungswert)

int sensorPin = A5; // Hier wird der Eingangs-Pin deklariert

// Serielle Ausgabe in 9600 Baud
void setup()
{
Serial.begin(9600);
}

// Das Programm misst den aktuellen Spannungswert am Sensor,
// berechnet aus diesen und dem bekannten Serienwiderstand den aktuellen
// Widerstandswert des Sensors und gibt die Ergebnisse auf der serielle Ausgabe aus

void loop()
{
// Aktueller Spannungswert wird gemessen...
int rawValue = analogRead(sensorPin);
float voltage = rawValue * (5.0/1023) * 1000;

float resitance = 10000 * ( voltage / ( 5000.0 - voltage) );

// ... und hier auf die serielle Schnittstelle ausgegeben
Serial.print("Spannungswert:"); Serial.print(voltage); Serial.print("mV");
Serial.print(", Widerstandswert:"); Serial.print(resitance);Serial.println("Ohm");
Serial.println("---------------------------------------");

delay(500);
}

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 81 von 227

KY-018 Fotowiderstand Modul

Um diese Problematik zu umgehen, besitzt unser mit dem ein Modul mit 16 Bit

Sensorkit X40

KY-053

genauen ADC, welches Sie am Raspberry nutzen können, um diesen um 4 analoge Eingänge erweitern zu
können. Dieses wird per I2C an den Raspberry Pi angeschlossen, übernimmt die analoge Messung und gibt
den Wert digital an den Raspberry Pi weiter.

Somit empfehlen wir, bei analogen Sensoren dieses Sets das KY-053 Modul mit dem besagten ADC
dazwischenzuschalten. Nähere Informationen finden Sie auf der Informationsseite zum  Analog KY-053

Digital Converter

!! !! !! !!Achtung Analoger Sensor Achtung

Das Programm nutzt zur Ansteuerung des ADS1115 ADC die entsprechenden ADS1x15 und I2C Python­Libraries der Firma Adafruit. Diese wurden unter dem folgenden Link [https://github.com/adafruit/Adafruit-

] unter der BSD-Lizenz [ ] veröffentlicht. Die benötigten Libraries sind im Raspberry-Pi-Python-Code Link

unteren Download-Paket enthalten.

Das Programm misst den aktuellen Spannungswert am Sensor, berechnet aus diesen und dem bekannten
Serienwiderstand den aktuellen Widerstandswert des Sensors und gibt die Ergebnisse auf der serielle
Ausgabe aus.

# coding=utf-8
#!/usr/bin/python

# Dieser Code nutzt die ADS1115 und die I2C Python Library fuer den Raspberry Pi
# Diese ist unter folgendem Link unter der BSD Lizenz veroeffentlicht
# [https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code]
from Adafruit_ADS1x15 import ADS1x15
from time import sleep

# Weitere benoetigte Module werden importiert und eingerichtet
import time, signal, sys, os, math
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)

# Benutzte Variablen werden initialisiert
delayTime = 0.2
voltageMax = 3300 # maximal möglicher Spannungswert am ADC

# Adresszuweisung ADS1x15 ADC

ADS1015 = 0x00 # 12-bit ADC
ADS1115 = 0x01 # 16-bit

# Verstaerkung (Gain) wird ausgewaehlt
gain = 4096 # +/- 4.096V
# gain = 2048 # +/- 2.048V
# gain = 1024 # +/- 1.024V
# gain = 512 # +/- 0.512V

###################################################################################################

### Copyright by Joy-IT
### Published under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
### Commercial use only after permission is requested and granted
###
### Single Analog Sensor - Raspberry Pi Python Code Example
### ################################################################################################

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 82 von 227

KY-018 Fotowiderstand Modul

except KeyboardInterrupt:
GPIO.cleanup()

Anschlussbelegung Raspberry Pi:

Sensor

GND = GND [Pin 06(RPi)]

+V = 3,3V [Pin 01(RPi)]

analoges Signal = Analog 0 [Pin A0 (ADS1115 - KY-053)]

ADS1115 - KY-053:

VDD = 3,3V [Pin 17]

GND = Masse [Pin 09]

# gain = 256 # +/- 0.256V

# Abtasterate des ADC (SampleRate) wird ausgewaehlt
# sps = 8 # 8 Samples pro Sekunde
# sps = 16 # 16 Samples pro Sekunde
# sps = 32 # 32 Samples pro Sekunde
# sps = 64 # 64 Samples pro Sekunde
# sps = 128 # 128 Samples pro Sekunde
sps = 250 # 250 Samples pro Sekunde
# sps = 475 # 475 Samples pro Sekunde
# sps = 860 # 860 Samples pro Sekunde

# ADC-Channel (1-4) wird ausgewaehlt
adc_channel = 0 # Channel 0
# adc_channel = 1 # Channel 1
# adc_channel = 2 # Channel 2
# adc_channel = 3 # Channel 3

# Hier wird der ADC initialisiert - beim KY-053 verwendeten
# ADC handelt es sich um einen ADS1115 Chipsatz
adc = ADS1x15(ic=ADS1115)

#############################################################################################################

# ########
# Hauptprogrammschleife
# ########
# Das Programm misst mit Hilfe des ADS1115 ADC den aktuellen Spannungswert am ADC, berechnet
# aus diesem und den bekannten Widerstandswert des Serien-Vorwiderstands den aktuellen
# Widerstandswert des Sensors und gibt diese in der Konsole aus.

try:
while True:
#Aktueller Wert wird aufgenommen,...
voltage = adc.readADCSingleEnded(adc_channel, gain, sps)

# ... der Widerstand wird berechnet...
resitance = 10000 * voltage/(voltageMax - voltage)

# ... und beides hier in die Konsole ausgegeben
print "Spannungswert:", voltage,"mV, Widerstand:", resitance,"Ω"
print "---------------------------------------"

# Delay
time.sleep(delayTime)

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 83 von 227

KY-018 Fotowiderstand Modul

SCL = GPIO03 / SCL [Pin 05]

SDA = GPIO02 / SDA [Pin 03]

A0 = s.o. [Sensor: analoges Signal]

Beispielprogramm Download

RPi_Single_Analog_Sensor.zip

Zu starten mit dem Befehl:

sudo python RPi_Single_Analog_Sensor.py

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 84 von 227

KY-019 5V Relais Modul

KY-019 5V Relais Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 2

5 Codebeispiel Raspberry Pi ................................................................................................................................... 3

Bild

Technische Daten / Kurzbeschreibung

Spannungsbereich: 240VAC / 10A | 28VDC / 10AEin Relais zum schalten von höherer Spannungen mittels
eines 5V Ausgangs.

!!!!! Warnung!!!!!

Das Arbeiten mit Spannungen >30v und vor allem bei Netzspannung (230V) kann zu
körperlichen Schäden führen sein.bis sogar tödlich

Wir raten dringend dazu erstmit höheren Spannungen zu Arbeiten, wenn Sie die fachliche
Kompetenz dazu besitzten.

!!!!! Warnung!!!!!

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 85 von 227

KY-019 5V Relais Modul

Die Ausgangsleiste des Relais besitzt zwei Ausgangsterminals:

- Das eine welches mit "NC" für "normally closed" gekennzeichnet ist, was bedeutet dass dieser Durchgang
ohne elektrische Umschaltung am Relais standardmäßig kurzgeschlossen ist.

- Das andere welches mit "NO" für "normally open" gekennzeichnet ist, was bedeutet dassdieser Durchgang
ohne elektrische Umschaltung am Relais standardmäßig offen bzw. getrennt ist.

Pin-Belegung

Codebeispiel Arduino

Das Programm bildet einen Blinker nach - es schaltet das Relais in vorher definierter Zeit (delayTime)
zwischen den beiden Zuständen (bzw. Ausgangsterminals) um.

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 86 von 227

KY-019 5V Relais Modul

Anschlussbelegung Arduino:

Sensor - = [Pin GND]

Sensor + = [Pin 5V]

Sensor Signal = [Pin 10]

Beispielprogramm Download

KY-019_Relais.zip

Codebeispiel Raspberry Pi

Das Programm bildet einen Blinker nach - es schaltet das Relais in vorher definierter Zeit (delayTime)
zwischen den beiden Zuständen (bzw. Ausgangsterminals) um.

# Hauptprogrammschleife
try:
while True:
GPIO.output(RELAIS_PIN, True) # NO ist nun kurzgeschlossen
time.sleep(delayTime)
GPIO.output(RELAIS_PIN, False) # NC ist nun kurzgeschlossen
time.sleep(delayTime)

int relay = 10; // Hier wird der Pin deklariert, an dem das Relay angeschlossen ist

delayTime = 1 // Wert in Sekunden, wie lange zwischen den Umschaltungen gewartet werden soll

void setup ()
{
pinMode (relay, OUTPUT); // Der Pin wird als Ausgang deklariert
}

// Das Programm bildet einen Blinker nach - es schaltet das Relais in vorher definierter
// Zeit (delayTime) zwischen den beiden Zuständen (bzw. Ausgangsterminals) um.
void loop ()
{
digitalWrite (relay, HIGH); // "NO" ist nun kurzgeschlossen;
delay (delayTime * 1000);
digitalWrite (relay, LOW); // "NC" ist nun kurzgeschlossen;
delay (delayTime * 1000);
}

# Benoetigte Module werden importiert und eingerichtet
import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)
# Hier wird die Pause (in Sekunden) zwischen dem Umschalten deklariert
delayTime = 1

# Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist.
# Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert RELAIS_PIN = 21
GPIO.setup(RELAIS_PIN, GPIO.OUT)
GPIO.output(RELAIS_PIN, False)

print "Sensor-Test [druecken Sie STRG+C, um den Test zu beenden]"

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 87 von 227

KY-019 5V Relais Modul

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Anschlussbelegung Raspberry Pi:

Relais - = GND [Pin 06]

Relais + = 5V [Pin 2]

Relais Signal = GPIO24 [Pin 18]

Beispielprogramm Download

KY-019_RPi_Relais.zip

Zu starten mit dem Befehl:

sudo python KY-019_RPi_Relais.py

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 88 von 227

KY-020 Neigungs-Schalter Modul

KY-020 Neigungs-Schalter Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 2

5 Codebeispiel Raspberry Pi ................................................................................................................................... 3

Bild

Technische Daten / Kurzbeschreibung

Je nach Neigung, schließt ein Schalter die Eingangspins kurz.

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 89 von 227

KY-020 Neigungs-Schalter Modul

Pin-Belegung

Codebeispiel Arduino

Hier bei handelt es sich um ein Beispielprogramm, welches eine LED zum Leuchten bringt, wenn am Sensor
ein Signal detektiert wurde. Als LED können z.B. auch unter anderem die Module KY-011, KY-016 oder KY­029 verwendet werden.

int Led = 13 ;// Deklaration des LED-Ausgangspin
int Sensor = 10; // Deklaration des Sensor-Eingangspin
int val; // Temporaere Variable

void setup ()
{
pinMode (Led, OUTPUT) ; // Initialisierung Ausgangspin
pinMode (Sensor, INPUT) ; // Initialisierung Sensorpin
}

void loop ()
{
val = digitalRead (Sensor) ; // Das gegenwärtige Signal am Sensor wird ausgelesen

if (val == HIGH) // Falls ein Signal erkannt werden konnte, wird die LED eingeschaltet.
{
digitalWrite (Led, LOW);
}
else
{
digitalWrite (Led, HIGH);
}
}

Anschlussbelegung Arduino:

LED + = [Pin 13]

LED - = [Pin GND]

Sensor Signal = [Pin 10]

Sensor+V = [Pin 5V]

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 90 von 227

KY-020 Neigungs-Schalter Modul

Sensor - = [Pin GND]

Beispielprogramm Download

SensorTest_Arduino_withoutPullUP.zip

Codebeispiel Raspberry Pi

Programmierbeispiel in der Programmiersprache Python

Anschlussbelegung Raspberry Pi:

Signal = GPIO24 [Pin 18]

+V = 3,3V [Pin 1]

GND = Masse [Pin 6]

Beispielprogramm Download

SensorTest_RPi_withoutPullUP.zip

Zu starten mit dem Befehl:

sudo python SensorTest_RPi_withoutPullUP.py

# Benoetigte Module werden importiert und eingerichtet
import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

# Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist.
# Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert GPIO_PIN = 24
GPIO.setup(GPIO_PIN, GPIO.IN)

print "Sensor-Test [druecken Sie STRG+C, um den Test zu beenden]"

# Diese AusgabeFunktion wird bei Signaldetektion ausgefuehrt
def ausgabeFunktion(null):
print("Signal erkannt")

# Beim Detektieren eines Signals (fallende Signalflanke) wird die Ausgabefunktion ausgeloest

GPIO.add_event_detect(GPIO_PIN, GPIO.FALLING, callback=ausgabeFunktion, bouncetime=100)

# Hauptprogrammschleife
try:
while True:
time.sleep(1)

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 91 von 227

KY-021 Mini Magnet Reed Modul

KY-021 Mini Magnet Reed Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 2

5 Codebeispiel Raspberry Pi ................................................................................................................................... 3

Bild

Technische Daten / Kurzbeschreibung

Wird ein Magnetfeld detektiert, so werden die beiden Eingangspins kurzgeschlossen.

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 92 von 227

KY-021 Mini Magnet Reed Modul

Pin-Belegung

Codebeispiel Arduino

Hier bei handelt es sich um ein Beispielprogramm, welches eine LED zum Leuchten bringt, wenn am Sensor
ein Signal detektiert wurde. Als LED können z.B. auch unter anderem die Module KY-011, KY-016 oder KY­029 verwendet werden.

int Led = 13 ;// Deklaration des LED-Ausgangspin
int Sensor = 10; // Deklaration des Sensor-Eingangspin
int val; // Temporaere Variable

void setup ()
{
pinMode (Led, OUTPUT) ; // Initialisierung Ausgangspin
pinMode (Sensor, INPUT) ; // Initialisierung Sensorpin
}

void loop ()
{
val = digitalRead (Sensor) ; // Das gegenwärtige Signal am Sensor wird ausgelesen

if (val == HIGH) // Falls ein Signal erkannt werden konnte, wird die LED eingeschaltet.
{
digitalWrite (Led, LOW);
}
else
{
digitalWrite (Led, HIGH);
}
}

Anschlussbelegung Arduino:

LED + = [Pin 13]

LED - = [Pin GND]

Sensor Signal = [Pin 10]

Sensor+V = [Pin 5V]

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 93 von 227

KY-021 Mini Magnet Reed Modul

Sensor - = [Pin GND]

Beispielprogramm Download

SensorTest_Arduino_withoutPullUP.zip

Codebeispiel Raspberry Pi

Programmierbeispiel in der Programmiersprache Python

Anschlussbelegung Raspberry Pi:

Signal = GPIO24 [Pin 18]

+V = 3,3V [Pin 1]

GND = Masse [Pin 6]

Beispielprogramm Download

SensorTest_RPi_withoutPullUP.zip

Zu starten mit dem Befehl:

sudo python SensorTest_RPi_withoutPullUP.py

# Benoetigte Module werden importiert und eingerichtet
import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

# Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist.
# Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert GPIO_PIN = 24
GPIO.setup(GPIO_PIN, GPIO.IN)

print "Sensor-Test [druecken Sie STRG+C, um den Test zu beenden]"

# Diese AusgabeFunktion wird bei Signaldetektion ausgefuehrt
def ausgabeFunktion(null):
print("Signal erkannt")

# Beim Detektieren eines Signals (fallende Signalflanke) wird die Ausgabefunktion ausgeloest

GPIO.add_event_detect(GPIO_PIN, GPIO.FALLING, callback=ausgabeFunktion, bouncetime=100)

# Hauptprogrammschleife
try:
while True:
time.sleep(1)

# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
GPIO.cleanup()

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 94 von 227

KY-022 Infrarot Receiver Modul

KY-022 Infrarot Receiver Modul

Inhaltsverzeichnis

1 Bild ....................................................................................................................................................................... 1

2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1

3 Pin-Belegung ........................................................................................................................................................ 2

4 Codebeispiel Arduino ........................................................................................................................................... 2

5 Codebeispiel Raspberry Pi ................................................................................................................................... 4

5.1 Lirc Installation ........................................................................................................................................... 5

5.2 IR-Receiver Test ......................................................................................................................................... 6

5.3 Fernbedienung anlernen ............................................................................................................................ 7

5.4 Befehle senden mit dem Infrarot Transmitter ............................................................................................ 8

Bild

Technische Daten / Kurzbeschreibung

Trägerfrequenz: 38kHz Kann Infrarotsignale empfangen und gibt diese am Signalausgang als digitale
Abfolge aus.

Zusätzlich blinkt die auf dem Modul integrierte LED kurz auf, wenn ein Infrarot-Signal detektiert wurde.

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 95 von 227

KY-022 Infrarot Receiver Modul

Pin-Belegung

Codebeispiel Arduino

Mithilfe der beiden Sensormodule KY-005 und KY-022 lässt sich ein Infrarot-Fernbedienung + Infrarot
Receiver System aufbauen. Hierzu werden neben den zwei Modulen auch zwei einzelne Arduinos benötigt.
Der eine fungiert hierbei dann als Sender und der andere empfängt die Signale und gibt diese dann in der
seriellen Konsole aus.

Für das folgende Codebeispiel wirdeine zusätzliche Library benötigt:

- [Arduino-IRremote] von | veröffentlicht unter LGPLKen Shirriff

Die Library istim Paket enthalten und muss vor dem Start der Arduino IDE in den "library"-Ordner kopiert
werden.

Diesen finden Sie standardmäßig unter dem folgenden Pfad Ihrer Windows-Installation:

C:\Benutzer\[Benutzername]\Dokumente\Arduino\libraries

Bei Infrarot-Sendesystemen, gibt es verschiedene Protokolle, in denen die Daten versendet werden können.
In dem folgenden Beispiel wird für das versenden das RC5 Protokoll verwendet - die verwendete Library
"Arduino-IRremote" kümmert sich eigenständig um die Konvertierung in die richtige Datenfolge. Es gibt
innerhalb der Library jedoch auch andere Protokolle/Kodierungen - diese sind in der Dokumentation/Code
der Library gekennzeichnet.

Code für den Empfänger:

// Arduino-IRremote Iibrary wird hinzugefuegt
#include <IRremote.h>

// Hier kann der entsprechende Eingangspin für den Signalausgang

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 96 von 227

KY-022 Infrarot Receiver Modul

Code für den Sender:

Beispielprogramm Download:

Arduino_Fernbedienung.zip

Anschlussbelegung Arduino 1 [Empfänger]:

KY-022

// des KY-022 deklariert werden
int RECV_PIN = 11;

// Arduino-IRremote Library wird initialisiert
IRrecv irrecv(RECV_PIN);
decode_results results;

void setup()
{
Serial.begin(9600);
irrecv.enableIRIn(); // Infrarot-Receiver wird gestartet
}

// Hauptprogrammschleife
void loop() {

// Es wird geprüft ob am Recveiver ein Signal eingegangen ist
if (irrecv.decode(&results)) {

// Bei Signaleingang wird das empfangene und dekodierte Signal

// in der serriellen Konsole ausgegeben
Serial.println(results.value, HEX);
irrecv.resume();
}
}

//Arduino-IRremote Library wird hinzugefügt...
#include <IRremote.h>

//...und hier initialisiert
IRsend irsend;

// Die Einstellungen für den Ausgang werden von der Library übernommen
// Die entsprechenden Ausgänge unterscheiden sich je nach verwendeten Arduino
// Arduino UNO: Ausgang = D3
// Arduino MEGA: Ausgang = D9
// Eine komplette Auflistung der entsprechenden Ausgänge finden Sie unter
// http://z3t0.github.io/Arduino-IRremote/
void setup()
{
}

// Hauptprogrammschleife
void loop() {
// Der Sender verschickt in diesem Beispiel das Signal A90
// (in hexdezimaler Form) in der Kodierung "RC5". Dieses wird dreimal
// hintereinander gesendet und danach eine Pause für 5 Sekunden eingelegt
for (int i = 0; i < 3; i++) {

// [0xA90] zu versendetes Signal | [12] Bit-Länge des zu versendeten Signals (hex A90=1010 1001 0000)

irsend.sendRC5(0xA90, 12);
delay(40);
}
delay(5000); //Zwischen den Sendeimpulsen gibt es eine Pause von 5 Sekunden
}

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 97 von 227

KY-022 Infrarot Receiver Modul

Signal = [Pin 11]

+V = [Pin 5V]

GND = [Pin GND]

Anschlussbelegung Arduino 2 [Sender]:

KY-005

Signal = [Pin 3 (Arduino Uno) | Pin 9 (Arduino Mega)]

GND+Widerstand = [Pin GND*]

GND = [Pin GND]

*Nur wenn Vorwiderstand auf dem Modul verlötet wurde und nicht vor dem Modul geschaltet ist

Codebeispiel Raspberry Pi

Der Raspberry Pi besitzt mit seiner fortschrittlichen Prozessorarchitektur den Vorteil gegenüber dem
Arduino, dass dieser ein komplettes Linux-Betriebssystem betreiben kann. Mit Hilfe eines Infrarot-Receivers
können somit nicht nur einfache Datensignale ausgetaucht, sondern es können auch komplette Software­Programme wie z.B. die Mediencenter Software OpenElec per Fernbedienung bedient werden.

Für die Einrichtung eines Infrarot-Steuerungssystem, bietet sich unter Linux bietet die Software "lirc" an
(veröffentlicht unter der LGPL - ). Im Folgenden zeigen wir auf, wie lirc eingerichtet, eine Website
Fernbedienung angelernt werden kann und per Infrarotdiode die erlernten Signale per Infrarot versendet
werden können (um z.B. aus dem Raspberry Pi eine per Software steuerbare Infrarot Fernbedienung zu
machen).

Zu diesem Zwecke werden die Module KY-005 als Infrarot-Transmitter und KY-022 als Infrarot Receiver
angewendet.

Anschlussbelegung Raspberry Pi:

KY-005

Signal = GPIO17 [Pin 11]

GND+Widerstand = GND* [Pin 9]

GND = GND [Pin 6]

*Nur wenn Vorwiderstand auf dem Modul verlötet wurde und nicht vor dem Modul geschaltet ist

KY-022

Signal = GPI18 [Pin 12]

+V = 3,3V [Pin 17]

GND = GND [Pin 25]

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 98 von 227

KY-022 Infrarot Receiver Modul

Lirc Installation

Als erstes öffnen wir auf dem Desktop ein Terminal oder verbinden wir uns per SSH mit dem Raspberry Pi.
Dort geben Sie den folgenden Befehl ein, um lirc auf den Raspberry Pi zu installieren:

sudo apt-get install lirc -y

[Hierzu muss der Raspberry Pi mit dem Internet verbunden sein]

Damit das lirc Modul direkt zum Start des Betriebssystem verfügbar ist, müssen folgende Zeilen am Ende
der Datei "/boot/config.txt" hinzugefügt werden:

dtoverlay=lirc-rpi,gpio_in_pin=18,gpio_out_pin=17,gpio_in_pull=up

Hierbei definiert "gpio_in_pin=18" den Eingangspin für den IR-Receiver, sowie "gpio_out_pin=17" den
Ausgangspin für den IR-Transmitter.

Die Datei kann mit folgenden Befehl editiert werden:

sudo nano /boot/config.txt

Mit der Tastenfolge [Strg+X -> Y -> Enter] kann die Datei, nach dem hinzufügen der Zeile am unteren Ende,
gespeichert und geschlossen werden.

Auch die Datei "/etc/lirc/hardware.conf" muss modifiziert werden. Hierbei ist der Befehl...

sudo nano /etc/lirc/hardware.conf

... zu verwenden. Hier müssen die die folgenden Zeilen modifiziert werden. An den entsprechenden Stellen
muss dann ...

DRIVER="UNCONFIGURED"

--->>
DRIVER="default"

DEVICE=""

--->>
DEVICE="/dev/lirc0"

MODULES=""

--->>
MODULES="lirc_rpi"

...geändert werden.

Die modifizierte Datei muss dann wie folgt aussehen:

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 99 von 227

KY-022 Infrarot Receiver Modul

# /etc/lirc/hardware.conf
#
# Arguments which will be used when launching lircd
LIRCD_ARGS=""

#Don't start lircmd even if there seems to be a good config file
#START_LIRCMD=false

#Don't start irexec, even if a good config file seems to exist.
#START_IREXEC=false

#Try to load appropriate kernel modules
LOAD_MODULES=true

# Run "lircd --driver=help" for a list of supported drivers.
DRIVER="default"
# usually /dev/lirc0 is the correct setting for systems using udev
DEVICE="/dev/lirc0"
MODULES="lirc_rpi"

# Default configuration files for your hardware if any
LIRCD_CONF=""
LIRCMD_CONF=""

Danach starten wir den Raspberry Pi mit dem folgenden Befehl neu:

sudo reboot

IR-Receiver Test

Um den angeschlossenen Receiver zu testen, muss vorab lirc mit dem Befehl...

sudo /etc/init.d/lirc stop

beendet werden. Danach kann mit...

mode2 -d /dev/lirc0

...getestet werden, ob am Raspberry Pi Signale detektiert werden können. Hierzu nehmen Sie eine Infrarot
Fernbedienung und drücken eine beliebige Taste - es sollten Zeilen in der folgenden Form auftauchen:

space 95253
pulse 9022
space 2210
pulse 604
space 95246
pulse 9019
space 2211
pulse 601
space 95252
pulse 9019
space 2210

Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.0 Seite 100 von 227