Wie du einen ESP8266 aus dem Deep Sleep mithilfe von einem Taster erwecken kannst, erfährst du in diesem Beitrag.

Ich habe dir bereits im Beitrag NodeMCU – Deep Sleep des ESP8266 gezeigt, wie du einen ESP8266 in den Deep Sleep versetzt und nach einer Zeit x dieser wieder selbständig erwacht und einen Text auf der seriellen Schnittstelle ausgibt.

Wozu der deep sleep?

Der deep sleep am Mikrocontroller lohnt sich, wenn du dein Projekt an einer Batterie betreiben möchtest. Aber auch wenn du Messwerte nur alle X Minuten, Stunden etc. benötigst, dann kann der deep sleep dir nützlich sein.
Wenn ein Mikrocontroller in den deep sleep versetzt wird, dann spart dieser Strom und auch wird dieser nicht unnötig betrieben, somit lebt der Baustein deutlich länger.

Benötigte Ressourcen

Für den Nachbau dieses Beitrages benötigst du:
- einen Microcontroller mit ESP8266 Chip*,
- USB Datenkabel
- einen Taster für die Printmontage*,
- einen 10 kOhm Widerstand*,
- ein 400 Pin Breadboard*,
- diverse Breadboardkabel*
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!

Aufbau der Schaltung

In diesem Beitrag verwende ich den Wemos D1 Mini V4 mit USB-Schnittstelle. Dieser Mikrocontroller verfügt über den “normalen” ESP8266 Chip jedoch über eine USB-Typ-C Schnittstelle.
Der Taster in dieser Schaltung wird mit dem Pin RST des Mikrocontrollers verbunden sowie per 10 kOhm PULL Up Widerstand mit 3.3V VCC. Der andere Pin des Tasters wird mit GND verbunden.

Schaltung - ESP8266, mit Taster

Programmieren - ESP8266 per Taster aus dem deep sleep erwecken

Der nachfolgende Code dient dazu, den Mikrocontroller per Tastendruck aus dem deep sleep zu erwecken. Die Codezeile in der Funktion loop wird nie erreicht, da der Mikrocontroller bereits in der Funktion setup wieder in den Tiefschlaf versetzt wird.
void setup() {
//beginn der seriellen Kommunikation mit 9600 baud
Serial.begin(9600);
//setzt den Timeout auf 2000 Millisekunden
Serial.setTimeout(2000);
//Warten darauf das die serielle Kommunikation aufgebaut wurde
while (!Serial) {}
//Ausgeben der Textzeilen auf der seriellen Schnittstelle
Serial.println(“Juhu, hier bin ich wieder!”);
//zusätzlich noch einmal die Millisekunden seit dem Start
Serial.print(“läuft seit ”);
Serial.println(millis());
//den Mikrocontroller in den deep sleep versetzen
ESP.deepSleep(0);
}
void loop() {
//diese Zeile wird nie erreicht!
Serial.println(“Hallo!”);
}

Read the full article

Wie du am neuen Raspberry Pi Pico 2 das Waveshare 1,3" TFT-LCD Display in MicroPython programmieren kannst. Du kannst dieses Display selbstverständlich auch mit dem Vorgängermodell und auch dem Pi Pico W programmieren, nur gerne möchte ich dir dieses heute am neuen Mikrocontroller der Raspberry Foundation präsentieren.
https://youtu.be/NkMuy3ViP7E
Disclaimer: Dieser Beitrag ist nicht gesponsert. Ich habe den Raspberry Pi Pico 2 und das Waveshare Display selbst gekauft, um meine Erfahrungen und Erkenntnisse mit euch zu teilen. Alle Meinungen und Empfehlungen in diesem Artikel basieren auf meinen persönlichen Eindrücken und Tests.
Für diesen Beitrag verwende ich den neuen Raspberry Pi Pico 2 welchen ich dir bereits im Beitrag Raspberry Pi Pico 2: Maximale Leistung bei unverändertem Layout vorgestellt habe, das Display ist jedoch auch voll kompatibel mit dem Vorgängermodell und natürlich dem RPi Pico mit WiFi

Bezug des Waveshare 1,3" TFT-LCD Display

Das mir vorliegende Modell habe ich für knapp 13€ auf ebay.de* gekauft. Du findest dieses jedoch auch auf aliexpress.com und anderen asiatischen Onlinemärkten.

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!

Aufbau des Displays

Das Modul verfügt neben dem 1,3" TFT-LCD noch über vier Taster (A, B, X, Y) sowie ein 4 Achsen Joystick mit einem Taster in der Mitte.

-
-
-
-
-
-
-
-
- Auf der offiziellen Seite

Read the full article

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.

https://youtu.be/DptfSzv8_Dk

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.

ESP32 D1 R32

ESP32 D1 R32 mit Rich Shield von Open Smart

ESP-WROOM-32 Chip auf dem ESP32 D1 R32

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

LEDs am Rich Shield von Open Smart

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

LEDESP32 D1 R32Arduino UNO R3LED1 (rot)IO17D4LED2 (grün)IO16D5LED3 (blau)IO27D6LED4 (gelb)IO14D7

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

TasterESP32 D1 R32Arduino UNO R3K1IO12D8K2IO13D9

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.

Read the full article