MicroPython mit ESP32: Helligkeitsregelung von LEDs mit PWM

In diesem Beitrag lernst du, wie du Pulsweitenmodulation (kurz PWM) mit dem ESP32 D1 R32 und MicroPython einsetzen kannst. PWM ist eine vielseitige Technik, die in vielen Anwendungen, von der LED-Dimmung bis zur Motorsteuerung, weit verbreitet ist. Mit dem ESP32 und MicroPython ist es einfach, PWM-Signale zu erzeugen und zu steuern.

MicroPython & ESP32 - Helligkeitsregelung von LEDs mit PWM

Dieses Video auf YouTube ansehen.

Wie du den Mikrocontroller für die Programmierung in MicroPython vorbereitest, habe ich dir bereits im Beitrag MicroPython mit ESP32: Einführung in den ESP32 D1 R32 gezeigt. Im letzten Beitrag MicroPython mit ESP32: GPIO-Pins steuern – LEDs und Taster hatte ich ebenso bereits gezeigt, wie du Taster und vor allem LEDs steuern kannst, jedoch fehlte dort noch der Abschnitt mit dem Dimmen von LEDs, was ich hier gerne nachholen möchte.

Inhaltsverzeichnis

• Was ist PWM?
• Erzeugen eines PWM Signals am ESP32 in MicroPython
  • Schritt 1 – import der benötigten Module
  • Schritt 2 – Initialisieren eines GPIO Pins
  • Schritt 3 – Konfigurieren des PWM Signals
  • Schritt 4 – setzen des PWM Wertes
  • Schritt 5 – deinitialisieren des GPIO Pins
• Programmieren eines Fade Effekts an einer LED
• Steuern der Helligkeit einer LED über Tasten
• Ausblick

Was ist PWM?

PWM steht für Pulsweitenmodulation. Das ist eine Methode, um analoge Geräte mit digitalen Signalen zu steuern. Dabei wird das Signal schnell ein- und ausgeschaltet, wobei die Dauer des Ein- und Ausschaltens verändert wird. Ein Beispiel ist die Steuerung der Helligkeit einer LED oder der Geschwindigkeit eines Motors.

Erzeugen eines PWM Signals am ESP32 in MicroPython

Schauen wir uns den Quellcode zum Erzeugen eines PWM Signals an einer LED etwas genauer an:

Schritt 1 – import der benötigten Module

Damit wir einen GPIO Pin ansteuern und später ein PWM Signal am ESP32 erzeugen können, benötigen wir die Module Pin & PWM aus machine. Das Modul sleep laden wir uns aus time, damit wir im Code eine kleine Pause einlegen können.

# Module zum steuern der GPIO-Pins
from machine import Pin, PWM
# Modul zum einlegen einer Pause im Code
from time import sleep

Schritt 2 – Initialisieren eines GPIO Pins

In meinem Fall möchte ich die rote LED1 am Rich Shield verwenden, welche am GPIO 17 angeschlossen ist, dieser Pin muss natürlich als Ausgang dienen.

# Initialisieren eines PWM Pins
led = PWM(Pin(17, Pin.OUT))

Schritt 3 – Konfigurieren des PWM Signals

Für eine LED reicht es aus die Frequenz auf 5 kHz zu setzen.

Das Setzen der PWM-Frequenz auf 5 kHz (Kilohertz) hat mehrere Gründe, die sich hauptsächlich auf die gewünschte Anwendung und die Eigenschaften der gesteuerten Geräte beziehen. Hier sind einige wichtige Punkte, die erklären, warum 5 kHz eine gute Wahl sein kann:

Vermeidung von Flimmern bei LEDs

Bei LEDs kann eine zu niedrige PWM-Frequenz Flimmern verursachen, das für das menschliche Auge sichtbar und störend sein kann. Eine Frequenz von 5 kHz liegt weit über der Wahrnehmungsgrenze des menschlichen Auges, wodurch das Flimmern effektiv vermieden wird.

Effizienz bei der Motorsteuerung

Bei der Steuerung von DC-Motoren kann eine höhere PWM-Frequenz zu einer ruhigeren und gleichmäßigeren Bewegung führen. Eine Frequenz von 5 kHz sorgt dafür, dass die Motoren effizienter und mit weniger Vibrationen arbeiten.

Allgemeine Kompatibilität

Eine Frequenz von 5 kHz ist für viele PWM-Anwendungen geeignet, sei es für LEDs, Motoren oder andere Geräte. Sie bietet eine gute Balance zwischen Leistung und Kompatibilität.

Vermeidung von Geräuschen

Bei manchen Anwendungen können niedrigere Frequenzen hörbare Geräusche erzeugen (z.B. Brummen bei Motoren oder Summen bei Lautsprechern). Eine Frequenz von 5 kHz liegt außerhalb des hörbaren Bereichs für die meisten Menschen, wodurch diese Geräusche vermieden werden.

