Navigation

    makesmart

    • Registrieren
    • Anmelden
    • Suche
    • Aktuell
    • Tags
    • Kategorien
    • Ungelesen
    • Beobachtet
    • Beliebt
    • Gespeichert

    Tutorial: ESP8266 Deep-Sleep

    Tipps, Tricks & Tutorials
    deep sleep esp8266 tutorial
    2
    5
    173
    Lade mehr Beiträge
    • Älteste zuerst
    • Neuste zuerst
    • Meiste Stimmen
    Antworten
    • In einem neuen Thema antworten
    Anmelden zum Antworten
    Dieses Thema wurde gelöscht. Nur Nutzer mit entsprechenden Rechten können es sehen.
    • cooper
      cooper zuletzt editiert von cooper

      Es ist soweit! Die ersten Projekte mit dem ESP werden langsam langweilig… Als nächstes ist Deep-Sleep dran! Ich nämlich brauche ein möglichst stromsparenden Betrieb, da mein Projekt später mit einer Batterie laufen soll - und das möglichst lange.

      Der Betrieb mit einer Deep-Sleep-Funktion eignet sich dafür bestens.


      Was ist Deep-Sleep?

      Deep-Sleep ist ein Zustand des Boards, welches einen sehr geringen Stromverbraucht misst. Grund dafür ist, dass so gut wie alle Funktionen des Boards außer Betrieb sind.

      Besser gesagt: Alle Funktionen bis auf RTC.

      Hier mal eine Übersicht, welche Funktionen von Deep-Sleep betroffen sind:

      Funktion Zustand
      WLAN aus
      System clock aus
      CPU aus
      RTC an

      Laut verschiedenen Angaben im Netz beträgt der Stromverbrauch während dem Deep-Sleep zwischen 10 und 20 uA. Das entspricht 0,01 - 0,02 mA. Das ist der Wahnsinn!

      Ob 10uA oder 20 uA, … mit Deep-Sleep kann der ESP, je nach Aufgabe, monatelang mit einer einzigen Batterie betrieben werden.


      Wie wird der ESP wieder aufgeweckt?

      Zum Aufwecken des ESPs sind mir zwei Möglichkeiten bekannt:

      1. Aufwecken per Knopfdruck

      Eine Möglichkeit den ESP aus dem Schlaf zu holen, ist der Knopfdruck.

      Hierbei gibt es keine Zeitbeschränkung. Das Aufwecken per Knopfdruck könnte zum Beispiel für Fernbedienungen jeglicher Art verwendet werden.

      2. Automatisch nach Ablauf einer bestimmten Zeit

      Der ESP kann auch für eine bestimmte Zeit in den Deep-Sleep versetzt werden.

      Die maximal mögliche Dauer beträgt hierbei 71 Minuten. Diese Methode eignet sich unter anderem für Sensoren, die regelmäßig einen Wert liefern oder abfragen sollen.


      Tutorial

      1. Deep-Sleep mit Knopfdruck

      Um den ESP auf unbestimmte Zeit in den Deep-Sleep zu schicken, wird lediglich eine Zeile Code benötigt.

      ESP.deepSleep(0);
      

      In einem Programm könnte das so aussehen:

      void setup() {
        pinMode(LED_BUILTIN, OUTPUT);  
      }
      
      void loop() {
        digitalWrite(LED_BUILTIN, LOW);
        delay(5000);
      
        ESP.deepSleep(0);
      
      }
      

      Sobald der ESP mit Strom versorgt wird, leuchtet die blaue LED für 5 Sekunden.

      Nach Ablauf des delay(5000); schicken wir den ESP auf unbestimmte Dauer in den Deep-Sleep-Modus.


      Zum Aufwecken muss der Pin RST kurz mit GND verbunden werden.

      ESP8266-01S Pinout

      Sobald RST nicht mehr mit GND verbunden ist, startet der ESP und führt den gespeicherten Programmcode aus.

      Die Zeile ESP.deepSleep(); schickt den ESP anschließend wieder schlafen, bis wir ihn erneut aufwecken.

      Fertig ist der ESP, der auf Knopfdruck startet, das Programm ausführt, und danach wieder pennen geht. 👍


      2. Deep-Sleep mit Zeit

      Um den ESP auf bestimmte Zeit in den Deep-Sleep zu schicken, wird die selbe Zeile Code benötigt. Diesmal aber mit Zeitangabe. Die Angabe der Zeit erfolgt in uS.

      ESP.deepSleep(5000000);
      

      Diese Zeile schickt den ESP für 5 Sekunden in den Deep-Sleep. In der Funktion können auch mathematische Bezeichnungen verwendet werden. Folgende Zeile schickt den ESP ebenfalls für 5 Sekunden in den Deep-Sleep.

      ESP.deepSleep(5e6);
      
      void setup() {
        pinMode(LED_BUILTIN, OUTPUT);  
      }
      
      void loop() {
        digitalWrite(LED_BUILTIN, LOW);
        delay(5000);
      
        ESP.deepSleep(5e6);
      
      }
      

      Auch hier gilt: Der ESP führt das Programm aus, und wird anschließend in den Deep-Sleep geschickt. Diesmal aber nur für 5 Sekunden.

      Leider geht das Aufwecken nach den 5 Sekunden nicht ohne Weiteres …


      … damit sich der ESP nach Ablauf der 5 Sekunden selbst wecken kann, muss eine dauerhafte Verbindung zwischen RST und GPIO16 hergestellt werden.

      Erst diese Verbindung automatisiert den Vorgang des Weckens.

      … obacht - jetzt wird’s fummlig:

      Quelle: https://arduinodiy.wordpress.com/2020/01/18/very-deepsleep-and-energy-saving-on-esp8266/


      Sobald die Verbindung steht, haben wir einen ESP, der das gespeicherte Programm ausführt, und sich anschließend selbst in den Deep-Sleep Modus versetzt… bis er sich nach 5 Sekunden wieder weckt und das Programm erneut ausführt. …

      … endless Story bro. 👌

      Übrigens:

      Der ESP kann auch bei der letzteren Methode jederzeit durch die Verbindung von RST und GND manuell oder per Knopfdruck aufgeweckt werden.


      Wie lange hält die Batterie?

      Und jetzt die eigentlich wichtige Frage:

      Ich fänd ein Beispiel mit einer Batterie gut , also quasi eine Rechnung , wir lange das ganze halten würde.

      – @Nick

      Da ich nicht die Möglichkeit habe, den genauen Stromverbrauch zu ermitteln, und ich ungern bewusst mit Halbwissen um mich werfe… 🤣 hier mal eine Seite um den Wert für jegliche Konstellation theoretisch zu berechnen: Berechne mich 🐖


      Viel Spaß bei euren Projekten,

      cooper

      1 Antwort Letzte Antwort Antworten Zitieren 0
      • F
        frrrdy zuletzt editiert von

        Hallo @cooper,

        vielen Dank für das Tutorial!

        Ich habe versucht die “deepSleep”-Funktion bei meinem Homebridge-D1-Thermometer einzubauen - leider erfolglos.

        Hier der Code, den ich auf den D1 Mini übertagen habe:

        /*
            WLAN THERMOMETER GET-Request
            GET-Request an einen HTTP-Server
            Created by cooper, 2020
            makesmart.net
        */
        
        #include <ESP8266WiFi.h>
        #include <ESP8266HTTPClient.h>
        #include <OneWire.h>
        #include <DallasTemperature.h>
        #define ONE_WIRE_BUS 2
        
        OneWire oneWire(ONE_WIRE_BUS);
        DallasTemperature sensors(&oneWire);
        
        HTTPClient sender;
        
        // WLAN-Daten
        const char* ssid = "Mein WLAN";
        const char* password = "Meine WLAN-PW";
        
        //Messintervall in Sekunden
        int wait = 5;
        
        //Temperatur
        float temperature;
        
        void push(){
        
          //Hier wird der Wert an die Smarthome-Umgebung übertragen
          
          if (sender.begin("http://rpi-zero_w-ip:1837/?accessoryId=outside&value=" + String(temperature))){
        
            // HTTP-Code der Response speichern
            int httpCode = sender.GET();
           
            if (httpCode > 0) {
              
              // Anfrage wurde gesendet und Server hat geantwortet
              // Info: Der HTTP-Code für 'OK' ist 200
              if (httpCode == HTTP_CODE_OK) {
        
                // Hier wurden die Daten vom Server empfangen
        
                // String vom Webseiteninhalt speichern
                String payload = sender.getString();
        
                // Hier kann mit dem Wert weitergearbeitet werden
                 // ist aber nicht unbedingt notwendig
                Serial.println(payload);
                        
              }
              
            }else{
              // Falls HTTP-Error
              Serial.printf("HTTP-Error: ", sender.errorToString(httpCode).c_str());
            }
        
            // Wenn alles abgeschlossen ist, wird die Verbindung wieder beendet
            sender.end();
        
            //delay(30000);
            ESP.deepSleep(600000000);
            
          }else {
            Serial.printf("HTTP-Verbindung konnte nicht hergestellt werden!");
          }
        
        }
        
        void setup() {
          Serial.begin(115200);
          
          WiFi.begin(ssid, password);
        
          while (WiFi.status() != WL_CONNECTED) {
            delay(200);
            Serial.print(".");
          }
        
          Serial.println("Verbunden!");
          wait = wait * 1000;
          sensors.begin();
          
        }
        
        void loop() {
          
          sensors.requestTemperatures();
          Serial.print(sensors.getTempCByIndex(0));
          Serial.println(" °C");
          
          temperature = sensors.getTempCByIndex(0);
          push();
          //delay(wait);
        
        }
        

        Homebridge empfängt aber unregelmäßig (meistens im ca. 10min-Intervall) Werte. Wie kann ich das genau einstellen und kann ich irgendwie nachvollziehen, ob der D1 sich überhaupt mal im deepSleep-Modus befindet?

        Webhooks in Homebridge ist folgendermaßen konfiguriert:

                {
                    "webhook_port": "1837",
                    "cache_directory": "/var/homebridge/node-persist/",
                    "sensors": [
                        {
                            "id": "outside",
                            "name": "Temperature Draussen",
                            "type": "temperature"
                        }
                    ],
                    "platform": "HttpWebHooks"
                }
        

        Vielen Dank & viele Grüße,
        frrrdy

        cooper 1 Antwort Letzte Antwort Antworten Zitieren 0
        • cooper
          cooper @frrrdy zuletzt editiert von cooper

          @frrrdy sagte in Tutorial: ESP8266 Deep-Sleep:

          Homebridge empfängt aber unregelmäßig (meistens im ca. 10min-Intervall) Werte

          ESP.deepSleep(600000000);
          

          entspricht 600 Sekunden also ca. 10 Minuten. Das ist in Mikrosekunden angegeben. Leserlicher ist mit dieser Schreibweise:

          ESP.deepSleep(600e6);
          

          Das sind nämlich ebenfalls 600 Sekunden -> 10 Minuten.


          kann ich irgendwie nachvollziehen, ob der D1 sich überhaupt mal im deepSleep-Modus befindet?

          Klar! Im setup() einfach eine Ausgabe einfügen

          void setup() {
             Serial.println("Ich bin wach! Und wieder am Start!");
          }
          

          Und bevor er sich schlafen legt eine weitere Ausgabe

          // vor dem Sleep eine weitere Ausgabe
          Serial.println("Bin dann mal weg.");
          ESP.deepSleep(600000000);
          

          So weißt du okay, das Setup wird ausgeführt, also war der ESP im Deepsleep. 👍

          Steht aber eigentlich alles im Tutorial. 🙉

          F 1 Antwort Letzte Antwort Antworten Zitieren 0
          • F
            frrrdy @cooper zuletzt editiert von

            @cooper
            Ah, danke für die schnelle Antwort! Dann scheint es ja doch zu funktionieren!

            Ich bin leider ein ziemlicher Laie. Aber wie bekomme ich die Ausgabe des Arduino auf den Bildschirm? Per Seriellem Monitor? Hab da bisher nur Hieroglyphen dargestellt bekommen. Liegt das an der Baudrate?

            cooper 1 Antwort Letzte Antwort Antworten Zitieren 0
            • cooper
              cooper @frrrdy zuletzt editiert von

              @frrrdy

              Per Seriellem Monitor?
              Genau!

              Serial.begin(115200);

              Baudrate im seriellen Monitor muss gleich eingestellt sein: 115200.

              1 Antwort Letzte Antwort Antworten Zitieren 0
              • 1 / 1
              • First post
                Last post