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

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, VS, und mit etwas Abstand, Out.

38kHz-IR-Empfänger TSOP 31238

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, VS 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)

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

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

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

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)

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)

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

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

31 Comments

  1. Avatar
    Antworten Mercy

    Moin Moin!
    Danke für die gute Anleitung. Diese hat mich wieder ein Stück weiter gebracht.
    Ich nutze den PI als Ambilight (was sehr gut funktioniert). Da mein komplettes Multimedia Geraffel (TV, Ambilight, BD, SAT, DVD, AV-Receiver, etc.) mittels Funksteckdose an- und ausgeschaltet wird (Strom sparen) möchte ich den PI vorher herunter fahren. Dazu will ich die FB des AV-Receiver nutzen, d.h. wenn der AV-Receiver ausgeschaltete wird, soll der PI mittels „sudo shutdown now“ herunter gefahren werden.
    lirc habe ich installiert, die FB hat schon ihre Tasten preisgegeben, aber wie bekomme ich den PI dazu beim drücken der „KEY_POWER“ auf der FB herunter zu fahren?
    Idee im lircrc:

    begin
        button = KEY_POWER
        prog = /etc/lirc/lirc_shutdown
        config = KEY_POWER
    end
    

    in lirc_shutdown:

    sudo shutdown now
    

    Könnte dieses funktionieren?
    Danke für deine Infos

    Gruß Mercy

    • Sebastian
      Antworten Sebastian

      Der Gedanke ist gut, aber es geht auch einfacher:
      In meinem Beispiel wird nur ein String übergeben. Du kannst in der Datei /etc/lirc/lircrc aber auch direkt Deine Aktion definieren. Das könnte dann so aussehen:

      begin
          button = KEY_POWER
          prog = irexec
          config = shutdown now
      end
      

      prog = irexec steht dabei dafür, einen Befehl direkt auszuführen oder ein Programm/Script zu starten.
      config = shutdown now ist der Befehl für das Herunterfahren.

      Da diese Befehle ohnehin als root ausgeführt werden, kannst Du Dir das sudo sparen. Natürlich könntest Du so auch ein Script ausführen. prog = irexec muss dann aber stehen bleiben.
      Änderungen an der Datei /etc/lirc/lircrc werden erst nach einem Neustart des Systems/LIRC wirksam.

  2. Avatar
    Antworten Gyula Borsos

    Hallo Sebastian,

    erstmal danke für die gute Anleitung! Es ist sehr hilfreich.
    Ich hätte eine Frage.
    Wie wäre es möglich, eine Ausgang (GPIO) bislang auf 1 halten , bis die RemoteControll taste gedrückt ist?
    (Ich möchte mit einer Ir-Taste einen Motor steuern)
    In python der Wert der lirc.nextcode() ist 1 nur in erstem zyklus, dann wird es zurückgesetzt, sobald die Taste noch gedrückt ist.

    Danke im Voraus.

    MfG:
    Gyula

    • Sebastian
      Antworten Sebastian

      Hi Gyula,
      eigentlich ist das ganz einfach, denn mein Beispiel-Script mit dem Relais zeigt, wie das prinzipiell funktioniert.
      Wie Du schon richtig erkannt hast, steht der Inhalt der codeIR-Variable nur einen Zyklus zur Verfügung. Deswegen wird der jeweils zum Code gehörende Befehl auch nur 1x abgearbeitet und auch der Ausgang entsprechend gesetzt.
      Grundsätzlich bleibt der Ausgang dann auch gesetzt – und zwar solange, bis Du ihn rücksetzt. Du müsstest mal Dein Programmablauf genau untersuchen, wann welcher Befehl ausgeführt wird. Sicher wirst Du zu der Erkenntnis kommen, dass irgendwo im Script der Rücksitzbefehl ausgeführt wird.
      Du kannst Deinen Code auch gern hier posten, das würde es einfacher machen, den genauen Fehler zu lokalisieren.

  3. Avatar
    Antworten Gyula Borsos

    Hallo Sebastian,
    danke für deine Rückmeldung!
    Mein Testscript sieht wie folgende aus:

    #!/usr/bin/env python2.7
    
    import pylirc as lirc
    import time
    blocking = 0
    import RPi.GPIO as GPIO
    GPIO.setmode(GPIO.BCM)
    GPIO.setup( 10, GPIO.OUT)
    sockid = lirc.init("irexec")
    
    while True:
          codeIR = lirc.nextcode()
          if codeIR == volume +:
             GPIO.output(10, GPIO.HIGH)
          time.sleep(0.2)
    

    Ich benutze pylirc statt lirc, weil der Command /blocking=False/ der Python-lirc bei mir nicht funtioniert.
    (Runeaudio – ArchLinux)
    Momentan wenn ich die „volume +“ Taste drücke, wird die Ausgang gesetzt.

    Das Ziel ist, wenn ich volume+ drücke, der Motor sollte solange laufen, bis die Taste gedrückt wird.
    (Bei loslassen der Taste, sollte die Ausgang zurückgesetzt werden)

    Danke im Voraus.

    MfG:
    Gyula

  4. Avatar
    Antworten Gyula Borsos

    Hallo Sebastian,

    zur Info.Erfolg!!
    In der lircrc soll repeat=1 einschreiben.
    Jetz kommt der Signal in jedem Takt!

    Danke.

    Gyula

    • Sebastian
      Antworten Sebastian

      Wunderbar, das hätte ich Dir auch empfohlen.
      Die Sache mit dem blocking löse ich übrigens anders.
      Ich erzeuge für die Remote einen eigenen Thread, der die IR-Signale empfängt. So hängt das Script nicht und ich muss in den IR-Thread keine Pause einfügen. Dadurch erfolgt auch eine unmittelbare Reaktion ohne zeitliche Verzögerung.

  5. Pingback: Raspberry Pi | Pearltrees

  6. Avatar
    Antworten Tobias

    Hallo. Danke für die Anleitung. Hat alles super geklappt. Ich habe aus Testzwecken erstmal eine LED mit LED.toggle() schalten wollen. jedoch schaltet diese erst bei jedem zweiten Tastendruck. Und es gibt auch Fehlinformationen von Tasten, die ich garnicht drücke. Dies hab ich mit einer gelb blinkenden LED signalisiert. Woran kann das denn liegen? Kann das sein dass der IR empfänger was abgekriegt hat? Ich hatte ihn am Anfang falsch angeschlossen und darauf ist er ziemlich warm geworden. Danke schonmal für deine Antwort

    • Sebastian
      Antworten Sebastian

      Hi Tobias,
      grundsätzlich ist es natürlich immer möglich, dass es etwas kaputt geht, wenn es falsch angeschlossen wird. Von der Ferne ist das schwer zu beurteilen.
      Leider ist jedoch Deine Fehlerbeschreibung nicht eindeutig genug, dass ich dazu irgendwas sagen könnte. Als erstes würde ich nochmal checken, ob die Frequenz des IR-Empfängers zur Fernbedienung passt.
      Was aber verbirgt sich hinter LED.toggle()? Wie sieht Dein Programm aus, das die LEDs schaltet? Funktioniert es denn wie gewünscht, wenn Du statt LIRC einfach mal einen GPIO-Pin zum toggeln verwendest?

  7. Avatar
    Antworten Stefan

    Hallo vielen Dank für deine sehr gut beschriebene Anleitung.

    Du hast erwähnt, das du die Abfrage in einem zweiten Thread erledigst. Könntest du diesen Beispielcode ebenfalls veröffentlichen?

    • Sebastian
      Antworten Sebastian

      Nachfolgend ein Beispiel, wie das aussehen könnte. Die Funktion remote() wird in einem neuen Thread ausgeführt (Zeile 58). Ein Tastendruck ruft dann im selben Thread die Funktion ircmd(...) und übergibt Parameter.

      #!/usr/bin/env python
      #coding: utf8 
      
      import lirc
      import RPi.GPIO as GPIO
      import sys
      import thread
      import time
      
      # ----------------------------------------------------------------------------
      #  Fernbedienung/LIRC abfragen
      # ----------------------------------------------------------------------------
      def remote():
      	while True:
      		codeIR = lirc.nextcode()
      		if codeIR != []:
      			if codeIR[0] == 'KEY_UP':
      				ircmd('cmd1')			
      			elif codeIR[0] == 'KEY_DOWN':
      				ircmd('cmd2')
      			elif codeIR[0] == 'KEY_LEFT':
      				ircmd('cmd3')
      			elif codeIR[0] == 'KEY_RIGHT':
      				ircmd('cmd4')
      			elif codeIR[0] == 'KEY_OK':
      				ircmd('cmd5')
      			elif codeIR[0] == 'KEY_MENU':
      				ircmd('cmd6')
      			elif codeIR[0] == 'KEY_PLAYPAUSE':
      				ircmd('cmd7')
      		time.sleep(0.05)
      	
      # ----------------------------------------------------------------------------
      #  Befehle ausführen
      # ----------------------------------------------------------------------------
      def ircmd(cmd):
      	# do commands from remote
      	
      # ----------------------------------------------------------------------------
      #  Script beenden
      # ----------------------------------------------------------------------------
      def getOut():
      	GPIO.cleanup()
      	sys.exit(0)
      
      # ----------------------------------------------------------------------------
      #  Hauptprogramm
      # ----------------------------------------------------------------------------
      if __name__ == '__main__':
      
      	GPIO.setmode(GPIO.BOARD)
      
      	GPIO.setup(22, GPIO.OUT)
      	GPIO.setup(24, GPIO.OUT)
      
      	sockid=lirc.init("appleremote", blocking = False)
      
      	thread.start_new_thread(remote,())	# Abfrage der Fernbedienung in neuem Thread starten
      
      	while True:
      		try:
      			# do things in mainthread 
      			time.sleep(0.1)
      		except KeyboardInterrupt:
      			getOut()
      

      Ich hab das Beispiel nicht ausprobiert, sondern einen anderen Code hergenommen und etwas entrümpelt. Kann also gut sein, dass das nicht auf Anhieb funktioniert. Das Prinzip sollte aber klar werden. Wichtig zu wissen ist noch: endet der Mainthread, endet auch das ganze Programm.

      Das Original befindet sich hier: http://indibit.de/multiroom-audio-wlan-lautsprecher-selber-bauen/

  8. Avatar
    Antworten Daniel

    Hallo

    ich komme bis zum Bereich „Einfaches Testscript“ … habe ein File erstellt was wie bei dir heisst „appleremote.py“ … den nächsten Befehl konnte ich aber nicht ausführen „chmod +x ~/appleremote.py“ .. dort kommt nur Folgende Meldung „chmod: Beim Setzen der Zugriffsrechte für „/home/pi/appleremote.py“: Die Operation ist nicht erlaubt“ … wenn ich es mit sudo davor gemacht habe ging es …. aber wenn ich das .py ausführen will kommt folgende Fehlermeldung

    File „/home/pi/appleremote.py“, line 7
    codeIR = lirc.nextcode()
    ^
    IndentationError: expected an indented block

    Was mache ich falsch .. habe vorher LIRC konfiguriert und 4 Tasten angelernt.

    grüße Daniel

  9. Avatar
    Antworten Daniel

    Hi

    eine Frage hätte ich noch … es funktioniert alles Bestens, bloß wie bekomme ich einen „toggle“ hin ?
    d.h. zurzeit brauch man ja 2 Tasten um das Relay an und auszuschalten. wie muss das Script aussehen wenn man nur 1 Taste benutzen möchte im toggle ?

    grüße

    • Sebastian
      Antworten Sebastian

      Ich setze mal voraus, dass Dein Script im Grunde den oben gezeigten Beispielen ähnelt.
      Mit einem if-Befehl wertest Du den IR-Code aus. Statt jetzt einfach den Ausgang zu setzen, fragst Du mit einem weiteren if-Befehl erstmal den Ausgang so ab, als währe es ein Eingang. Wenn er high ist, schaltest Du den Ausgang aus, ist er low, schaltest Du ihn ein. Das könnte dann so aussehen:

      while True:
          codeIR = lirc.nextcode()
          if codeIR != []:
              if codeIR[0] == "KEY_UP":
              	# Abfragen, ob Ausgang high ist
          		if GPIO.input(22) == GPIO.HIGH:
          			# Ausgang ausschalten
          			GPIO.output(22, GPIO.LOW)	
              	# Abfragen, ob Ausgang low ist
              	elif GPIO.input(22) == GPIO.LOW:
          			# Ausgang einschalten
          			GPIO.output(22, GPIO.HIGH)
      
  10. Avatar
    Antworten Stefan

    Hi Sebastian,

    erste Sahne Deine Anleitung ! Ich baue gerade meinen zweiten, verbesserten MP3 Hörbuchplayer für Blinde. Habe mir 2 Restposten bestellt: SIEMENS GIGASET RC 20 Fernbedienung und Infrarot-Empfänger HUEY-JANN IR1261, 38 kHz für zusammen unter 1,50 €. Mit Deiner Anleitung lief alles auf Anhieb!

    Super vielen Dank!
    Stefan

  11. Avatar
    Antworten Sebastian Sch.

    Hallo,

    versuche gerade meine Fernbedienung in OSMC zu integrieren.
    Es funktioniert bist zum Python skript alles.
    ->irw liefert die Tastenergebnisse
    ->~/.lircrc Informationen habe ich wie oben beschrieben eingefügt

    Pythonscript:

    import lirc
    sockid = lirc.init("fernbedienung-cdx", blocking = True)
    while 1:
            codeIR = lirc.nextcode()
            print codeIR
    

    Führe ich das Skript aus und drücke eine Taste kommt immer nur [] ohne Inhalt, egal bei welcher Taste.
    Komisch ist, dass wenn ich im Py-Script den Namen fernbedienung-cdx ändere( auf einen nicht existierenden Namen) passiert genau das gleiche.

    hat jemand auch mit dem Problem zu kämpfen oder hat eine Ahnung an was das liegen könnte?

    lg Sebastian

    • Sebastian
      Antworten Sebastian

      Hast Du denn auch den Hinweis beachtet?

      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

      • Avatar
        Antworten Sebastian Sch.

        Du bist ein Wahnsinn vielen Dank für die schnelle Antwort.
        Hat das Problem gelöst, habe ich überlesen.

  12. Avatar
    Antworten Tobias

    Hallo. Erstmal danke für die umfangreiche Anleitung. Aber irgendwie bekomme ich den Python Script nicht zum laufen. Weder den einfachen Testscript noch den erweiterten Testscript. Am Anfang hatte es wegen dem print-Befehl gemeckert. Nachdem ich dann die Klammern nachträglich eingebaut habe, erscheint immer die Fehlermeldung
    ImportError: No module named 'lirc'
    Ich habe die Anleitung zu 100% befolgt und bis zu der Stelle hat auch alles funktioniert (mode2 usw…) was mache ich denn falsch?

    • Sebastian
      Antworten Sebastian

      Hi Tobias,
      wo fehlen denn Klammern im Script?

      Aus der Fehlermeldung würde ich schließen, dass das Paket python-lirc nicht (korrekt) installiert ist. Setz‘ doch nochmal folgenden Befehl ab:
      $ sudo apt-get install python-lirc

      • Avatar
        Antworten Tobias

        In deinen Beispielen stand
        print „Taste … gedrückt“
        Bei mir wollte er Klammern haben
        print („Taste … gedrückt“)

        Und Python-Lirc ist laut Terminal Ausgabe installiert und auf dem neusten Stand.

  13. Avatar
    Antworten PiMan

    Danke für das Tutorial, bei mir hängt es an Python-LIRC:
    Ich habe die neuste Raspbian-Version (update/upgrade/dist), ebenso LIRC heute erst installiert und dennoch meldet mir die Shell „E: Paket python3-lirc kann nicht gefunden werden.“
    Selbst über „sudo dpkg -i python3-lirc_1.2.1-1_all.deb“ meldet sich „Auf das Paket … kann nicht zugegriffen werden.“ Auch Internet/Firewall ist alles dafür offen.
    Hast du vielleicht eine Idee oder einen Tipp, wie ich es dennoch auf den Pi bekomme?
    Danke!

    • Sebastian
      Antworten Sebastian

      Hi,
      Ich kann da leider nichts dazu sagen.
      Allerdings habe ich Python 2 und demzufolge python_lirc in den Beispielen verwendet.

  14. Avatar
    Antworten Jens

    Hallo Sebastian,
    ich habe das oben aufgeführte Tutorial schon viele Male gemacht und an sich nie Pobleme gehabt. Nun bleibe ich aber beim ersten Test-Mapping hängen. Habe bis dahin an sich alles wie Du beschrieben hast gemacht. Aber nach der Eingabe von
    irsend LIST appleremote „“ kommt
    Irsend:command failed: List appleremote
    irsend:unknown remote: „appleremote“
    Keine Ahnung wo ich da den Fehler eingebaut habe. Kannst Du mir dabei weiter helfen?
    Vielen Dank
    Gruß Jens

    • Sebastian
      Antworten Sebastian

      Hi Jens,
      sieht für mich so aus, als gäbe es ein Problem mit der lircd.conf . Hast du dich beim Namen vielleicht verschrieben? Liegt die Datei auch am richtigen Ort?

  15. Avatar
    Antworten Uwe

    Hallo
    Ich hoffe du kannst mir weiterhelfen. Ich wollte die Oscam per lirc neustarten können. Leider funktioniert es nicht. Reboot von Raspian funktioniert schon einwandfrei und der Befehl oscam -b funktioniert auch einwandfrei wenn ich mit Putty auf den Raspberry zugreife, aber mit lirc hab ich es leider nicht hinbekommen.So steht es in meiner .lircxrc

    begin
      prog = irexec
      button = 4
      config =/usr/bin/oscam -b
    end
    
    • Sebastian
      Antworten Sebastian

      Hi Uwe,
      ich kenne mich mit Oscam leider nicht aus, daher kann ich kaum etwas dazu sagen.
      Sorry.

  16. Avatar

Hinterlasse eine Antwort

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.