# Frequenz auf 5 kHz setzen
led.freq(5000) 

Schritt 4 – setzen des PWM Wertes

Mit der Funktion duty am PWM Objekt setzen wir im Falle einer LED die Helligkeit. Wir können hier Werte zwischen 0 und 1023 eingeben.

# Helligkeit auf 1/4 setzen (0..1023)
led.duty(128)

Schritt 5 – deinitialisieren des GPIO Pins

Zum Schluss ergibt es größtenteils Sinn, die verwendeten Pins wieder zu deaktivieren, da sonst die angeschlossenen Aktoren (LEDs, Motoren etc.) weiterbetrieben werden. Im Falle einer LED würde die lediglich weiter leuchten.

# Pin deinitialisieren
led.deinit()

Programmieren eines Fade Effekts an einer LED

Im Nachfolgenden möchte ich dir nun zeigen, wie man einen Fade Effekt programmiert. Dieser Effekt lässt eine LED langsam auf-/ableuchten.

Für diesen Effekt an einer LED starten wir eine For-Schleife von 0 bis 1023 und nutzen den Index von dieser für die Helligkeit der LED. Wichtig ist auch hier die kleine Pause von 15 ms. damit wir den Effekt auch sehen können.

# Schleife von 0 bis 1023
for value in range(0,1024):
    # setzen des aktuellen Wertes
    # des Indexes aus der Schleife
    # als Helligkeitswert
    led.duty(value)
    # eine Pause von 15 ms.
    sleep(0.015)

Hier nun der komplette Code:

# Module zum steuern der GPIO-Pins
from machine import Pin, PWM
# Modul zum einlegen einer Pause im Code
from time import sleep

# Initialisieren eines PWM Pins
led = PWM(Pin(17, Pin.OUT))

# Frequenz auf 5 kHz setzen
led.freq(5000) 

# Schleife von 0 bis 1023
for value in range(0,1024):
    # setzen des aktuellen Wertes
    # des Indexes aus der Schleife
    # als Helligkeitswert
    led.duty(value)
    # eine Pause von 15 ms.
    sleep(0.015)

# Pin deinitialisieren
led.deinit()

Steuern der Helligkeit einer LED über Tasten

Am Rich Shield von Open Smart findest du auch zwei Tasten, mit welchen du die Helligkeit der LED steuern kannst. Da es jedoch eher mühsam wäre alle 1023 Schritte über Tasten zu betätigen, setze ich die Helligkeit in 100er-Schritte.

# Module zum steuern der GPIO-Pins
from machine import Pin, PWM
# Modul zum einlegen einer Pause im Code
from time import sleep

# anlegen der Variablen für die Taster
# Taster K1 am GPIO12
k1 = Pin(12, Pin.IN, Pin.PULL_UP)
#Taster K2 am GPIO13
k2 = Pin(13, Pin.IN, Pin.PULL_UP)

# Initialisieren eines PWM Pins
led = PWM(Pin(17, Pin.OUT))

# Frequenz auf 5 kHz setzen
led.freq(5000) 

# Variable zum zwischenspeichern
# des Wertes der Helligkeit
helligkeit = 0

# Funktion zum setzen der Helligkeit
def setLEDHelligkeit():
    # wird benötigt um einen Zugriff auf
    # die globale Variable zu erlangen
    global helligkeit
    # Ausgeben des Wertes auf der Kommandozeile
    print("Helligkeit:", helligkeit)
    # setzen der Helligkeit an der LED
    led.duty(helligkeit)
    
# Try/Catch Block
# dient zum Abfangen von Ausnahmen / Exceptions
try:
    # starten der Endlosschleife
    while True:
        # Wenn der Taster K1 betätigt wurde und
        # der Wert der Helligkeit kleiner 1000 ist, dann...
        if not k1.value() and helligkeit < 1000:
            # erhöhen der Helligkeit um den Wert 100
            helligkeit += 100
            # setzen der Helligkeit
            setLEDHelligkeit()
            # einlegen einer kleinen Pause von 300 ms.
            sleep(0.3)
    
        # Wenn der Taster K2 betätigt wird und der Wert größer 0 ist,
        # dann soll der Wert um 100 verringert werden.
        if not k2.value() and helligkeit > 0:
            helligkeit -= 100
            setLEDHelligkeit()
            sleep(0.3)

# Wenn das Programm über die Schaltfläche STOP, abgebrochen wurde,
# dann wird eine KeyboardInterrupt Exception geworfen.
# Diese Exception fangen wir ab und deaktivieren die LED.
except KeyboardInterrupt:
    led.deinit()

Ausblick

Im nächsten Beitrag werden wir uns den Drehpotentiometer anschauen und ich werde dir zeigen wie dieser ausgelesen werden kann und damit die LEDs gesteuert werden können.