MicroPython mit ESP32: GPIO-Pins steuern – LEDs und Taster

Nachdem ich dir gezeigt habe, wie du den ESP32 für MicroPython flasht und wie die Programmiersprache aufgebaut ist, wollen wir LEDs und Taster via GPIO-Pins steuern.

MicroPython & ESP32 - GPIO-Pins steuern – LEDs und Taster

Dieses Video auf YouTube ansehen.

Für diese Beitragsreihe verwende ich den ESP32 D1 R32 sowie das Rich Shield Two von Open Smart. Wenn du dieses nicht hast, so gebe ich dir trotzdem jeweils die Hinweise wie du die Schaltung auf einem Breadboard aufbauen kannst.

Sollten trotzdem Fragen offen bleiben, so kannst du mir gerne eine Mail an info@draeger-it.blog senden oder hier einen Kommentar hinterlassen.

Inhaltsverzeichnis

• LEDs am Rich Shield von Open Smart
  • Schaltung ohne Rich Shield
  • Steuern der GPIO-Pins der LEDs
  • LED blinken lassen
    • LED eine bestimmte Anzahl blinken lassen
    • LED eine bestimmte Zeit blinken lassen
    • LED dauerhaft blinken lassen
  • Lauflicht programmieren
• Taster auslesen
  • Schaltung ohne Rich Shield
  • Auslesen des Status der Taster
  • Aktivieren einer LED mit einem Taster
  • Aktivieren und Deaktivieren einer LED mit nur einem Taster (Toggeln)
• Fazit & Ausblick

LEDs am Rich Shield von Open Smart

Die LEDs am Rich Shield von Open Smart sind an nachfolgende Pins angeschlossen:

LED	ESP32 D1 R32	Arduino UNO R3
LED1 (rot)	IO17	D4
LED2 (grün)	IO16	D5
LED3 (blau)	IO27	D6
LED4 (gelb)	IO14	D7

Schaltung ohne Rich Shield

Hier nun die Schaltung, wenn du das Rich Shield von Open Smart nicht hast, aber trotzdem dieses Tutorial nachprogrammieren möchtest.

Steuern der GPIO-Pins der LEDs

Ein GPIO Pin kann als Eingang und Ausgang dienen. Eine LED dient zur Ausgabe (in diesem Fall Licht) und daher wird der Pin als Pin.OUT definiert. Hätten wir einen Taster, wäre dieses dann Pin.IN.

Damit wir im Code eine kleine Pause einlegen können, müssen wir das Modul time implementieren. Dieses Modul bietet viele Funktionen, eine davon ist time.sleep(<Sekunden>) wobei als Parameter hier die Sekunden eingegeben werden. (Anders als wie bei der Arduino IDE mit dem Befehl delay welcher Millisekunden erwartet.)

#Modul für den Zugriff auf die GPIO Pins
import machine
#Modul für den Zugriff auf Funktionen
#wie zum einlegen einer Pause im Code
import time

#anlegen einer Variable,
#GPIO17, als Ausgang
led1 = machine.Pin(17, machine.Pin.OUT)
led1.value(1) #aktivieren des Pins
time.sleep(1) #eine Pause von 1 Sekunde
led1.value(0) #deaktivieren des Pins

Wenn wir den Code ausführen, dann wird die LED1 (rot) für 1 Sekunde aktiviert und danach wieder deaktiviert. Anschließen beendet sich das Programm von selber.

LED blinken lassen

Im Beitrag MicroPython mit ESP32: Grundlagen der Programmierung habe ich dir die Schleifen vorgestellt. Mit einer Schleife können wir jetzt die LED blinken lassen. Dabei können wir entweder diese für eine Anzahl x, Zeit x oder dauerhaft blinken lassen.

LED eine bestimmte Anzahl blinken lassen

Um eine LED eine bestimmte Anzahl blinken zu lassen, müssen wir mit einer For-Schleife lediglich von / bis Zählen. Im unten stehenden Code zähle ich von 1 bis 5, wobei ich hier die Laufvariable i nicht verwende.

#Modul für den Zugriff auf die GPIO Pins
import machine
#Modul für den Zugriff auf Funktionen
#wie zum einlegen einer Pause im Code
import time

#Wert für die Pause in der Schleife
pause = 0.250

#anlegen einer Variable,
#GPIO17, als Ausgang
led1 = machine.Pin(17, machine.Pin.OUT)

#eine Schleife von 1 bis 5
for i in range(1,6):
    led1.value(1) #aktivieren des Pins
    time.sleep(pause) #eine Pause
    led1.value(0) #deaktivieren des Pins
    time.sleep(pause) #eine Pause

