MicroPython mit ESP32: IR-Signale empfangen und verarbeiten

Posted on by Stefan Draeger

In diesem Beitrag möchte ich dir gerne zeigen, wie du IR-Signale am ESP32 in MicroPython empfangen und verarbeiten kannst. Dem Rich Shield liegt eine kleine Infrarotfernbedienung bei, welche ich nachfolgend auslesen und über die Tasten, die LEDs und die Segmentanzeige steuern möchte.

MicroPython & ESP32 - IR-Signale empfangen und verarbeiten
Dieses Video auf YouTube ansehen.

Wie du eine Infrarotfernbedienung am ESP32 in MicroPython programmierst, habe ich dir bereits im Beitrag Infrarot-Fernbedienung mit dem ESP32 und MicroPython auslesen: Ein Anfängerleitfaden gezeigt. Hier möchte ich an diesen Beitrag anknüpfen und dir ein paar Anwendungsfälle am Rich Shield von Open Smart zeigen.

Inhaltsverzeichnis

Aufbau der Schaltung ohne Rich Shield

Wenn du das Rich Shield von Open Smart nicht hast, dann kannst du dir diese kleine Schaltung auch sehr einfach und günstig nachbauen.

Den Infrarotempfänger bekommst du als einzelne Diode und auch als fertigen Baustein auf einer Platine. Ich würde dir empfehlen zu einer Platine zu greifen, das ist deutlich einfacher als die Schaltung mit der einzelnen Diode.

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Infrarotfernbedienungen

Es gibt zu diversen mobilen Geräten Infrarotfernbedienungen, welche wir am Mikrocontroller auslesen können. Zumeist funktioniert dieses auch recht gut, nur manchmal muss man die Protokolle durchspielen, um es zum Laufen zu bekommen.

Infrarot Fernbedienung
Infrarot Fernbedienung
Infrarotfernbedienung
Infrarotfernbedienung
IR Fernbedienung für Grundig LED Spots
IR Fernbedienung für Grundig LED Spots

In diesem Beitrag verwende ich eine einfache IR-Fernbedienung, welche dem Rich Shield von Open Smart beiliegt. Du bekommst diese aber auch inkl. IR-Empfänger in einem Set recht günstig auf ebay.de oder aliexpress.com.

Auslesen der Infrarotfernbedienung

Bevor wir den Tasten der Infrarotfernbedienung eine Aktion zuweisen können, müssen wir diese zunächst auslesen. Dazu wiederum benötigen wir ein Modul, welches wir vom GitHub Repository peterhinch/micropython_ir als ZIP-Datei herunterladen können.

Der folgende Python-Code ist für einen Mikrocontroller geschrieben und ermöglicht es, Signale von einer Infrarot-Fernbedienung (IR-Fernbedienung) zu empfangen und zu verarbeiten.

1. Import der benötigten Module

Zuerst importieren wir die notwendigen Module:

from machine import Pin, freq
from ir_rx.print_error import print_error
from ir_rx.nec import NEC_16
  • Pin und freq stammen aus dem machine Modul. Diese helfen uns dabei, mit den Pins des Mikrocontrollers zu arbeiten und die Frequenz einzustellen.
  • print_error importieren wir aus dem Modul ir_rx.print_error, um Fehler anzeigen zu können.
  • NEC_16 importieren wir aus ir_rx.nec. Dies ist das Protokoll, das wir für unsere IR-Fernbedienung verwenden.

2. Konfiguration des IR-Empfängers

Hier konfigurieren wir den Pin, an dem unser IR-Empfänger angeschlossen ist:

pin_ir = Pin(26, Pin.IN)
  • Der IR-Empfänger ist an GPIO26 (Pin 26) angeschlossen und wird als Eingabepin (Pin.IN) definiert.

3. Dekodierung der Tastenwerte

Wir definieren eine Funktion, die die empfangenen Daten ausgibt:

def decodeKeyValue(data):
    print(data)
  • Diese Funktion gibt einfach den empfangenen Datenwert aus. Hier können wir später Logik hinzufügen, um auf verschiedene Tasten zu reagieren.

4. Callback-Funktion

Diese Funktion wird aufgerufen, wenn eine Taste auf der Fernbedienung gedrückt wird:

def callback(data, addr, ctrl):
    if data < 0:
        pass
    else:
        decodeKeyValue(data)
  • Wenn ungültige Daten empfangen werden (data < 0), passiert nichts.
  • Bei gültigen Daten rufen wir die decodeKeyValue(data) Funktion auf.

5. Initialisierung des IR-Empfängers

Hier richten wir das IR-Modul ein:

ir = NEC_16(pin_ir, callback)
ir.error_function(print_error)
  • Wir initialisieren das IR-Modul und geben den Pin sowie die Callback-Funktion an.
  • Bei Fehlern wird die print_error Funktion aufgerufen.

6. Hauptprogramm

Das Hauptprogramm läuft in einer Endlosschleife:

try:
    while True:
        pass
