- Bedarf
- Schaltplan des ESP32-Ruhemodus
- Übersicht über die Schlafmodi in ESP32
- Programmieren von ESP32 für den Tiefschlafmodus
- Testen von ESP32 im Tiefschlafmodus
ESP32 ist eines der beliebtesten Wi-Fi-basierten Mikrocontrollermodule und in vielen tragbaren IoT-Anwendungen eine beliebte Wahl. Es handelt sich um einen leistungsstarken Controller, der die Dual-Core-Programmierung unterstützt und über eine integrierte Bluetooth Low Energy (BLE) -Unterstützung verfügt. Dies macht ihn zu einer guten Wahl für tragbare Anwendungen wie iBeacon-Geräte, GPS-Tracker usw. Allerdings für batteriebetriebene Anwendungen wie diese Das Hauptanliegen ist die Sicherung der Batterie. Diese Batteriesicherung kann durch eine intelligentere Steuerung der Mikrocontrollereinheit erhöht werden, so wie man ESP32 im Ruhezustand im Idealzustand programmieren kann, um die Batteriesicherung des Geräts zu erhöhen.
In diesem Projekt werden wir den aktuellen Verbrauch der weit verbreiteten Wi-Fi- und Bluetooth-fähigen Mikrocontroller-Einheit ESP32 im normalen Arbeitsmodus und im Tiefschlafmodus überprüfen. Außerdem werden wir den Unterschied testen und prüfen, wie der ESP32 in den Tiefschlafmodus versetzt wird. Weitere Tipps, mit denen Sie Ihr Design wesentlich energieeffizienter gestalten können, finden Sie im Artikel zur Minimierung des Stromverbrauchs in Mikrocontrollern. Wenn Sie sich für den Schlafmodus anderer Mikrocontroller interessieren, können Sie auch den Arduino-Schlafmodus und den ESP8266 NodeMCU-Schlafmodus auswählen.
Bedarf
Zu diesem Zweck verwenden wir das ESP32-basierte Devkit V4.0 von Espressif mit USB-UART-Brücke sowie andere ESP32-Pinbelegungen für eine einfache Verbindung. Die Programmierung erfolgt mit Arduino IDE. Wenn Sie völlig neu sind, lesen Sie für den Einstieg in ESP32 mit Arduino den verlinkten Artikel, bevor Sie fortfahren.
Die Anforderungen dieses Projekts sind die folgenden:
- Auf Knopfdruck geht es in den Tiefschlafmodus.
- Durch Drücken einer anderen Taste wird der Tiefschlafmodus aktiviert.
- Um den Status des ESP32 zu erkennen, blinkt eine LED mit einer Einschaltzeit von 1000 Millisekunden. Während des Schlafmodus wird es ausgeschaltet.
Daher sind zusätzliche Komponenten erforderlich.
- LED - 1 Stck
- Druckknopf (Tastschalter) - 2 Stk
- 4,7k Widerstände - 2 Stk
- 680R Widerstand - 1 Stck
- Steckbrett
- Draht anschließen
- 5V Adapter oder Netzteil
- Ein Micro-USB-Kabel
- Arduino IDE mit ESP32-Programmierschnittstelle in einem PC oder Laptop.
Schaltplan des ESP32-Ruhemodus
Das Schema, in dem ESP32 mit einem Druckknopf in den Ruhezustand versetzt wird, ist unten dargestellt.
Der Schaltplan ist ziemlich einfach. Es hat zwei Tasten. Die Sleep-Taste versetzt den ESP32 in den Tiefschlafmodus und ein weiterer Schalter wird zum Aufwecken des ESP32 aus dem Ruhemodus verwendet. Beide Tasten sind in PIN 16 und PIN 33 verbunden. Beide Tasten sind beim Drücken als aktiv niedrig konfiguriert, daher wird ein zusätzliches Pull-up angegeben. Um jedoch festzustellen, ob sich der ESP 32 im Ruhemodus oder im normalen Betriebszustand befindet, ist die LED an den E / A-Pin 4 angeschlossen.
Übersicht über die Schlafmodi in ESP32
Es gibt viele verschiedene Energiemodi für ESP32, nämlich den aktiven Modus, den Modem-Schlafmodus, den leichten Schlafmodus, den Tiefschlafmodus und den Ruhezustand.
Während des normalen Arbeitszustands läuft der ESP32 im aktiven Modus. Im aktiven ESP32-Modus sind die CPU, die WiFi / BT-Hardware, der RTC-Speicher und die RTC-Peripheriegeräte sowie die ULP-Co-Prozessoren aktiviert und arbeiten je nach Arbeitslast. In verschiedenen Leistungsmodi sind jedoch eine oder mehrere Peripheriegeräte ausgeschaltet. Befolgen Sie die nachstehende Tabelle, um verschiedene Betriebsarten zu überprüfen.
|
Hardware |
Aktiver Modus |
Modem-Schlafmodus |
Leichter Schlafmodus |
Tiefschlafmodus |
Winterschlaf |
|
Zentralprozessor |
AUF |
AUF |
PAUSE |
AUS |
AUS |
|
WiFi / BT |
AUF |
AUS |
AUS |
AUS |
AUS |
|
RTC- und RTC-Peripheriegeräte |
AUF |
AUF |
AUF |
AUF |
AUS |
|
ULP-Co-Prozessor |
AUF |
AUF |
AUF |
AN AUS |
AUS |
Wie wir in der obigen Tabelle sehen können, sind im ESP32-Tiefschlafmodus, der häufig als ULP- Sensorüberwachungsmuster bezeichnet wird - CPU, WiFi / BT, RTC-Speicher und Peripheriegeräte, ULP-Co-Prozessoren alle ausgeschaltet. Nur der RTC-Speicher und die RTC-Peripheriegeräte sind eingeschaltet.
Während der Aufwecksituation muss der ESP32 von einer Aufweckquelle benachrichtigt werden, die den ESP32 aus dem Tiefschlafmodus aufweckt. Da jedoch die RTC-Peripheriegeräte eingeschaltet sind, kann der ESP32 über RTC-fähige GPIOs aktiviert werden. Es gibt auch andere Optionen. Es kann über externe Weck-Interrupt-Pins oder mit einem Timer zum Aufwecken des ESP32 aufgeweckt werden. In diesem Projekt verwenden wir ext0 wakeup an Pin 33.
Programmieren von ESP32 für den Tiefschlafmodus
Das vollständige Programm finden Sie unten auf dieser Seite. Es wurde für Arduino IDE geschrieben und kann daher leicht an Ihre Anforderungen angepasst werden. Die Erklärung des Codes lautet wie folgt.
Am Anfang des Codes, // Eine PushButton-Variable erstellen PushBnt pushBtn = {GPIO_NUM_16, 0, false}; // Led Pin definieren uint8_t led_pin = GPIO_NUM_4; // Wake-Up-Pin definieren uint8_t wakeUp_pin = GPIO_NUM_33;
Die obigen drei Zeilen definieren den Weck-Pin, den LED-Pin und den Schlafmodus-Pin.
void setup () { // Gib deinen Setup-Code hier ein, um ihn einmal auszuführen: // setze die serielle Schnittstelle auf 115200 Serial.begin (115200); Verzögerung (1000); // setze den PushButton Pin als Eingang mit internem PullUp PinMode (pushBtn.pin, INPUT_PULLUP); // setze den Interrupt-Handler mit dem pushButton-Pin in den Falling-Modus attachInterrupt (pushBtn.pin, isr_handle, FALLING); // setze den Led Pin als ouput pinMode (led_pin, OUTPUT); // Erstelle eine Aufgabe, die in der Funktion blinkLed () mit Priorität 1 ausgeführt und auf Kern 0 ausgeführt wird. xTaskCreate ( blinkLed, / * Aufgabenfunktion. * / "blinkLed", / * Name der Aufgabe. * / 1024 * 2, / * Stapelgröße der Aufgabe * / NULL, / * Parameter der Aufgabe * / 5, / * Priorität der Aufgabe * / & taskBlinkled); / * Aufgabenhandle, um die erstellte Aufgabe zu verfolgen * / delay (500); // Pin 33 als ext0-Weckquelle mit LOW-Logikpegel konfigurieren esp_sleep_enable_ext0_wakeup ((gpio_num_t) wakeUp_pin, 0); }}
Oben wird der Interrupt durch das Code-Snippet in einen fallenden Modus versetzt
attachInterrupt (pushBtn.pin, isr_handle, FALLING);
Daher wird bei jedem Drücken des Schalters der Logikpegel von logisch 1 (3,3 V) auf logisch 0 (0 V) geändert. Die Spannung des Tastenstifts fällt ab und der ESP32 erkennt, dass der Schalter gedrückt wurde. Es wurde auch eine Aufgabe erstellt, um die LED zu blinken.
xTaskCreate ( blinkLed, / * Task-Funktion. * / "blinkLed", / * Name der Task. * / 1024 * 2, / * Stapelgröße der Task * / NULL, / * Parameter der Task * / 5, / * Priorität der Aufgabe * / & taskBlinkled); / * Aufgabenhandle, um die erstellte Aufgabe zu verfolgen * / delay (500);
Der Pin 33 wird auch unter Verwendung des folgenden Codeausschnitts als externe Aufweckquelle konfiguriert, die als ext0 identifiziert wird.
esp_sleep_enable_ext0_wakeup ((gpio_num_t) wakeUp_pin, 0);
Als nächstes in der while-Schleife
void loop () { // Gib deinen Hauptcode hier ein, um ihn wiederholt auszuführen: if (pushBtn.pressed) { Serial.printf ("PushButton (% d) Pressed \ n", pushBtn.pin); Serial.printf ("Unterbrechen der 'blinkLed'-Task \ n"); // Unterhalte die blinkLed Task vTaskSuspend (taskBlinkled); digitalWrite (led_pin, LOW); Serial.printf ("Schlafen gehen….. \ n", pushBtn.pin); pushBtn.pressed = false; // Jetzt schlafen gehen esp_deep_sleep_start (); } esp_sleep_wakeup_cause_t wakeupReason; wakeupReason = esp_sleep_get_wakeup_cause (); switch (wakeupReason) { case ESP_SLEEP_WAKEUP_EXT0: Serial.println ("Verwenden des externen Signals ext0 für WakeUp From Sleep"); Unterbrechung; case ESP_SLEEP_WAKEUP_EXT1: Serial.println ("Verwenden des externen Signals ext1 für WakeUp From Sleep"); Unterbrechung; case ESP_SLEEP_WAKEUP_TIMER: Serial.println ("Timer-Signal für WakeUp From Sleep verwenden"); Unterbrechung; case ESP_SLEEP_WAKEUP_TOUCHPAD: Serial.println ("Verwenden des TouchPad-Signals für WakeUp From Sleep"); Unterbrechung; case ESP_SLEEP_WAKEUP_ULP: Serial.println ("Verwenden des ULP-Signals für WakeUp From Sleep"); Unterbrechung; Standard: break; Serial.printf ("Fortsetzen der 'blinkLed'-Aufgabe \ n"); // starte die blinkLed Task neu vTaskResume (taskBlinkled); } }
Die while-Schleife prüft ständig, ob die Sleep-Taste gedrückt ist oder nicht. Wenn die Taste gedrückt wird, wird die LED-Blinkaufgabe gestoppt oder angehalten und die esp Deep Sleep Start-Funktion ausgeführt.
esp_deep_sleep_start ();
Wenn in dieser Situation die externe Interrupt-Taste ext0 gedrückt wird, wird sie sofort aus dem Tiefschlafmodus geweckt und setzt die LED-Blinkaufgabe fort.
Zuletzt ist die LED-Blinkfunktion in den folgenden Ausschnitten zu sehen. Sie blinkt die LED 1000 ms Sekunden.
void blinkLed (void * param) { while (1) { static uint32_t pin_val = 0; // Pin-Wert umschalten pin_val ^ = 1; digitalWrite (led_pin, pin_val); Serial.printf ("Led -----------------% s \ n", pin_val? "On": "Off"); / * Schalten Sie die LED einfach alle 1000 ms oder 1 s um * / vTaskDelay (1000 / portTICK_PERIOD_MS); } taskBlinkled = NULL; vTaskDelete (NULL); }}
Testen von ESP32 im Tiefschlafmodus
Die Schaltung besteht aus einem Steckbrett und ein Multimeter der Metravi XB Edition wird zum Messen des Stroms verwendet. Der von der Schaltung im aktiven Modus aufgenommene Strom beträgt fast 58 mA, im Tiefschlafmodus jedoch fast 4,10 mA. Das folgende Bild zeigt die Stromaufnahme des aktiven ESP32-Modus -
Im Tiefschlafmodus ist der Stromverbrauch auf ca. 3,95 mA gesunken. Das folgende Bild zeigt den Stromverbrauch im Tiefschlafmodus des ESP32.
Im Tiefschlafmodus beträgt der Stromverbrauch des ESP32 jedoch fast 150 uA. Der aufgezeichnete Stromverbrauch für diese ESP32-Devkit-Karte beträgt jedoch fast 4,10 mA. Dies ist auf den CP2102 und den Linearregler zurückzuführen. Diese beiden sind an die 5V-Stromleitung angeschlossen. In der Stromleitung ist auch eine Power-LED angeschlossen, die fast 2 mA Strom verbraucht.
Daher kann leicht festgestellt werden, dass der ESP32 im Tiefschlafmodus eine sehr geringe Energiemenge verbraucht, was für batteriebetriebene Operationen sehr nützlich ist. Weitere Informationen zur Funktionsweise finden Sie im unten verlinkten Video. Wenn Sie Fragen haben, lassen Sie diese im Kommentarbereich unten oder nutzen Sie unsere Foren für andere technische Fragen.