In dem Video siehst du das die kleine rote 5 mm LED insgesamt 5-mal aufblinkt. Wenn wir die Range in der For-Schleife auf range(1,11) anpassen würden, dann würde diese 10-mal blinken.

LED eine bestimmte Zeit blinken lassen

Wenn wir die LEDs eine bestimmte Zeit blinken lassen wollen, dann benötigen zum einen den aktuellen Zeitstempel und die Dauer. Hier hilft uns einfache Mathematik und eine While-Schleife weiter.

#Modul für den Zugriff auf die GPIO Pins
import machine
#Modul für den Zugriff auf Funktionen
#wie zum einlegen einer Pause im Code
import time

#Wert für die Pause in der Schleife
pause = 0.250

#anlegen einer Variable,
#GPIO17, als Ausgang
led1 = machine.Pin(17, machine.Pin.OUT)

#aktuelle Millisekunden, seitdem das Programm
#gestartet wurde
currentTimestamp = time.ticks_ms()
#die Dauer, wielange die LED blinken soll
duration = 5000

#LED eine Zeit blinken lassen
#Funktion ticks_ms() liefert bei jedem Aufruf,
#die aktuellen Millisekunden, seitdem das Programm
#gestartet wurde.
while (time.ticks_ms() < (currentTimestamp + duration)):
    led1.value(1) #aktivieren des Pins
    time.sleep(pause) #eine Pause
    led1.value(0) #deaktivieren des Pins
    time.sleep(pause) #eine Pause

In dem Video lasse ich die LED 2 Sekunden lang blinken, bei einer Pause von jeweils 0,25 Sekunden sind das dann 4x.

LED dauerhaft blinken lassen

Um die LED dauerhaft blinken zu lassen, müssen wir unsere While-Schleife lediglich in eine Endlosschleife umstellen und als Prüfung ein True übergeben.

#Modul für den Zugriff auf die GPIO Pins
import machine
#Modul für den Zugriff auf Funktionen
#wie zum einlegen einer Pause im Code
import time

#Wert für die Pause in der Schleife
pause = 0.250

#anlegen einer Variable,
#GPIO17, als Ausgang
led1 = machine.Pin(17, machine.Pin.OUT)

#aktuelle Millisekunden, seitdem das Programm
#gestartet wurde
currentTimestamp = time.ticks_ms()
#die Dauer, wielange die LED blinken soll
duration = 5000

#starten der Endlosschleife
while True:
    led1.value(1) #aktivieren des Pins
    time.sleep(pause) #eine Pause
    led1.value(0) #deaktivieren des Pins
    time.sleep(pause) #eine Pause

Lauflicht programmieren

Wenn wir nun die LEDs nacheinander aktivieren und wieder deaktivieren, dann können wir uns ein kleines Lauflicht erstellen.

Damit wir etwas weniger Schreibarbeit haben und auch der Code nicht zu lang wird, erzeuge ich mir zum setzen eines Status der LED eine zusätzliche Funktion.

#Modul für den Zugriff auf die GPIO Pins
import machine
#Modul für den Zugriff auf Funktionen
#wie zum einlegen einer Pause im Code
import time

#Wert für die Pause in der Schleife
pause = 0.130

#anlegen einer Variable,
#GPIO17, als Ausgang
led1 = machine.Pin(17, machine.Pin.OUT)
led2 = machine.Pin(16, machine.Pin.OUT)
led3 = machine.Pin(27, machine.Pin.OUT)
led4 = machine.Pin(14, machine.Pin.OUT)
    
#Funktion zum setzen eines Status der LEDs
def ledLightUp(led1Status, led2Status, led3Status, led4Status):
    led1.value(led1Status)
    led2.value(led2Status)
    led3.value(led3Status)
    led4.value(led4Status)
    time.sleep(pause) #einlegen einer Pause
    
#starten der Endlosschleife
while True:
    #aufrufen der Funktion ledLightUp
    #als Parameter wird der neue Status der LED übergben
    ledLightUp(1,0,0,0) #rote LED an
    ledLightUp(0,0,0,0) #alle LEDs aus
    ledLightUp(0,1,0,0) #grüne LED an
    ledLightUp(0,0,0,0) #alle LEDs aus
    ledLightUp(0,0,1,0) #blaue LED an
    ledLightUp(0,0,0,0) #alle LEDs aus
    ledLightUp(0,0,0,1) #gelbe LED an
    ledLightUp(0,0,0,0) #alle LEDs aus

Taster auslesen

Auf dem kleinen Shield finden wir noch zwei zusätzliche Taster, welche wir im Nachfolgenden nutzen möchten, um die LEDs zu aktivieren und auch verschiedene Programme starten möchten.

