ESP32-C3 Mini im Deep Sleep: So verlängerst du die Akkulaufzeit

/*
Autor: Stefan Draeger
Webseite: https://draeger-it.blog

Beschreibung:
Dieses Beispiel zeigt, wie ein ESP32-C3 in einem Intervall von 5 Sekunden aufwacht, eine LED aktiviert und dann wieder in den Tiefschlaf (Deep Sleep) geht.

Funktionsweise:
- Der ESP32 wacht alle 5 Sekunden auf.
- Er aktiviert eine LED für 250 Millisekunden.
- Anschließend wird die Anzahl der Boot-Zyklen gezählt und ausgegeben.
- Danach geht der ESP32 wieder in den Tiefschlaf.
*/

// Umrechnungsfaktor für Mikrosekunden zu Sekunden
#define uS_TO_S_FACTOR 1000000ULL  // 1 Sekunde = 1.000.000 Mikrosekunden
#define TIME_TO_SLEEP 5            // Zeitspanne des Tiefschlafs in Sekunden

// LED-Pin Definition
#define led 4  // Die LED ist mit GPIO4 verbunden

// Speichert die Anzahl der Boot-Zyklen im RTC-Speicher (bleibt beim Deep Sleep erhalten)
RTC_DATA_ATTR int bootCount = 0;

void setup() {
  Serial.begin(115200);  // Startet die serielle Kommunikation mit 115200 Baud
  delay(1000);           // Kurze Wartezeit zur Stabilisierung

  pinMode(led, OUTPUT);  // Setzt den LED-Pin als Ausgang

  // LED für 250 Millisekunden aktivieren
  digitalWrite(led, HIGH);
  delay(250);  // Kurze Verzögerung, um das Blinken sichtbar zu machen

  // Boot-Zähler erhöhen und ausgeben
  ++bootCount;
  Serial.println("Start: #" + String(bootCount));

  // Konfigurieren des Timers für den Tiefschlaf
  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
  Serial.println("Der ESP32 geht nun für " + String(TIME_TO_SLEEP) + " Sekunden schlafen!");

  Serial.println("Gute Nacht!");
  Serial.flush();  // Wartet darauf, dass die serielle Ausgabe abgeschlossen ist

  // Tiefschlafmodus aktivieren
  esp_deep_sleep_start();

  // Diese Zeile wird nie erreicht, da der ESP32 in den Tiefschlaf geht
  Serial.println("!!Diese Ausgabe wird nie erscheinen!!");
}

void loop() {
  // Die Loop-Funktion bleibt leer, da der ESP32 immer wieder in den Tiefschlaf geht.
}

/*
Autor: Stefan Draeger
Webseite: https://draeger-it.blog

Beschreibung:
Dieses Programm nutzt einen Taster, um den ESP32-C3 aus dem Deep Sleep zu wecken.  
Nach dem Aufwachen blinkt eine LED 10 Mal, während ein Indexwert über die serielle Schnittstelle ausgegeben wird.  
Danach geht der ESP32 wieder in den Tiefschlaf, bis der Taster erneut gedrückt wird.

Hardware:
- Der Taster ist an GPIO2 angeschlossen.
- Die LED ist an GPIO4 angeschlossen.
- Der ESP32 geht in den Tiefschlaf und wird durch den Taster wieder aktiviert.
*/

// Definition der verwendeten GPIO-Pins
#define LED 4          // LED ist mit GPIO4 verbunden
#define WAKEUP_PIN 2   // Taster ist mit GPIO2 verbunden

// Speichert die Anzahl der Boot-Zyklen im RTC-Speicher (bleibt nach dem Deep Sleep erhalten)
RTC_DATA_ATTR int bootCount = 0;

// Speichert den aktuellen Blink-Index im RTC-Speicher (bleibt nach dem Deep Sleep erhalten)
RTC_DATA_ATTR int blinkIndex = 0;

