Réception de la télécommande infrarouge avec Intel Edison

Reçoit une télécommande infrarouge à l'aide du GPIO de la carte Intel Edison Arduino. Cette fois, le module de réception de télécommande infrarouge utilisé était PL-IRM0101.

Connexion du capteur infrarouge

Utilisez une maquette pour connecter la carte Intel Edison Arduino au PL-IRM0101.

Les broches de PL-IRM0101 sont ** Vout ** (4,5 à 5,5 V), ** GND **, ** VCC ** (4,5 à 5,5 V) du côté gauche, donc la broche du côté gauche. Connectez-vous à l'entrée / sortie numérique 8, la broche du milieu à GND et la broche droite à Power 5V.

Format de la télécommande infrarouge

Le format de la télécommande infrarouge n'est pas clairement défini par RFP, etc., mais il semble qu'il soit conforme au format NEC ou au format Home Appliances Association au Japon. Pour plus de détails sur chaque format, reportez-vous aux documents suivants.

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

Cette fois, nous allons implémenter la partie analyse de la commande envoyée au format coopératif de l'électroménager avec python2.7.

Programme d'analyse des commandes de la télécommande infrarouge

Le système d'exploitation par défaut d'Intel Edison inclut la bibliothèque d'abstraction matérielle ** MRAA ** fournie par Intel depuis le début, et il peut être utilisé à partir de Python comme s'il s'agissait d'une bibliothèque standard.

irsensor.py

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

import mraa
import time

PIN = 8          #Numéro GPIO de la carte Arudino à laquelle Vout est connecté
BUF = 0.35       # HIGH/Largeur de flou autorisée pour une durée FAIBLE[ms]
FLAME_SPACE = 50 #La durée de LOW pour déterminer qu'une série de commandes est terminée[ms]

HIGH, LOW = 1, 0


class KadenkyoDecoder(object):
    L_HIGH = 3.2   #Durée HIGH dans le code leader du format coopératif d'électroménager[ms]
    L_LOW = 1.6    #FAIBLE durée dans le code leader du format coopératif d'électroménager[ms]

    D_LOW_0 = 0.4  #Durée FAIBLE quand 0 dans le code de données du format coopératif de l'électroménager[ms]
    D_LOW_1 = 1.2  #Durée FAIBLE en cas de 1 dans le code de données du format coopératif de l'électroménager[ms]

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

    def decode(self):
        if len(self.code) <= 3: #Reçu HIGH/Si la taille de la liste LOW est inférieure ou égale à 3, elle est considérée comme du bruit.
            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/HIGH la liste des durées FAIBLES&Convertir en une liste de paires FAIBLES
        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): #Vérifiez s'il correspond au code de lecteur du format coopératif de l'électroménager
        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): #HIGH selon la définition du code de données du format coopératif de l'électroménager&Convertir la paire LOW en 0 ou 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) #Obtenez l'état de tension GPIO spécifié à l'aide de la bibliothèque MRAA d'Intel
    ir.dir(mraa.DIR_IN)

    recv, last, st, nt, code = False, LOW, 0, 0, []
    while True:
        current = not ir.read()  # PL-IRM0101 renvoie 0 lorsqu'il reçoit des rayons infrarouges, donc inversion de bits
        nt = time.time() * 1000
        if last != current: #Mesurer le temps de front à partir du bord où HAUT et BAS sont inversés
            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_S'il continue à être BAS pendant SPACE, il est jugé que la commande est terminée.
            # 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-Quitter lorsque C est entré
        print "end"

Dans le code ci-dessus, le traitement suivant est effectué approximativement (le traitement des erreurs n'est pas du tout implémenté, il est donc préférable de l'ajouter si nécessaire).

1. main (): À partir du changement de tension Vout du module de réception de la télécommande infrarouge, mesurez et répertoriez l'heure à laquelle les rayons infrarouges sont reçus (HIGH) et l'heure à laquelle les rayons infrarouges ne sont pas reçus (LOW).
2. KadenkyoDecoder (code) .decode (): Décompose l'impulsion infrarouge obtenue en un code de lecteur, un code de données et un bit d'arrêt à la lumière de la définition du format Home Appliance Association.
3. Si le format Home Appliance Association est suivi, la partie du code de données est décodée dans un tableau de 48 bits et renvoyée.
4. Renvoie «INCONNU» s'il ne respecte pas le format de l'Association d'appareils ménagers

Notez que le Vout obtenu à partir de PL-IRM0101 renvoie 0 lors de la réception de rayons infrarouges et 1 lors de la non réception de rayons infrarouges.

Le code PIN, BUF secondes et FLAME_SPACE secondes peuvent varier en fonction de l'environnement. Je veux que vous l'adaptiez à un bon.

Résultat d'exécution

Résultat d'exécution

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

Lorsque j'ai pointé la télécommande infrarouge pour un certain décodeur vers le capteur et appuyé sur quelques boutons, le résultat ci-dessus a été obtenu.

Cette télécommande infrarouge pour le décodeur semble être capable d'envoyer quatre types de commandes selon le format coopératif de l'électroménager qui fait fonctionner le téléviseur lui-même, et plusieurs commandes qui ne suivent pas le format coopératif de l'appareil ménager qui fait fonctionner le décodeur.

Correspondance entre les commandes transmises et les touches de fonctionnement du téléviseur

010000000000010000000001000000001011110010111101  =>Allumer/OFF
010000000000010000000001000000000010110000101101  =>Sur la chaîne
010000000000010000000001000000001010110010101101  =>Sous le canal
010000000000010000000001000000001010000010100001  =>Commutation de la source d'entrée

Résumé

Cette fois, à l'aide de la carte ntel Edison Arduino et du module récepteur de télécommande infrarouge, nous avons analysé les commandes du format coopératif d'appareils ménagers de la télécommande infrarouge.

À l'avenir, il sera intéressant de prendre en charge le format NEC, de prendre en charge lorsque le bouton est maintenu enfoncé et de prendre en charge la fonction d'apprentissage des commandes de la télécommande infrarouge.