Raspberry Pi: Mit LIRC Infrarot-Befehle senden (irsend)

Wie man mit einer Infrarot-Fernbedienung ein Python-Script und am Raspberry Pi angeschlossene Hardware steuern kann, hatte ich hier schonmal gezeigt. In diesem Beitrag soll es nun darum gehen, Infrarot-Befehle an ein beliebiges Gerät zu senden. Ich orientiere mich dazu weitestgehend an dem Ursprünglichen Beitrag, einige Dinge werden Euch also vielleicht bekannt vorkommen.

Raspberry Pi mit IR-Receiver und IR-Emitter

Raspberry Pi mit IR-Receiver und IR-Emitter

Für dieses Vorhaben verwende ich einen Raspberry Pi Modell B+, den 38kHz-IR-Empfänger TSOP 31238, einen IR-Emitter, den ich ganz billig in China geschossen habe, sowie einige female-female-Steckbrücken (40er-Pack). Dazu noch eine beliebige Fernbedienung, deren Befehle imitiert werden sollen. Bei mir ist das wieder die Apple Remote.

Schaltung aufbauen

Das Aufbauen der Schaltung ist schnell gemacht. Dem Datenblatt entnehmen wir die Anschlussbelegung des Infrarot-Empfängers: Mit der Wölbung nach oben und Blick auf die Anschlüsse zählen wir von links nach rechts: GND, VS, und mit etwas Abstand, Out.

Über die Belegung der GPIO-Anschlüsse hatte ich hier schonmal geschrieben. Wir verbinden also GND mit dem Pin 14, VS mit Pin 1 (3,3V) und Out mit einem beliebigen GPIO. Ich verwende den GPIO23, also Pin 16.

Den IR-Empfänger brauchen wir hier eigentlich nur, um eine Fernbedienung anlernen zu können. Für das reine Senden von IR-Signalen ist er nicht nötig. Vielleicht findet Ihr ja hier Eure Fernbedienung, dann könnt Ihr Euch die Mühe mit dem Anlernen sparen.

Infrarot-Empfänger

38kHz-IR-Empfänger TSOP 31238

Infrarot-Emitter

Open Smart IR-Emitter

Wie der Infrarot-Emitter angeschlossen werden soll, ist direkt auf der Platine aufgedruckt. Wir verbinden also GND mit Pin 20 am RPi, VCC mit Pin 2 (5V) und SIG wieder mit einem beliebigen GPIO. Hier nutze ich GPIO24 (Pin 18).

Raspberry Pi mit Infrarot-Empfänger und Infrarot-Emitter

Raspberry Pi mit IR-Empfänger TSOP 31238 und IR-Emitter

Linux Infrared Remote Control (LIRC)

Um die Signale, die der Infrarot-Empfänger an den Raspberry Pi weiterleitet, interpretieren und eigene Befehle über den Infrarot-Emitter senden zu können, verwenden wir LIRC. Im Paket enthalten ist alles, was wir für unser Vorhaben benötigen. Weiterführende Informationen zu LIRC findet Ihr hier.

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 gpio_out_pin=24

Auf Zeile 9 geben wir in BCM-Zählweise an, welche GPIO wir mit LIRC nutzen wollen – also die GPIO-Nummern, 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

Recht weit unten (bei mir Zeile 51) passen wir die Einstellungen wie folgt an:

# Uncomment this to enable the lirc-rpi module
dtoverlay=lirc-rpi,gpio_in_pin=23,gpio_out_pin=24

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

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. Die angelernten Daten sind dann auch gleich die Informationen, die wir für das Senden von IR-Befehlen benötigen.

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 kann man die Tastenbezeichnungen auch im Nachgang noch anpassen. Solltet Ihr Eure Fernbedienung in den erlaubten Tastenbezeichnungen nicht wiederfinden, könnt Ihr erstmal beliebige verfügbare Bezeichnungen nutzen, und im Nachgang die Bezeichnungen frei ändern. Bei Interesse findet Ihr hier die Dokumentation zu irrecord.

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

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

Raspberry Pi: Konfigurationsdatei lircd.conf testen

Wenn wir genug gesehen haben, beenden wir das Ganze mit der Tastenkombination Strg-C.

Aktionen erstellen (.lircrc)

Hier ein Schnitt.
Warum? Zum Senden von Infrarot-Signalen benötigen wir diese Aktionen nicht, sondern nur um empfangene Signale einfacher auswerten zu können. Wer’s doch braucht, schaut hier nach.

Infrarot-Signale senden…

…auf der Kommandozeile

An diesem Punkt sind wir schon in der Lage, Infrarot-Signale zu senden, und das testen wir gleich mal. Auf der Kommandozeile setzen wir folgenden Befehl ab:

$ irsend SEND_ONCE appleremote KEY_UP

Was ist nun passiert? Wir haben den Befehl, der mit der „Hoch“-Taste auf der Apple Remote ausgelöst wird, genau ein mal gesendet. Es ist jedoch auch möglich, den Befehl dauerhaft (wiederholt) zu senden. Der Befehl dafür lautet:

$ irsend SEND_START appleremote KEY_UP

Gesendet wird nun solange, bis das Ganze wieder gestoppt wird:

$ irsend SEND_STOP appleremote KEY_UP

Wer sich nicht sicher ist, ob die Hardware richtig funktioniert und die Signale auch wirklich korrekt gesendet werden, kann das ganz einfach überprüfen:
Auf der Kommandozeile den Befehl $ irsend SEND_START appleremote KEY_UP absetzen und die Diode ganz gerade in die Linse einer Digitalkamera halten. Auf dem Display sieht man sie dann blinken. 

Weitere Informationen zu irsend findet Ihr hier.

…mit Python

Für das reine Senden von Infrarot-Signalen benötigen wir keine weiteren Pakete, sondern können einfach loslegen. Wir nutzen dafür einfach die Möglichkeit, aus einem Python-Script heraus Kommandozeilenbefehle abzusetzen.

Dazu bauen wir ein einfaches Testscript. Das Script könnt Ihr einfach kopieren und unter beliebigem Namen (z.B. send-ir.py) auf dem Raspberry Pi im Benutzer-Home-Verzeichnis abspeichern.

#!/usr/bin/env python
#coding: utf8

import os
import time

while True:
	os.system("irsend SEND_ONCE appleremote KEY_UP")
	time.sleep (1)

Das Script noch ausführbar machen…

$ chmod +x ~/send-ir.py

… und starten:

$ ~/send-ir.py

Was nun passiert erklärt sich fast von selbst. Solange, wie das Script aktiv ist, wird der Befehl KEY_UP gesendet und anschließend eine Sekunde gewartet. Dann wieder der Befehl gesendet, gewartet, usw.

Das Script lässt sich mit Strg+C beenden.

Das war’s? Jup. Die Grundlagen habt Ihr. Jetzt könnt Ihr etwas eigenes daraus bauen. Viel Spaß dabei 😉

Sebastian

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 😉
Sebastian

Hinterlasse einen Kommentar

Hinterlasse den ersten Kommentar!

Benachrichtige mich zu:
avatar
wpDiscuz
Translate »