void setup() {
  Serial.begin(115200);  // Startet die serielle Kommunikation mit 115200 Baud
  delay(500);            // Kurze Wartezeit zur Stabilisierung

  pinMode(LED, OUTPUT);  // Setzt den LED-Pin als Ausgang

  // Die LED 10 Mal blinken lassen und den Index ausgeben
  for (int i = 1; i <= 10; i++) {
    digitalWrite(LED, HIGH);  // LED einschalten
    delay(250);               // 250 Millisekunden warten
    digitalWrite(LED, LOW);   // LED ausschalten
    delay(250);               // 250 Millisekunden warten
    blinkIndex++;             // Blink-Index erhöhen
    Serial.println("Index #" + String(blinkIndex));  // Blink-Index über die serielle Schnittstelle ausgeben
  }

  Serial.println("Gute Nacht!");  // Meldung vor dem Tiefschlaf
  Serial.printf("Um den ESP32-C3 wieder aufzuwecken, drücke den Taster am GPIO %d\n", WAKEUP_PIN);

  // Aktiviert das Wake-up per GPIO2 (Taster), wenn dieser auf LOW gezogen wird
  esp_deep_sleep_enable_gpio_wakeup(1 << WAKEUP_PIN, ESP_GPIO_WAKEUP_GPIO_LOW);

  // Startet den Tiefschlafmodus (ESP32 schaltet sich aus, bis er durch den Taster geweckt wird)
  esp_deep_sleep_start();
}

void loop() {
  // Die Loop-Funktion bleibt leer, da der ESP32 nach jedem Wake-up den Setup-Code erneut durchläuft.
}

/*
 * ESP32-C3 Mini - Deep Sleep mit DHT22 Sensor
 * -------------------------------------------
 * Dieses Programm liest beim Drücken eines Tasters die Temperatur- und Luftfeuchtigkeitswerte 
 * eines DHT22 Sensors aus, gibt diese auf der seriellen Schnittstelle aus und versetzt den 
 * ESP32-C3 Mini anschließend in den Deep Sleep Modus. 
 * Der Mikrocontroller wird durch das Drücken des Tasters am Wakeup-Pin wieder aufgeweckt.
 * 
 * Hardware:
 * - ESP32-C3 Mini
 * - DHT22 Sensor an GPIO 3
 * - LED an GPIO 4 (nur zur visuellen Bestätigung des Startvorgangs)
 * - Taster an GPIO 2 als Wakeup-Pin
 * 
 * Autor: Stefan Draeger
 */

#include <DHT.h> // Bibliothek für den DHT22 Sensor

// Definition der Pins
#define LED 4            // GPIO für die LED (visuelle Bestätigung)
#define WAKEUP_PIN 2     // GPIO für den Wakeup-Taster
#define DHT22_PIN 3      // GPIO für den DHT22 Sensor

#define DHTTYPE DHT22    // Sensortyp festlegen
DHT dht(DHT22_PIN, DHTTYPE); // DHT-Sensor-Objekt erstellen

void setup() {
  Serial.begin(115200); // Serielle Kommunikation starten
  delay(500);           // Kurze Verzögerung für den seriellen Monitor

  pinMode(LED, OUTPUT); // LED-Pin als Ausgang definieren

  // LED kurz aufleuchten lassen als Startbestätigung
  digitalWrite(LED, HIGH);
  delay(250);
  digitalWrite(LED, LOW);

  dht.begin();  // DHT22-Sensor initialisieren
  delay(500);   // Kurze Wartezeit für den Sensorstart

  // Temperatur auslesen und ausgeben
  float t = dht.readTemperature();
  Serial.println("Temperatur: " + String(t, 2) + "°C");

  // Luftfeuchtigkeit auslesen und ausgeben
  float h = dht.readHumidity();
  Serial.println("rel. Luftfeuchtigkeit: " + String(h, 2) + "%");

  Serial.println("Gute Nacht!"); // Hinweis, dass der ESP gleich schlafen geht
  Serial.printf("Um den ESP32-C3 wieder aufzuwecken, drücke den Taster am GPIO %d\n", WAKEUP_PIN);

  // GPIO-Wakeup aktivieren: ESP32 wacht auf, wenn der Taster gedrückt wird (LOW-Signal)
  esp_deep_sleep_enable_gpio_wakeup(1 << WAKEUP_PIN, ESP_GPIO_WAKEUP_GPIO_LOW);

  // ESP32 in den Deep Sleep Modus versetzen
  esp_deep_sleep_start();
}

