Infrarot-Fernbedienung mit dem ESP32 und MicroPython auslesen: Ein Anfängerleitfaden

In diesem kurzen Beitrag möchte ich dir zeigen, wie du eine Infrarot-Fernbedienung am ESP32 mit MicroPython auslesen kannst. Ich werde dich Schritt-für-Schritt mitnehmen und dir somit alles aufzeigen, was du benötigst, um später mit der Fernbedienung Aktoren wie LEDs, LED-Streifen, Motoren, Servos etc. zu steuern.

Programmieren einer Infrarot-Fernbedienung am ESP32 mit MicroPython

Dieses Video auf YouTube ansehen.

Inhaltsverzeichnis

• Benötigte Ressourcen für den Aufbau der Schaltung am ESP32
• Aufbau der Schaltung am ESP32
• Aufbau der Schaltung am AZ-Delivery ESP32 mit LEDs
• Vorbereitung des ESP32
• Programmieren in der Thonny IDE
  • Auslesen der IR-Fernbedienung
  • steuern von LEDs mit einer Infrarot-Fernbedienung am ESP32 mit MicroPython

Benötigte Ressourcen für den Aufbau der Schaltung am ESP32

Für unsere Schaltung benötigen wir:

• einen ESP32*,
• ein Micro-USB-Datenkabel*,
• ein Infrarot Funk Fernbedienung Set*

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!

Zum Testen der Fernbedienung verwende ich hier zusätzlich drei verschiedenfarbige LEDs inkl. Vorwiderstand.

Aufbau der Schaltung am ESP32

Das IR-Remote Modul K022 verfügt über drei Pins (GND, VCC, Signal), welche wie nachfolgend an den ESP32 angeschlossen werden.

Aufbau der Schaltung am AZ-Delivery ESP32 mit LEDs

In meinem Fall nutze ich den AZ-Delivery ESP32, welcher im Formfaktor des Arduino UNO daher kommt. Zusätzlich implementiere ich noch vier farbige LEDs, welche ich später einzeln schalten möchte.

Vorbereitung des ESP32

Wenn du wie ich den ESP32 für viele Experimente und Schaltungen verwendest, dann ist es ratsam, bevor man mit der Schaltung und vor allem Programmierung beginnt, ein leeres Programm auf den Mikrocontroller zu spielen.

Im Fall von MicroPython ist dieses recht einfach, denn wir können hier einfach eine leere PY-Datei mit der Thonny IDE hochladen.

Programmieren in der Thonny IDE

Das Programm erzeuge ich in der Thonny IDE welche du unter https://thonny.org/ für macOS, Windows und auch Linux kostenfrei herunterladen kannst.

Zum Auslesen der IR-Fernbedienung benötigen wir eine Bibliothek, diese kannst du dir vom GitHub Repository peterhinch / micropython_ir als ZIP-Datei herunterladen.

Wenn du die ZIP-Datei heruntergeladen und entpackt hast, dann musst du den Ordner „ir_rx“ in den Ordner lib auf dem ESP32 kopieren.

Auslesen der IR-Fernbedienung

Auf dem Markt gibt es diverse Sets mit ebenso verschiedenen IR-Fernbedienungen. In meinem Fall nutze ich eine kleine einfache Fernbedienung, welche wie nachfolgend aufgebaut ist.

Der MicroPython Code zum auslesen der IR-Fernbedienung:

#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(14, 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 von LEDs mit einer Infrarot-Fernbedienung am ESP32 mit MicroPython

Nachfolgend nun ein kleines Programm zum steuern von LEDs via IR-Fernbedienung am ESP32.

Du kannst statt LEDs auch andere Aktoren wie Servomotoren, Motoren (am Motorshield) ansteuern.

#Import der benötigten Module
from machine import Pin, freq
import machine
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

#LEDs 
ledRot = Pin(18, Pin.OUT)
ledGruen = Pin(12, Pin.OUT)
ledBlau = Pin(23, Pin.OUT)
ledGelb = Pin(19, Pin.OUT)

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

powerOn = False
ledRotOn = False

ledGruenOn = False
ledBlauOn = False
ledGelbOn = False

#Funktion zum aktivieren des Codes
#die LEDs gruen, blau und gelb
#lassen sich nur aktivieren wenn die
#rote LED leuchtet.
def togglePower():
    global powerOn, ledRot
    powerOn = not powerOn
    ledRot.value(powerOn)

#Funktion für die grüne LED
def toggleLEDGruen():
    #laden der globalen Felder
    global powerOn, ledGruen, ledGruenOn
    #prüfen ob das Feld powerOn WAHR / True ist
    if powerOn:
        #umkehren des Status der LED
        ledGruenOn = not ledGruenOn
        #zuweisen des neuen Status zum Pin
        ledGruen.value(ledGruenOn)

def toggleLEDBlau():
    global powerOn, ledBlau, ledBlauOn
    if powerOn:
        ledBlauOn = not ledBlauOn
        ledBlau.value(ledBlauOn)

def toggleLEDGelb():
    global powerOn, ledGelb, ledGelbOn
    if powerOn:
        ledGelbOn = not ledGelbOn
        ledGelb.value(ledGelbOn)

#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):
    global ledGruen, ledGruenOn, ledBlau, ledBlauOn, ledGelb, ledGelbOn
    if data == 69: #Taste POWER
        togglePower()
    elif data == 12: #Taste 1 - grüne LED
        toggleLEDGruen()
    elif data == 24: #Taste 2 - blaue LED
        toggleLEDBlau()
    elif data == 94: #Taste 3 - gelbe LED
        toggleLEDGelb()
    else: #alle anderen Tasten
        print("Taste nicht belegt!")

#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.
        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:
    #initial die LEDs deaktivieren
    ledRot.off()
    ledGruen.off()
    ledBlau.off()
    ledGelb.off()
    #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()