Raspberry Pi: Mit Apple Remote+LIRC Python-Scripte steuern

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.

Raspberry Pi mit Fernbedienung steuern

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.

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, V_S, und mit etwas Abstand, 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, V_S mit Pin 1 (3,3V) und Out mit einem beliebigen GPIO. Ich verwende den GPIO23, also Pin 16.

Raspberry Pi mit IR-Empfänger TSOP 31238 (Schema)

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:

LIRC-Prinzipschema

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:

Raspberry Pi: Rohdaten von LIRC im Terminal

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:

1. Text lesen, Enter drücken.
2. 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.
3. Jetzt geht es ans Anlernen der Tasten: Wir geben den Namen der ersten Taste ein, die wir anlernen wollen: KEY_UP und drücken Enter. Anschließend drücken wir auf der Fernbedienung die Taste mit dem Pfeil nach oben.
4. Nächste Taste: Wir geben den Namen der zweiten Taste ein: KEY_DOWN, drücken Enter und betätigen auf der Fernbedienung die Taste mit dem Pfeil nach unten.
5. 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 und KEY_PLAYPAUSE.

Raspberry Pi: Tasten mit irrecord anlernen

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:

Raspberry Pi: Konfigurationsdatei lircd.conf testen

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.

Raspberry Pi mit 2-Kanal-Relais-Modul und IR-Empfänger (Schema)

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()

• Über
• Letzte Artikel

Sebastian

...ist staatlich geprüfter Techniker für Elektrotechnik, Schwerpunkt Prozessautomatisierung und Energietechnik. Die Themen Automatisierung und Programmierung haben es ihm besonders angetan.
Außerdem ist er für jede technische Spielerei zu haben 😉

Letzte Artikel von Sebastian (Alle anzeigen)

• 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