In diesem Beitrag soll es darum gehen, wie man eine Apple Remote, oder eine beliebige andere Infrarot-Fernbedienung, in einem Python-Script auswertet und wie man je nach betätigter Taste unterschiedliche Aktionen auslösen kann.
Hierzu verwende ich einen Raspberry Pi Modell B+, eine Apple Remote, den 38kHz-IR-Empfänger TSOP 31238, einige female-female-Steckbrücken (40er-Pack), sowie ein 2-Kanal-Relais-Modul.
Inhalt
Schaltung aufbauen
Das Aufbauen der Schaltung ist schnell gemacht. Dem Datenblatt entnehmen wir die Anschlussbelegung des IR-Empfängers: Mit der Wölbung nach oben und Blick auf die Anschlüsse zählen wir von links nach rechts: GND
,
S, und mit etwas Abstand, V
Out
.
38kHz-IR-Empfänger TSOP 31238
Über die Belegung der GPIO-Anschlüsse hatte ich hier schonmal geschrieben. Wir verbinden also GND
mit dem Pin 14,
S mit Pin 1 (3,3V) und V
Out
mit einem beliebigen GPIO. Ich verwende den GPIO23
, also Pin 16.
Linux Infrared Remote Control (LIRC)
Um die Signale, die der IR-Empfänger an den Raspberry Pi weiterleitet, interpretieren zu können, eignet sich LIRC besonders, denn es bringt unter Anderem auch ein Tool zum Anlernen der Tasten mit. Weiterführende Informationen zu LIRC findet Ihr hier.
Wie das Ganze funktioniert, soll das nachfolgende Schema zeigen:
Installation & Konfiguration
Per SSH verbinden wir uns auf den Raspberry Pi und installieren LIRC mit folgendem Befehl:
$ sudo apt-get install lirc
Damit LIRC korrekt funktioniert, müssen aber noch einige Einstellungen vorgenommen werden. Dazu ergänzen wir als erstes die Datei /etc/modules
um einige Einträge. Wenn Ihr schon andere Hardware am Raspberry Pi angeschlossen habt, kann es sein, dass bei Euch schon Einträge vorhanden sind. Die neuen Einträge fügt Ihr einfach am Ende der Datei ein.
$ sudo nano /etc/modules
Im „Autostart“ laden wir die benötigten LIRC-Module:
# /etc/modules: kernel modules to load at boot time. # # This file contains the names of kernel modules that should be loaded # at boot time, one per line. Lines beginning with "#" are ignored. # Parameters can be specified after the module name. lirc_dev # GPIO in BCM-Zählweise lirc_rpi gpio_in_pin=23
Auf Zeile 9 geben wir in BCM-Zählweise an, welchen GPIO wir mit LIRC nutzen wollen – also die GPIO-Nummer, nicht die Pin-Nummer. Wir verlassen den Editor und speichern die Änderungen.
Anschließend passen wir die Hardware-Konfiguration von LIRC an:
$ sudo nano /etc/lirc/hardware.conf
Hier tragen wir für LIRCD_ARGS
, DRIVER
, DEVICE
und MODULES
die Werte wie abgebildet ein.
# /etc/lirc/hardware.conf # # Arguments which will be used when launching lircd LIRCD_ARGS="--uinput" #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=""
Anschließend verlassen wir den Editor und speichern die Änderungen. Zuletzt müssen wir noch einen Eintrag in der Datei /boot/config.txt
ergänzen.
$ sudo nano /boot/config.txt
Ganz unten (bei mir Zeile 45) fügen wir folgendes ein:
dtoverlay=lirc-rpi,gpio_in_pin=23
Wir verlassen den Editor und speichern die Änderungen. Nun ist es Zeit für einen Neustart:
$ sudo reboot
Erster Test von LIRC
Wenn der Raspberry Pi den Bootvorgang abgeschlossen hat, verbinden wir uns wieder per SSH. Nun können wir einen ersten Test starten und damit überprüfen, ob LIRC grundsätzlich funktionsfähig ist. Dazu stoppen wir den LIRC-Daemon…
$ sudo /etc/init.d/lirc stop
…und lassen uns die Empfangenen Rohdaten direkt im Terminal ausgeben, indem wir folgenden Befehl absetzen:
$ mode2 -d /dev/lirc0
Anschließend drücken wir ein paar Tasten auf der Fernbedienung. Der Inhalt des Terminalfensters sollte in etwa so aussehen:
Wenn wir genug davon haben beenden wir das ganze mit der Tastenkombination Strg+C
.
Tasten-Mapping für die Fernbedienung erzeugen (lircd.conf)
Als nächstes erzeugen wir die Konfigurationsdatei lircd.conf
. Diese wandelt die Rohdaten der empfangenen Signale in verständliche Zeichenketten um, die uns das weitere Vorgehen enorm erleichtern. Wenn Ihr ebenfalls eine Apple Remote verwendet, könnt Ihr diesen Schritt überspringen und Euch meiner Konfiguration (weiter unten) bedienen. Nutzt Ihr eine andere Fernbedienung, müsst Ihr entweder dieses Prozedere über Euch ergehen lassen, oder Ihr schaut (solltet Ihr wissen, wie die Fernbedienung heißt) ganz einfach mal hier nach, ob Ihr die passende lircd.conf
vielleicht einfach downloaden könnt.
Zum Anlernen nutzen wir ein Tool namens irrecord
, welches von LIRC mitgeliefert wird. Eine Sache gibt es hier zu beachten: die Tastenbezeichnung ist vorgegeben. Das bedeutet, dass wir nur Tastenbezeichnungen verwenden dürfen, die irrecord
auch kennt. Das lässt sich zwar mit entsprechendem Parameter umgehen, jedoch könnte das an anderer Stelle vielleicht nachteilhaft sein, daher halten wir uns einfach daran. Bei Interesse findet Ihr hier die Dokumentation dazu.
Die erlaubten Tastenbezeichnungen lassen wir uns mit folgendem Befehl in einer recht langen Liste ausgeben:
$ irrecord --list-namespace
Die Bezeichnungen, die mit KEY_
beginnen, bieten eine sehr vielfältige Auswahl, daher verwenden wir diese auch. Wir starten das Anlernen mit dem Befehl:
$ irrecord -d /dev/lirc0 ~/lircd.conf
Jetzt kommt einiges an Text, den man durchaus lesen sollte. Die wichtigsten Schritte erkläre ich hier kurz:
- Text lesen, Enter drücken.
- Nun soll man mehrere Tasten auf der Fernbedienung drücken, und das solange, bis zwei Zeilen mit Punkten voll sind. Im Anschluss geht es von alleine weiter.
- Jetzt geht es ans Anlernen der Tasten: Wir geben den Namen der ersten Taste ein, die wir anlernen wollen:
KEY_UP
und drückenEnter
. Anschließend drücken wir auf der Fernbedienung die Taste mit dem Pfeil nach oben. - Nächste Taste: Wir geben den Namen der zweiten Taste ein:
KEY_DOWN
, drückenEnter
und betätigen auf der Fernbedienung die Taste mit dem Pfeil nach unten. - Das wiederholen wir für jede Taste auf der Fernbedienung. Ich hab für die Apple Remote folgende Bezeichnungen gewählt:
KEY_UP
,KEY_DOWN
,KEY_LEFT
,KEY_RIGHT
,KEY_OK
,KEY_MENU
undKEY_PLAYPAUSE
.
Wenn alle Tasten angelernt sind, betätigen wir abermals die Enter
-Taste. Nun wird die Konfigurationsdatei geschrieben.
Das war es noch nicht ganz, wir müssen der soeben angelernten Fernbedienung noch einen Namen geben. Dazu öffnen wir die lircd.conf
in einem Editor…
$ nano ~/lircd.conf
…und tragen in Zeile 15 einen lesbaren Namen ein. Statt /home/pi/lircd.conf
vielleicht appleremote
oder einen sonstigen beliebigen Namen. Wer mag, kann auf den Zeilen 9-11 noch richtige Angaben machen. Ist aber nicht zwingend notwendig.
# Please make this file available to others # by sending it to <lirc@bartelmus.de> # # this config file was automatically generated # using lirc-0.9.0-pre1(default) on Tue Aug 18 19:23:09 2015 # # contributed by # # brand: /home/pi/lircd.conf # model no. of remote control: # devices being controlled by this remote: begin remote name appleremote bits 8 flags SPACE_ENC|CONST_LENGTH eps 30 aeps 100 header 9058 4422 one 624 1595 zero 624 497 ptrail 623 repeat 9058 2194 pre_data_bits 16 pre_data 0x77E1 post_data_bits 8 post_data 0x4E gap 107798 toggle_bit_mask 0x0 begin codes KEY_UP 0xD0 KEY_DOWN 0xB0 KEY_LEFT 0x10 KEY_RIGHT 0xE0 KEY_OK 0xBA 0x20 KEY_MENU 0x40 KEY_PLAYPAUSE 0x7A 0x20 end codes end remote
Anschließend verlassen wir den Editor und speichern die Änderungen. Die Konfigurationsdatei bewegen wir noch an die richtige Stelle…
$ sudo mv ~/lircd.conf /etc/lirc/lircd.conf
…und starten LIRC wieder.
$ sudo /etc/init.d/lirc start
Tasten-Mapping testen
Um zu überprüfen, ob die vorigen Schritte alle richtig abgearbeitet wurden, lassen wir uns zunächst eine Liste mit den Tasten ausgeben, die dem System bekannt sind. Für appleremote
setzt Ihr den Namen ein, den Ihr in der lircd.conf
auf Zeile 15 vergeben habt.
$ irsend LIST appleremote ""
Wenn das funktioniert hat, lassen wir uns die empfangenen Tasten im Terminal ausgeben. Dazu setzen wir…
$ sudo irw
…ab und drücken ein paar Tasten auf der Fernbedienung. Die Ausgabe im Terminal sollte so, oder so ähnlich aussehen:
Wenn wir genug gesehen haben, beenden wir das Ganze mit der Tastenkombination Strg-C
.
Aktionen erstellen (.lircrc)
Was wir bis jetzt haben: ein Tool, das die Signale vom IR-Empfänger hernimmt und aus den Rohdaten einfach zu verwertende Strings erzeugt.
Was wir noch brauchen: etwas, das uns dabei hilft, auch an die Daten heran zu kommen. Dazu nutzen wir die .lircrc
.
In dieser Datei wird definiert, welches Programm was machen soll, wenn eine bestimmte Taste gedrückt wird. Vom Grunde her könnte man hier schon direkt GPIOs schalten oder Programme ausführen. Wir machen das anders: wir bereiten alles so vor, dass wir die Werte später ganz einfach in unser Script übergeben bekommen. Das macht auch viel weniger Arbeit.
Der Aufbau dafür ist recht einfach. button
ist die Taste, die auf der Fernbedienung gedrückt wird. Hier verwenden wir die gleichen Bezeichnungen, wie beim Anlernen. prog
ist das Programm, welches den String übergeben bekommen soll. Wir schreiben hier den Socket rein, auf den wir uns dann mit dem Script verbinden wollen. Dieser kann beliebig lauten, muss aber für alle Tasten gleich sein. config
ist der String, der übergeben wird. Hier ist es das einfachste, den Tastennamen zu verwenden.
Wir erzeugen also die Datei im Benutzer-Home-Verzeichnis…
$ sudo nano ~/.lircrc
…und packen folgenden Inhalt rein:
# ~/.lircrc # # button: Name der Taster (wie angelernt) # prog: Ziel, wohin die Information übergeben werden soll (Socket oder Programm) # config: Übergebener String # Apple Remote # KEY_UP # KEY_DOWN # KEY_LEFT # KEY_RIGHT # KEY_OK # KEY_MENU # KEY_PLAYPAUSE begin button = KEY_UP prog = appleremote config = KEY_UP end begin button = KEY_DOWN prog = appleremote config = KEY_DOWN end begin button = KEY_LEFT prog = appleremote config = KEY_LEFT end begin button = KEY_RIGHT prog = appleremote config = KEY_RIGHT end begin button = KEY_OK prog = appleremote config = KEY_OK end begin button = KEY_MENU prog = appleremote config = KEY_MENU end begin button = KEY_PLAYPAUSE prog = appleremote config = KEY_PLAYPAUSE end
Anschließend verlassen wir den Editor und speichern die Datei.
Hinweis: Die soeben erstellte .lircrc
steht nur dem Nutzer zur Verfügung, mit dem Ihr aktuell eingeloggt seid. Wenn Ihr Euer Script später unter einem anderen Benutzer ausführen wollt (z.B. als root
), solltet Ihr sie in ein öffentliches Verzeichnis kopieren/verschieben:
$ sudo cp ~/.lircrc /etc/lirc/lircrc
Weiterführende Informationen dazu sind hier zu finden.
Das zu steuernde Script
LIRC für Python installieren
Bevor wir jetzt zum eigentlichen Script kommen, installieren wir noch python-lirc
. Das ermöglicht dem Script den Zugriff auf LIRC.
$ sudo apt-get install python-lirc
Einfaches Testscript
Wir beginnen mit einem ganz einfachen Testscript, um die Funktionsweise des Ganzen näher zu betrachten. Das Script könnt Ihr einfach kopieren und unter beliebigem Namen (z.B. appleremote.py
) auf dem Raspberry Pi im Benutzer-Home-Verzeichnis abspeichern.
#!/usr/bin/env python #coding: utf8 import lirc import time sockid=lirc.init("appleremote", blocking = False) while True: codeIR = lirc.nextcode() if codeIR != []: print codeIR[0] time.sleep(0.05)
Das Script noch ausführbar machen…
$ chmod +x ~/appleremote.py
…, starten…
$ ~/appleremote.py
…und beliebige Tasten auf der Fernbedienung drücken. Das Script schreibt nun die gedrückte Taste ins Terminalfenster.
Erklärung: Den oberen Teil kennt Ihr ja bereits, darüber hab ich hier schonmal geschrieben. Ab Zeile 7 wird es interessant. Hier verbinden wir uns auf den Socket, den wir in der Datei .lircrc
erzeugt haben. Dadurch bekommen wir die in dieser Datei definierten Strings als Array übergeben, sobald eine Taste auf der Fernbedienung gedrückt wird. Ab Zeile 9 beginnt die Dauerschleife. In die Variable codeIR
lassen wir uns die Strings von LIRC hineinschreiben. Wird keine Taste gedrückt, ist sie leer. Sobald eine Taste gedrückt wird, bekommt codeIR
einen Inhalt wie beispielsweise [u'KEY_OK']
übergeben. Zeile 11: Wenn ein String übergeben/eine Taste gedrückt wurde… Zeile 12: …schreibe den Inhalt/das erste Element im Array ins Terminal.
Zeile 13 dient nur dazu, dass unser Script den Prozessor nicht komplett auslastet. Die Schleife wird nach jedem Durchlauf um 50ms angehalten, bevor es weiter geht. Das hat sich in der Praxis als guter Wert bewiesen. Es kommt zu keiner spürbaren Verzögerung und senkt die Prozessorlast, die das Script ausübt, von ~98% auf ~0,3%.
Das Script lässt sich mit Strg+C
beenden.
Erweitertes Testscript
Für mein eigentliches Ziel, das ich mit dieser Sache verfolge, brauch ich jede Taste einzeln. Daher hab ich das Script noch einmal erweitert, und zwar so, dass ich bei jeder Taste eine andere Aktion auslösen kann.
#!/usr/bin/env python #coding: utf8 import lirc import time sockid=lirc.init("appleremote", blocking = False) while True: codeIR = lirc.nextcode() if codeIR != []: if codeIR[0] == "KEY_UP": print "Taste KEY_UP gedrückt" elif codeIR[0] == "KEY_DOWN": print "Taste KEY_DOWN gedrückt" elif codeIR[0] == "KEY_LEFT": print "Taste KEY_LEFT gedrückt" elif codeIR[0] == "KEY_RIGHT": print "Taste KEY_RIGHT gedrückt" elif codeIR[0] == "KEY_OK": print "Taste KEY_OK gedrückt" elif codeIR[0] == "KEY_MENU": print "Taste KEY_MENU gedrückt" elif codeIR[0] == "KEY_PLAYPAUSE": print "Taste KEY_PLAYPAUSE gedrückt" time.sleep(0.05)
Diese Aktionen sind hier durch print
angedeutet. An dieser Stelle könnte aber ebenso gut auch ein GPIO.output(8, GPIO.HIGH)
stehen, um einen Ausgang zu setzen. Wer tatsächlich Ausgänge schalten möchte, wirft am Besten nochmal einen Blick auf diesen Beitrag und in das nachfolgende Script.
GPIO mit der Fernbedienung schalten
Zu guter Letzt erweitere ich mein Testscript noch um die GPIO-Ausgänge und meine Schaltung um das Relais-Modul.
Da der Zugriff auf GPIO einem Superuser vorbehalten ist, muss dieses Script mit sudo ausgeführt werden:
$ sudo ~/appleremote.py
Und hier kommt jetzt auch zum Tragen, wo sich die Datei lircrc
befindet. Sollte das Script mit einer Fehlermeldung abbrechen, schaut oben nochmal.
#!/usr/bin/env python #coding: utf8 import lirc import time import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) GPIO.setup( 8, GPIO.OUT) GPIO.setup(25, GPIO.OUT) sockid=lirc.init("appleremote", blocking = False) while True: codeIR = lirc.nextcode() if codeIR != []: if codeIR[0] == "KEY_UP": print "Taste KEY_UP gedrückt" GPIO.output(8, GPIO.LOW) elif codeIR[0] == "KEY_DOWN": print "Taste KEY_DOWN gedrückt" GPIO.output(8, GPIO.HIGH) elif codeIR[0] == "KEY_LEFT": print "Taste KEY_LEFT gedrückt" GPIO.output(25, GPIO.HIGH) elif codeIR[0] == "KEY_RIGHT": print "Taste KEY_RIGHT gedrückt" GPIO.output(25, GPIO.LOW) elif codeIR[0] == "KEY_OK": print "Taste KEY_OK gedrückt" elif codeIR[0] == "KEY_MENU": print "Taste KEY_MENU gedrückt" elif codeIR[0] == "KEY_PLAYPAUSE": print "Taste KEY_PLAYPAUSE gedrückt" time.sleep(0.05) GPIO.cleanup()
- Proxmox: „Failed to connect to Server“ mit Safari auf MacOS - 28. Januar 2023
- Loxone: Benachrichtigung per Telegram - 15. Januar 2022
- Telegram: Nachrichten per Bot von der Heimautomation aufs Handy - 2. Januar 2022
Pingback: Raspberry Pi | Pearltrees