void loop() {
  // Die Loop-Funktion bleibt leer, da der ESP32 nach jedem Wake-up den Setup-Code erneut durchläuft.
}

/*
 * ESP32-C3 Mini - Sensordaten an ThingSpeak senden & Deep Sleep
 * --------------------------------------------------------------
 * Dieses Programm liest beim Drücken eines Tasters die Temperatur- und Luftfeuchtigkeitswerte 
 * eines DHT22 Sensors aus, sendet diese an ThingSpeak und versetzt den ESP32-C3 Mini anschließend 
 * in den Deep Sleep Modus. Der Mikrocontroller wird durch das Drücken des Tasters am Wakeup-Pin 
 * wieder aufgeweckt.
 *
 * Hardware:
 * - ESP32-C3 Mini
 * - DHT22 Sensor an GPIO 3
 * - LED an GPIO 4 (nur zur visuellen Bestätigung des Startvorgangs)
 * - Taster an GPIO 2 als Wakeup-Pin
 *
 * ThingSpeak:
 * - WiFi-Verbindung wird hergestellt
 * - Sensordaten werden per HTTP GET an die API von ThingSpeak gesendet
 *
 * Autor: Stefan Draeger
 */

#include <DHT.h>        // Bibliothek für den DHT22 Sensor
#include <WiFi.h>       // WiFi-Bibliothek für ESP32
#include <WiFiMulti.h>  // WiFiMulti für einfaches Handling mehrerer Netzwerke
#include <HTTPClient.h> // HTTP-Client für die ThingSpeak API

// WLAN-Zugangsdaten
#define WIFI_SSID "abc"   // SSID deines WLANs
#define WIFI_PWD "123"    // Passwort deines WLANs

// Definition der Pins
#define LED 4            // GPIO für die LED (visuelle Bestätigung)
#define WAKEUP_PIN 2     // GPIO für den Wakeup-Taster
#define DHT22_PIN 3      // GPIO für den DHT22 Sensor

#define DHTTYPE DHT22    // Sensortyp festlegen
DHT dht(DHT22_PIN, DHTTYPE); // DHT-Sensor-Objekt erstellen

// ThingSpeak API-Konfiguration
String url = "https://api.thingspeak.com/update?api_key=P8P3GCWE9ZD9PZD0&";
String paramTemp = "field1=";
String paramHumidity = "field2=";

WiFiMulti wifiMulti; // WiFiMulti-Objekt zur Verwaltung der WLAN-Verbindung

void setup() {
  Serial.begin(115200); // Serielle Kommunikation starten
  delay(500);           // Kurze Verzögerung für den seriellen Monitor

  pinMode(LED, OUTPUT); // LED-Pin als Ausgang definieren

  // WLAN-Netzwerk hinzufügen
  wifiMulti.addAP(WIFI_SSID, WIFI_PWD);

  // Verbindung mit dem WLAN herstellen
  Serial.print("Verbinde mit WLAN");
  while (wifiMulti.run() != WL_CONNECTED) {
    Serial.print(".");
    delay(500);
  }
  Serial.println();
  Serial.println("WiFi verbunden");
  Serial.println("IP-Adresse: " + WiFi.localIP().toString());

  // Prüfen, ob die WLAN-Verbindung aktiv