except KeyboardInterrupt:
    ir.close()
  • Das Programm bleibt in einer Endlosschleife (while True).
  • Wenn das Programm durch Strg + C oder durch die IDE unterbrochen wird (KeyboardInterrupt), wird die Verbindung zum IR-Modul sauber geschlossen (ir.close()).
#Import der benötigten Module
from machine import Pin, freq
from ir_rx.print_error import print_error
#Für die IR-Fernbedienung benötige ich das Modul NEC-16
#ggf. musst du hier den Import anpassen.
from ir_rx.nec import NEC_16

#IR-Receiver am Pin GPIO14 angeschlossen
pin_ir = Pin(26, Pin.IN)

#Funktion um den Code der Taste auszuwerten,
#hier können wir später mit einem Switch oder einer
#If-Bedienung auf die Tasten reagieren.
def decodeKeyValue(data):
    print(data)

#Funktion welche bei einem Tastendruck auf
#der IR-Fernbedienung ausgeführt werden soll.
def callback(data, addr, ctrl):
    #Wenn keine gültigen Daten empfangen wurden
    #dann soll nichts passieren.
    if data < 0:
        pass
    else:
        #Wenn jedoch gültige Daten empfangen wurden,
        #dann soll die Funktion decodeKeyValue mit
        #diesen aufgerufen werden.
        print(decodeKeyValue(data))

#Definieren das, dass IR-Modul am Pin 14 angeschlossen ist,
#zusätzlich wird noch ein Callback angegeben welcher aufgerufen wird,
#wenn eine Taste betätigt wird.
ir = NEC_16(pin_ir, callback)
#Im Fehlerfall soll die das Modul "print_error" angesteuert werden
ir.error_function(print_error)

#Try-Except Block
try:
    #starten einer leeren Endlosschleife
    while True:
        pass
#Wenn das Programm über Strg + C oder
#über die IDE abgebrochen wird, wird ebenso
#die Verbindung zum IR-Modul geschlossen.
except KeyboardInterrupt:
    ir.close()

Steuern der LEDs via Infrarotfernbedienung

Auf dem Rich Shield sind vier LEDs verbaut, welche wir bereits in den letzten Beiträgen ausgiebig genutzt haben, in diesem Beispiel möchte ich diese nun mit der Infrarotfernbedienung Ein-/Ausschalten.

Da die LEDs mit LED1, LED2 … beschriftet sind, bieten sich hier die Tasten 1 bis 4 an.

#Import der benötigten Module
from machine import Pin, freq
from ir_rx.print_error import print_error
#Für die IR-Fernbedienung benötige ich das Modul NEC-16
#ggf. musst du hier den Import anpassen.
from ir_rx.nec import NEC_16

#IR-Receiver am Pin GPIO26 angeschlossen
pin_ir = Pin(26, Pin.IN)

#rote LED am GPIO17
ledRed = Pin(17, Pin.OUT)
#gruene LED am GPIO16
ledGreen = Pin(16, Pin.OUT)
#blaue LED am GPIO27
ledBlue = Pin(27, Pin.OUT)
#gelbe LED am GPIO14
ledYellow = Pin(14, Pin.OUT)

#alle LEDs deaktivieren
ledRed.off()
ledGreen.off()
ledBlue.off()
ledYellow.off()

#Funktion um den Code der Taste auszuwerten,
#hier können wir später mit einem Switch oder einer
#If-Bedienung auf die Tasten reagieren.
def decodeKeyValue(data):
    print(data)
    if data == 12: #Taste 1
        toggleLed(ledRed)
    elif data == 24: #Taste 2
        toggleLed(ledGreen)
    elif data == 94: #Taste 3
        toggleLed(ledBlue)
    elif data == 8: #Taste 4
        toggleLed(ledYellow)
    elif data == 69: #Taste POWER
        ledRed.value(0)
        ledGreen.value(0)
        ledBlue.value(0)
        ledYellow.value(0)

#Funktion zum umkehren eines zustandes am Pin
#aus einem aktiven Pin wird ein deaktiver
def toggleLed(pin):
    if not pin.value():
        pin.value(1)
    else: 
        pin.value(0)

#Funktion welche bei einem Tastendruck auf
#der IR-Fernbedienung ausgeführt werden soll.
def callback(data, addr, ctrl):
    #Wenn keine gültigen Daten empfangen wurden
    #dann soll nichts passieren.
    if data < 0:
        pass
    else:
        decodeKeyValue(data)

#Definieren das, dass IR-Modul am Pin 14 angeschlossen ist,
#zusätzlich wird noch ein Callback angegeben welcher aufgerufen wird,
#wenn eine Taste betätigt wird.
ir = NEC_16(pin_ir, callback)
#Im Fehlerfall soll die das Modul "print_error" angesteuert werden
ir.error_function(print_error)

#Try-Except Block
try:
    #starten einer leeren Endlosschleife
    while True:
        pass
#Wenn das Programm über Strg + C oder
#über die IDE abgebrochen wird, wird ebenso
#die Verbindung zum IR-Modul geschlossen.
except KeyboardInterrupt:
    ir.close()

Schreibe einen Kommentar

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