[PYTHON] Infrarot-Fernbedienungsempfang mit Intel Edison

Empfängt Infrarot-Fernbedienung über GPIO des Intel Edison Arduino Board. Dieses Mal wurde als Empfangsmodul für die Infrarot-Fernbedienung [PL-IRM0101] verwendet (http://akizukidenshi.com/download/ds/paralight/DS-27-01-0001%20PL-IRM0101-3%20B1.pdf).

Infrarotsensoranschluss

Verwenden Sie ein Steckbrett, um das Intel Edison Arduino Board mit dem PL-IRM0101 zu verbinden.

Die Stifte von "PL-IRM0101" sind ** Vout ** (4,5 bis 5,5 V), ** GND **, ** VCC ** (4,5 bis 5,5 V) von der linken Seite, also der linke Stift. Verbinden Sie den digitalen Eingang / Ausgang 8, den mittleren Pin mit GND und den rechten Pin mit Power 5V.

Infrarot-Fernbedienungsformat

Das Format der Infrarot-Fernbedienung ist durch RFP usw. nicht klar definiert, scheint jedoch dem NEC-Format oder dem Format der Home Appliances Association in Japan zu entsprechen. Einzelheiten zu den einzelnen Formaten finden Sie in den folgenden Materialien.

http://akizukidenshi.com/download/k4174_format.pdf

Dieses Mal implementieren wir den Analyseteil des Befehls, der im kooperativen Format der Home Appliance mit python2.7 gesendet wird.

Programm zur Analyse von Infrarot-Fernbedienungsbefehlen

Das Standardbetriebssystem von Intel Edison enthält die von Intel von Anfang an bereitgestellte Hardware-Abstraktionsbibliothek ** MRAA ** und kann von Python aus wie eine Standardbibliothek verwendet werden.

irsensor.py

#! /usr/bin/env python
# -*- coding: utf-8 -*-

import mraa
import time

PIN = 8          #GPIO-Nummer des Arudino-Boards, mit dem Vout verbunden ist
BUF = 0.35       # HIGH/Zulässige Unschärfebreite für NIEDRIGE Dauer[ms]
FLAME_SPACE = 50 #Die Dauer von LOW, um festzustellen, dass eine Reihe von Befehlen beendet wurde[ms]

HIGH, LOW = 1, 0


class KadenkyoDecoder(object):
    L_HIGH = 3.2   #HOHE Dauer im Leader-Code des kooperativen Formats für Haushaltsgeräte[ms]
    L_LOW = 1.6    #NIEDRIGE Dauer im Leitcode des kooperativen Formats für Haushaltsgeräte[ms]

    D_LOW_0 = 0.4  #NIEDRIGE Dauer, wenn 0 im Datencode des kooperativen Formats für Haushaltsgeräte[ms]
    D_LOW_1 = 1.2  #NIEDRIGE Dauer bei 1 im Datencode des Genossenschaftsformats für Haushaltsgeräte[ms]

    def __init__(self, code):
        self.code = code

    def decode(self):
        if len(self.code) <= 3: #HIGH erhalten/Wenn die Größe der LOW-Liste 3 oder weniger beträgt, wird dies als Rauschen betrachtet.
            return "UNKNOWN"

        paired = self.__make_pair(self.code[:-1])

        if not self.__is_valid_format(paired[0]):
            return "UNKNOWN"
        else:
            return "".join(map(str, map(self.__make_bit, paired[1:])))

    def __make_pair(self, code): # HIGH/HOCH die Liste der NIEDRIGEN Dauern&In eine Liste von LOW-Paaren konvertieren
        def pair(l):
            for i in xrange(0, len(l), 2):
                yield {"H": l[i]["len"], "L": l[i + 1]["len"]}
        return list(pair(code))

    def __is_valid_format(self, lc): #Überprüfen Sie, ob es mit dem Lesercode des kooperativen Formats für Haushaltsgeräte übereinstimmt
        h = self.L_HIGH - BUF <= lc["H"] <= self.L_HIGH + BUF
        l = self.L_LOW - BUF <= lc["L"] <= self.L_LOW + BUF
        return h and l

    def __make_bit(self, dc): #HOCH gemäß der Definition des Datencodes des Genossenschaftsformats für Haushaltsgeräte&Konvertieren Sie das LOW-Paar in 0 oder 1
        if self.D_LOW_0 - BUF <= dc["L"] <= self.D_LOW_0 + BUF:
            return 0
        elif self.D_LOW_1 - BUF <= dc["L"] <= self.D_LOW_1 + BUF:
            return 1
        else:
            return 9


def print_code(code):
    for i, elem in enumerate(code):
        s = "LOW " if elem["state"] == HIGH else "HIGH"
        print "%03d: %s %5.2f[ms]" % (i, s, round(elem["len"], 2))


def main():
    ir = mraa.Gpio(PIN) #Ermitteln Sie den angegebenen GPIO-Spannungsstatus mithilfe der MRAA-Bibliothek von Intel
    ir.dir(mraa.DIR_IN)

    recv, last, st, nt, code = False, LOW, 0, 0, []
    while True:
        current = not ir.read()  # PL-IRM0101 gibt 0 zurück, wenn es Infrarotstrahlen empfängt, also Bitinversion
        nt = time.time() * 1000
        if last != current: #Messen Sie die Kantenzeit von der Kante, an der HIGH und LOW invertiert sind
            last = current
            if not recv:
                recv = True
                st = time.time() * 1000
                continue
            code.append({"state": last, "len": nt - st})
            st = nt
        if recv and last == LOW and nt - st > FLAME_SPACE: # FLAME_Wenn es während SPACE weiterhin LOW ist, wird beurteilt, dass der Befehl beendet wurde.
            # print_code(code)
            s = KadenkyoDecoder(code).decode()
            print s
            recv, last, st, nt, code = False, LOW, 0, 0, []

if __name__ == "__main__":
    try:
        print "start"
        main()
    except KeyboardInterrupt as err: # Ctrl-Beenden Sie, wenn C eingegeben wird
        print "end"

Im obigen Code wird die folgende Verarbeitung grob ausgeführt (die Fehlerverarbeitung ist überhaupt nicht implementiert, daher ist es besser, sie nach Bedarf hinzuzufügen).

1. main (): Messen und listen Sie anhand der Vout-Spannungsänderung des Empfangsmoduls der Infrarotfernbedienung die Zeit auf, zu der Infrarotstrahlen empfangen werden (HIGH) und die Zeit, zu der Infrarotstrahlen nicht empfangen werden (LOW).
2. KadenkyoDecoder (Code) .decode (): Zerlegt den erhaltenen Infrarotimpuls unter Berücksichtigung der Definition des Home Appliance Association-Formats in einen Lesecode, einen Datencode und ein Stoppbit.
3. Wenn das Format der Home Appliance Association verwendet wird, wird der Datencodeteil in ein 48-Bit-Bit-Array decodiert und zurückgegeben.
4. Gibt "UNBEKANNT" zurück, wenn das Format der Home Appliance Association nicht eingehalten wird

Beachten Sie, dass der von PL-IRM0101 erhaltene Vout beim Empfang von Infrarotstrahlen 0 und beim Nichtempfang von Infrarotstrahlen 1 zurückgibt.

Die PIN-Nummer, BUF-Sekunden und FLAME_SPACE-Sekunden können je nach Umgebung variieren. Ich möchte, dass Sie es auf ein gutes einstellen.

Ausführungsergebnis

Ausführungsergebnis

root@edison:~# ./irsensor.py 
start
010000000000010000000001000000001011110010111101
UNKNOWN
UNKNOWN
010000000000010000000001000000000010110000101101
UNKNOWN
UNKNOWN
010000000000010000000001000000001010110010101101
UNKNOWN
UNKNOWN
UNKNOWN
UNKNOWN
010000000000010000000001000000001010110010101101
UNKNOWN
UNKNOWN
010000000000010000000001000000001010000010100001
UNKNOWN
UNKNOWN
UNKNOWN
UNKNOWN
010000000000010000000001000000001011110010111101
UNKNOWN
UNKNOWN
^Cend

Als ich die Infrarot-Fernbedienung für eine bestimmte Set-Top-Box auf den Sensor richtete und einige Tasten drückte, wurde das obige Ergebnis erzielt.

Diese Infrarot-Fernbedienung für die Set-Top-Box scheint in der Lage zu sein, vier Arten von Befehlen gemäß dem kooperativen Format der Haushaltsgeräte, mit denen das Fernsehgerät selbst betrieben wird, und mehrere Befehle zu senden, die nicht dem kooperativen Format der Haushaltsgeräte entsprechen, mit dem die Set-Top-Box betrieben wird.

Korrespondenz zwischen übertragenen Befehlen und TV-Bedientasten

010000000000010000000001000000001011110010111101  =>Ein/OFF
010000000000010000000001000000000010110000101101  =>Auf dem Kanal
010000000000010000000001000000001010110010101101  =>Unter dem Kanal
010000000000010000000001000000001010000010100001  =>Eingangsquellenumschaltung

Zusammenfassung

Dieses Mal haben wir mit dem ntel Edison Arduino Board und dem Empfängermodul für Infrarot-Fernbedienungen die Befehle des kooperativen Formats der Infrarot-Fernbedienung für Haushaltsgeräte analysiert.

In Zukunft wird es interessant sein, das NEC-Format, die Unterstützung bei gedrückter Taste und die Befehlslernfunktion der Infrarot-Fernbedienung zu unterstützen.