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.
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
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.