Taster	ESP32 D1 R32	Arduino UNO R3
K1	IO12	D8
K2	IO13	D9

Schaltung ohne Rich Shield

Hier die kleine Schaltung auf dem 400 Pin Breadboard.

Auslesen des Status der Taster

Für das Auslesen der Taster benötigen wir nun eine Endlosschleife, denn wenn wir unser Programm ohne starten würden, hätten wir keine Chance eine Tastaktion auszulesen / auszuwerten.

#Modul für den Zugriff auf die GPIO Pins
import machine
#Modul für den Zugriff auf Funktionen
#wie zum einlegen einer Pause im Code
import time

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

#Starten der Endlosschleife
while True:
    #Wenn der Wert von Value gleich 0 / False ist, dann..
    if not k1.value():
        #Ausgeben der Textzeile auf der Kommandozeile
        print("Taster K1 gedrückt!")
        #eine kleine Pause einlegen damit der Taster entprellt wird
        time.sleep(0.25)
        
    if not k2.value():
        print("Taster K2 gedrückt!")
        time.sleep(0.25)

Wenn wir einen der Taster betätigen, dann wird auf der Kommandozeile der Text „Taster Kn gedrückt!“ ausgegeben. Zusätzlich legen wir danach eine kleine Pause von 0,25 Sekunden ein, diese Pause wird benötigt, um den Taster zu entprellen.

Aktivieren einer LED mit einem Taster

Jetzt können wir mit dem Wissen aus dem Abschnitt der LED und dem kleinen Beispiel zum Taster nun die LEDs steuern.

#Modul für den Zugriff auf die GPIO Pins
import machine
#Modul für den Zugriff auf Funktionen
#wie zum einlegen einer Pause im Code
import time

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

#LED1 (rot)
led1 = machine.Pin(17, machine.Pin.OUT)

#Starten der Endlosschleife
while True:
    #Wenn der Taster K1 betätigt wird, dann
    #soll die rote LED1 aktiviert werden.
    if not k1.value():
        led1.value(1)
        time.sleep(0.25)
        
    #Wenn der Taster K1 betätigt wird, dann
    #soll die rote LED1 deaktiviert werden.
    if not k2.value():
        led1.value(0)
        time.sleep(0.25)

Wenn wir jetzt den Taster K1 betätigen, dann wird die LED1 (rot) aktiviert und beim Betätigen des Tasters K2 wieder deaktiviert.

Aktivieren und Deaktivieren einer LED mit nur einem Taster (Toggeln)

Wir können aber auch recht einfach mit nur einem Taster die LED aktivieren und auch deaktivieren, dazu prüfen wir den Status des Pins und wenn dieser aktiviert ist, dann deaktivieren wir diesen und umgekehrt.

#Modul für den Zugriff auf die GPIO Pins
import machine
#Modul für den Zugriff auf Funktionen
#wie zum einlegen einer Pause im Code
import time

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

#LED1 (rot)
led1 = machine.Pin(17, machine.Pin.OUT)
#LED2 (grün)
led2 = machine.Pin(16, machine.Pin.OUT)

#Starten der Endlosschleife
while True:
    #Wenn der Taster K1 betätigt wird, dann
    #soll die rote LED1 aktiviert werden.
    if not k1.value():
        #Wenn der aktuelle Status des Pins LOW / 0 ist, dann...
        if not led1.value():
            #Pin auf HIGH / 1 setzen
            led1.value(1)
        else: #Wenn der Pin jedoch auf HIGH / 1 ist, dann...
            #Pin auf LOW / 0 setzen
            led1.value(0)
            
        time.sleep(0.25) #eine kleine Pause von 250 Millisekunden
        
    #Taster K2 kann nun eine weitere LED steuern
    if not k2.value():
        #Wenn der aktuelle Status des Pins LOW / 0 ist, dann...
        if not led2.value():
            #Pin auf HIGH / 1 setzen
            led2.value(1)
        else: #Wenn der Pin jedoch auf HIGH / 1 ist, dann...
            #Pin auf LOW / 0 setzen
            led2.value(0)
            
        time.sleep(0.25) #eine kleine Pause von 250 Millisekunden
       

Wir können nun mit den beiden Tastern die beiden roten und grünen LEDs steuern.

Fazit & Ausblick

Damit möchte ich diesen kleinen Beitrag schließen, im nächsten Beitrag möchte ich zeigen wie du den analogen Drehpotentiometer auslesen und die Werte auf die LEDs mappen kannst.

Letzte Aktualisierung am: 23. Januar 2025