In diesem Tutorial lernst du, wie du einen ESP32 lite mit Batterien im Deep-Sleep-Modus betreibst, um Halloween-Lichter zu steuern. Und um es richtig cool zu machen, verwenden wir das, um einem Halloween-Schädel ein Paar rot glühende, gruselige Augen zu verleihen 😉
Im Rahmen dieses Projekts lernst du das Lolin32 lite Entwicklungsboard kennen, wie man mit Deep-Sleep den Batterieverbrauch reduziert und wie man einfache Lichteffekte mit LEDs erzeugt.
Lass uns Spaß haben.
Benötigte Teile
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Unten findest du die Komponenten, die für den Bau des Projekts benötigt werden. Für dieses Projekt verwende ich ein älteres ESP32-Board, das zwar veraltet ist, aber noch sehr günstig erhältlich ist. Genau das ist unten aufgeführt. Es gibt ein Nachfolgemodell mit verbesserten Spezifikationen, das du finden kannst here. Ich habe dieses selbst noch nicht ausprobiert, aber es sollte genauso funktionieren.
Außerdem ist der Schädel, den ich verwendet habe, anders als der unten aufgeführte. Ich finde, der unten sieht tatsächlich besser aus, ist aber etwas kleiner. Trotzdem passen Board und Batterie sehr gut hinein.
Schließlich haben alle 903052 LiPo-Batterien, die ich finden konnte, den falschen Anschluss. Daher die unten vorgeschlagenen! Du musst den Stecker abschneiden und durch einen 2,0 mm JST PH 2-poligen Stecker ersetzen. Ich mag das Format dieser Batterien, da sie fast die gleichen Abmessungen wie das ESP32-Board haben.
ESP32 lite
Dupont-Kabelset
Breadboard
USB-Datenkabel
Widerstands- & LED-Kit
1200mAh Batterie
Schädel
Arduino IDE
Anschließen der Teile
Wir wollen einen Halloween-Schädel mit einem Paar rot glühender Augen bauen. Für die Augen verwenden wir zwei rote LEDs. Außerdem sollen die Augen blinken oder einen anderen Effekt zeigen. Das bedeutet, wir brauchen einen Mikrocontroller.
Das Bild unten zeigt dir, wie du die Teile anschließt.
Wie du siehst, ist es sehr einfach. Wir verbinden den GND-Pin des ESP32-Boards mit einem blauen Kabel mit den Kathoden der beiden LEDs (das sind die kürzeren Pins). Die Anoden (die längeren Pins) der LEDs sind über einen 68Ω Widerstand (lila und grünes Kabel) mit den Pins 16 und 17 verbunden.
Es ist egal, welche LED du an welchen Pin am Board anschließt. Achte nur darauf, welche LED das rechte und welche das linke Auge sein soll.
Für die Programmierung und Stromversorgung verwenden wir vorerst den USB-Anschluss. Es muss also keine Batterie angeschlossen sein.
Software schreiben
In diesem Abschnitt zeige ich dir, wie du die Steuerungssoftware für die LEDs implementierst. Wir streben folgenden Effekt an:
- eine 5-Sekunden-Phase, in der die Augen/LEDs langsam dunkler werden mit einem zufälligen Flackern am Ende
- gefolgt von einer weiteren 5-Sekunden-Phase, in der die LEDs komplett ausgeschaltet sind.
Wir wollen den Eindruck erwecken, dass der Schädel plötzlich aufwacht, dich mit rot glühenden Augen anstarrt und dann langsam einschläft, bis er eine Weile schläft.
Wenn du ganz neu in der Arduino-Welt bist, schau dir vielleicht zuerst unser Tutorial How To Blink An LED Using Arduino an. Ansonsten wirf einfach einen kurzen Blick auf den Code unten. Ich erkläre die Details in den folgenden Abschnitten.
const int ledPin1 = 16;
const int ledPin2 = 17;
const int ts_ms = 10;
const int dozingoff_ms = 5000;
const uint64_t sleeping_ms = 5000;
void set_brightness(int brightness) {
analogWrite(ledPin1, brightness);
analogWrite(ledPin2, brightness);
}
int effect(int t) {
long flutter = random(0, 30);
int brightness = 255 * (dozingoff_ms - t) / dozingoff_ms;
return brightness < 150 ? brightness + flutter : brightness;
}
void dozingoff() {
for (int t = 0; t < dozingoff_ms / ts_ms; t++) {
delay(ts_ms);
int brightness = effect(t * ts_ms);
set_brightness(brightness);
}
}
void sleeping() {
esp_sleep_enable_timer_wakeup(sleeping_ms * 1000);
esp_deep_sleep_start();
}
void setup() {
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
}
void loop() {
dozingoff();
sleeping();
}
Konstanten
Wir beginnen mit der Definition einiger Konstanten. ledPin1 und ledPin2 sind natürlich die Pins, an denen die LEDs angeschlossen sind.
const int ledPin1 = 16; const int ledPin2 = 17; const int ts_ms = 10; const int dozingoff_ms = 5000; const uint64_t sleeping_ms = 5000;
Danach folgen einige Zeitkonstanten. Diese verwenden wir, um zu regeln, wie lange die Einschlaf- und Schlafphasen dauern. Die Zeiten sind in Millisekunden (ms), also sind 5000 ms 5 Sekunden.
Du kannst diese Konstanten nach Belieben ändern, um die beiden Phasen kürzer oder länger zu machen. Mach dozingoff_ms größer, wenn du ein langsameres Einschlafen möchtest. Und mach sleeping_ms größer, wenn du eine längere Schlafphase möchtest.
Wir sprechen später über den Zeitschritt ts_ms.
Hilfsfunktionen
Als nächstes implementieren wir einige nützliche Hilfsfunktionen, um den Code übersichtlich und lesbar zu halten. Wir verwenden die set_brightness() Funktion, um die Helligkeit der beiden LEDs einzustellen. Dabei erledigt analogWrite() die eigentliche Arbeit.
void set_brightness(int brightness) {
analogWrite(ledPin1, brightness);
analogWrite(ledPin2, brightness);
}
Beachte, dass wir einen Pin benötigen, der Pulsweitenmodulation (PWM) unterstützt, damit analogWrite() funktioniert. Für das hier verwendete ESP32-Board ist das kein Problem. Die Pins 16 und 17 sind PWM-Pins, ebenso fast alle anderen Pins auf dem Board. Schau dir das Pinout-Diagramm unter Pinout des ESP32-Boards an.
Der Parameter brightness ist ein Wert zwischen 0 und 255, wobei 255 maximale Helligkeit bedeutet.
Um den Einschlaf-Effekt zu erzeugen, implementieren wir eine Funktion namens effect(). Überraschung, Überraschung. Sie nimmt einen Zeitschritt t als Parameter und verringert über die Zeit die LED-Helligkeit von 255 auf 0. Um es interessanter zu machen, fügen wir etwa in der Mitte des Einschlafens ein zufälliges Flackern hinzu. Das vermittelt den Eindruck, dass der Schädel gegen den Schlaf kämpft mit flatternden Augenlidern. Ich weiß, Schädel haben keine Augenlider, trotzdem …
int effect(int t) {
long flutter = random(0, 30);
int brightness = 255 * (dozingoff_ms - t) / dozingoff_ms;
return brightness < 150 ? brightness + flutter : brightness;
}
Ich hoffe, das folgende Diagramm macht klar, wie das im Detail funktioniert.
Einschlaf-Funktion
Wir werden die effect() Funktion in der dozingoff() Funktion unten verwenden. Diese Funktion iteriert einfach über die Zeitschritte der Länge ts_ms, berechnet die Helligkeit über die effect() Funktion und stellt dann die Helligkeit der LED entsprechend ein.
void dozingoff() {
for (int t = 0; t < dozingoff_ms / ts_ms; t++) {
delay(ts_ms);
int brightness = effect(t * ts_ms);
set_brightness(brightness);
}
}
Du kannst die Länge der Zeitschritte ändern, was zu einem sanfteren oder gröberen Effekt führt. Ich habe 10 ms gewählt, was gut funktioniert. Du kannst Batterie sparen, indem du es länger machst, aber die Animation wird nicht so flüssig sein.
Schlaf-Funktion
Um den Kopf schlafen zu lassen, könnten wir einfach die Helligkeit der LEDs auf null setzen und dann die Dauer der Schlafphase abwarten. Der Code unten macht genau das.
void sleeping() {
set_brightness(0);
delay(sleeping_ms);
}
Allerdings würden wir wertvolle Batterieleistung verschwenden, da der Mikroprozessor während der Schlafphase weiterläuft, ohne etwas zu tun. Stattdessen versetzen wir den Mikroprozessor in den echten deep-sleep mode, wo er viel weniger Strom verbraucht. Der Code unten zeigt, wie das gemacht wird.
void sleeping() {
esp_sleep_enable_timer_wakeup(sleeping_ms * 1000);
esp_deep_sleep_start();
}
Zuerst legen wir fest, wie wir aufwachen wollen. Es gibt verschiedene Möglichkeiten, aber hier setzen wir einen Timer über esp_sleep_enable_timer_wakeup (). Dieser nimmt die Schlafzeit in Mikrosekunden. Deshalb müssen wir sleeping_ms mit 1000 multiplizieren.
Und in der zweiten Zeile starten wir einfach den Deep-Sleep-Modus durch Aufruf von esp_deep_sleep_start(). Beachte, dass das bedeutet, dass die setup- und loop-Funktion laufen, dann das Board einschläft, aufwacht und der Zyklus von vorne beginnt, beginnend mit der setup-Funktion.
Setup-Funktion
Unser Setup ist sehr einfach. Wir schalten nur die Pins, die die LEDs steuern, in den Ausgangsmodus. Fertig.
void setup() {
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
}
Loop-Funktion
Und dank unserer Hilfsfunktionen ist die loop-Funktion ebenfalls schön einfach. Wir schlafen ein, dann schlafen wir und das war’s.
void loop() {
dozingoff();
sleeping();
}
Beachte jedoch, dass die loop-Funktion nur einmal läuft, da wir beim Schlafen in den Deep-Sleep-Modus gehen und beim Aufwachen das Board neu starten.
Stromeinsparung
Wir wollen unseren gruseligen Schädel mit Batterien betreiben. Die offensichtliche Frage ist, wie lange er läuft und wie sehr der Deep-Sleep-Modus hilft.
Ich verwende eine 1200mAh LiPo-Batterie. Ich habe den Strom während der Einschlafphase (LEDs an) mit 50mA gemessen. Im Deep-Sleep verbraucht das Board nur 0,054mA und wenn ich delay() stattdessen verwende, steigt der Verbrauch auf 39mA . Jetzt machen wir die Rechnung.
Zuerst wandeln wir die Batteriekapazität in Coulomb um:
1200mA x 3600s = 4320000mC
Für die Einschlafphase, wenn das Board 5 Sekunden wach ist, verbrauchen wir
50mA x 5s = 250mC
Während der 5 Sekunden im Deep-Sleep-Modus verbrauchen wir jedoch nur
0,054mA x 5s = 0,27mC
Insgesamt verbrauchen wir 250mC + 0,27mC = 250,27mC alle 10 Sekunden.
Daher erhalten wir eine durchgehende Laufzeit von etwa
10s * 4320000mC / 250,27mC ≈ 17263s ≈ 48 Stunden = 2 Tage
Ohne Deep-Sleep-Modus halbiert sich diese Zeit. Wenn du die Laufzeit erhöhen möchtest, mach die Schlafphase länger (oder die Einschlafphase kürzer). Oder verwende natürlich eine größere Batterie.
Pinout des ESP32-Boards
In diesem Abschnitt möchte ich einige spezielle Aspekte des Lolin32 lite Boards hervorheben, das wir für dieses Projekt verwenden. Das Pinout findest du unten.
Dieses Board eignet sich besonders gut für batteriebetriebene Projekte, da es einen Batterieanschluss und eine Ladeelektronik mit maximal 500mA Ladestrom hat. Das bedeutet, du kannst eine LiPo-Batterie an das Board anschließen, das Board mit Batterie betreiben und über den USB-Anschluss laden. Sehr praktisch!
Außerdem sind die Deep-Sleep-Ströme ziemlich niedrig. Die Spezifikation sagt 125mA mit WiFi an und 45mA mit WiFi aus, was ich ungefähr auch gemessen habe.
Ohne angeschlossene Batterie und mit Stromversorgung über USB wirst du ein kontinuierliches Flackern der Lade-LED sehen. Das ist normal! Wenn du eine Batterie anschließt, hört das Flackern auf. Wenn die Batterie lädt, leuchtet die LED dauerhaft blau und schaltet sich aus, wenn sie voll geladen ist.
Beachte, dass das Board mit 3,3V Logikpegel arbeitet. Nicht alle Module, die du für Arduino bekommst, funktionieren daher unbedingt mit diesem Board, da Arduino mit 5V läuft.
Zum Schluss noch ein Warnhinweis. Der Batterieanschluss ist ein 2,0 mm JST PH 2-poliger Stecker. Aber die meisten Batterien mit diesem Stecker haben eine umgekehrte Polung! Schau genau auf die Markierungen des Boards. Im Bild oben ist der Plus-Pin auf der linken Seite. Achte darauf, dass das rote Kabel der Batterie mit dem Plus-Pin verbunden wird. Ich musste den Stecker an meiner Batterie abschneiden und umpolen.
Verdrahtung des Halloween-Schädels
Während das Breadboard ideal zum Testen der Schaltung ist, passt es nicht in den Schädel. Sobald du bestätigt hast, dass alles funktioniert, musst du die Kabel an das Board und die LEDs löten. So sieht meine Verdrahtung aus
Der Schädel, den ich gekauft habe, hatte keinen abnehmbaren Deckel. Also musste ich den Boden ausschneiden und zwei Löcher für die Augen bohren. Ich habe ihn auch neu lackiert und etwas gealtert. Aber ich bin sehr zufrieden mit dem Endergebnis.
Besonders nachdem alles schön verstaut ist:
Fazit
In diesem Artikel haben wir gezeigt, wie man Halloween-Lichter mit einem Lolin32 lite auf Batteriebetrieb steuert. Wir haben mit der Auflistung der benötigten Teile begonnen, darunter das LoLin32 Lite Board, das sich hervorragend für batteriebetriebene Projekte eignet. Dann haben wir den Prozess des Anschlusses der Teile und der Verdrahtung der LEDs für den Halloween-Schädel besprochen.
Anschließend haben wir die Software für den ESP32 geschrieben, die das Steuern der Lichter und den Deep-Sleep-Modus zur Schonung der Batterie ermöglicht. So können die Lichter über einen längeren Zeitraum betrieben werden, ohne ständig mit Strom versorgt zu werden.
Insgesamt bietet dieses Projekt eine spaßige und kreative Möglichkeit, deinen Halloween-Dekorationen eine gruselige Note zu verleihen. Mit dem ESP32 und ein paar einfachen Komponenten kannst du deine Halloween-Lichter leicht steuern und ein unvergessliches Erlebnis für Süßes-oder-Saures-Geher schaffen.
Natürlich könnte man noch viel mehr machen. Einen PIR-Bewegungssensor oder Radarsensor hinzufügen, um die Lichter nur einzuschalten, wenn eine Person erkannt wird. Oder ein Soundmodul und weitere Lichteffekte, oder die Steuerung des Schädels per Wi-Fi. Die Möglichkeiten sind endlos.
Wenn du Fragen hast oder auf Probleme stößt, während du an diesem Projekt arbeitest, schau bitte in den untenstehenden Abschnitt Häufig gestellte Fragen für weitere Hinweise.
Häufig gestellte Fragen
Hier sind einige häufig gestellte Fragen zur Steuerung von LEDs mit ESP32 auf Batterie:
F: Kann ich für dieses Projekt jedes ESP32-Board verwenden?
A: Ja, du kannst jedes ESP32-Board verwenden. In diesem Blogbeitrag verwenden wir jedoch speziell das LoLin32 Lite Board, da es sich leicht mit Batterie betreiben lässt.
F: Wie lange hält die Batterie?
A: Die Batterielaufzeit hängt von verschiedenen Faktoren ab, wie der Kapazität der Batterie, dem Stromverbrauch der Lichter und der Schlafdauer des ESP32. Es wird empfohlen, eine Batterie mit hoher Kapazität zu verwenden und den Code zu optimieren, um den Stromverbrauch zu minimieren und die Batterielaufzeit zu verlängern. Siehe die obigen Berechnungen.
Für fortgeschrittene Methoden zur Stromersparnis schau dir diesen hervorragenden Beitrag an: ESP32: Tips to increase battery life.
F: Kann ich andere Lichter statt des Halloween-Schädels verwenden?
A: Absolut! Du kannst jede Art von Lichtern verwenden, die du möchtest. Die Verdrahtung und der Code können je nach gewählten Lichtern variieren, aber das Grundkonzept bleibt gleich. Eine schöne Idee wäre, RGB-LEDs zu verwenden, um Farbeffekte zu erzielen.
F: Ist es möglich, mehrere Lichtsets mit einem ESP32 zu steuern?
A: Ja, es ist möglich, mehr Lichter mit einem ESP32 zu steuern. Du kannst mehrere Lichter parallel anschließen oder einen Multiplexer verwenden, um sie einzeln zu steuern. Beachte jedoch, dass der Stromverbrauch entsprechend steigt, was die Batterielaufzeit beeinflusst.
F: Kann ich den Code ändern, um mehr Funktionen hinzuzufügen?
A: Auf jeden Fall! Der im Blogbeitrag bereitgestellte Code ist ein einfaches Beispiel, um dir den Einstieg zu erleichtern. Du kannst ihn modifizieren und erweitern, um weitere Funktionen hinzuzufügen, wie verschiedene Lichtmuster, Fernsteuerung oder Integration mit anderen Smart-Home-Geräten.
F: Kann ich den ESP32 mit einem USB-Kabel statt mit einer Batterie betreiben?
A: Ja, du kannst den ESP32 mit einem USB-Kabel statt mit einer Batterie betreiben. Das Ziel dieses Projekts ist jedoch, es tragbar und kabellos mit einer Batterie zu machen. Wenn du eine kabelgebundene Lösung bevorzugst, kannst du den ESP32 über USB mit Strom versorgen.
Links
Einige nützliche Links mit zusätzlichen Informationen sind unten aufgeführt.
- Lolin32 classic vs Lolin32 lite
- ESP32: Tips to increase battery life
- Deep Sleep — Arduino-ESP32 2.0.6 documentation
- ESP32 External Wake Up from Deep Sleep
- In-Depth: ESP32 Deep Sleep & Wakeup Sources
- ESP32 WeMos LOLIN32 Lite high resolution pinout and specs
- ESP32 Power Consumption Comparison
