Welt-Spar-Tag

Inhaltsverzeichnis

Wer IoT-Geräte in freier Wildbahn, also an Orten ohne Steckdose, betreiben möchte, stößt bald auf ein Problem. Ohne entsprechende Vorkehrungen saugen Schaltungen mit Mikrocontrollern in kürzester Zeit Batterien oder Akkus leer. Um möglichst sparsam mit der verfügbaren Energie umzugehen, gibt es einige Möglichkeiten.

Tipps und Tricks

Dieses Posting entstand deshalb, weil ein Leserkommentar dazu angeregt hat. Allerdings gilt: Auch der Autor dieses Blogs hat die Weisheit nicht mit Löffeln gefressen. Daher betrachten Sie bitte die folgende Liste lediglich als unvollständige Sammlung. Ihre Tipps und Erfahrungen sind daher willkommen, um diese Liste auszubauen.

Das Problem

Bereits im Leerlauf mit dem BareMinimum-Beispiels-Sketch aus der Arduino IDE verbraucht ein Arduino Uno rund 15mA. Verwendet die Schaltung einen 9V-Block aus Zink-Kohle als Energiequelle, so hat die Batterie nach rund 22 Stunden das Ende ihrer Kapazität erreicht. Fügt jemand der Schaltung noch einen 220Ω Widerstand und eine LED hinzu, reduziert sich die ohnehin sehr geringe Laufzeit nochmals. Zusatzhardware wie ein Kohlenmonoxid-Gassensor oder eine Wetterstation könnte auch diese eingeschränkte Batterie-Lebensdauer verringern. Ganz zu schweigen von Situationen, in denen Kommunikationstechnologien wie WiFi, Bluetooth oder LoRa ins Spiel kommen. Gerade bei autark arbeitenden oder mobilen IoT-Geräten wiegt diese Herausforderung besonders schwer, weil die erwarteten Batterie-Kapazitäten oft für Tage, Monate oder sogar Jahre reichen müssen. Bei stationären Geräten mit Netzanschluss erwarten Nutzer mittlerweile einen energiesparenden Betrieb. Was nun, Herr und Frau Maker?

"Wer misst, misst Mist" - was nicht immer richtig ist

Vorweg möchte ich kurz auf das Thema Werkzeuge für Maker zu sprechen kommen. Ohne Diagnosewerkzeug lassen sich Schaltungsfehler oft nur schwer aufspüren.

Um dem Energieverbrauch auf dem Grund zu gehen, empfiehlt sich der Einsatz eines guten Multimeters. Damit können Maker gezielt überprüfen, an welchen Stellen welche Energieverbräuche entstehen. Es gibt hierfür recht preisgünstige Messtechnik (etwa das sehr gut bewertete Ragu 17B für 29,99 Euro), aber selbst für ernsthaftere Hobbyisten sei auf lange Sicht Qualitätshardware empfohlen. Diese messen genauer, reagieren schneller, und arbeiten zuverlässiger. Die Geräte von Fluke gehören sicher zum Nonplusultra, was Preis und Qualität betrifft, lassen sich aber schon in kleineren Varianten für unter 200 Euro erwerben. Etwa ein Fluke Multimeter 113 für um die 120 Euro oder ein 117 für unter 200 Euro.

Ein Multimeter ist selbstredend nicht nur sinnvoll, um den Energiekillern auf die Spur zu kommen, sondern auch für die Fehlersuche oder Diagnose bei Schaltungen.

Mehr Infos

DiY für Messtechnik

Der konsequente Maker baut sogar seine Messgeräte selbst, wobei hier natürlich die Geschichte von Huhn und Ei in den Sinn kommt.

• In seiner Instructable-Anleitung stellt Milen den Bau eines Arduino-Multimeter-Shields vor
• Das Design eines Strommessers findet sich zum Beispiel auf dieser Seite
• Mittels Sensor-Breakout-Boards auf Basis von ICs wie MAX471, INA219, ACS712 lassen sich Strommessungen in Schaltungen durchführen
• Auch Voltmeter, Ohmmeter und Arduino-Schaltungen zur Erfassung weiterer physikalischer Größen finden sich im Internet zuhauf
  

Natürlich gibt es einige andere Geräte, die in Zukunft noch im Blog zur Sprache kommen. (Logik-Analysatoren für die Diagnose digitaler Logik - etwa zur Buskommunikation mit SPI, I2C, PWM - hatte ich bereits in einem früheren Beitrag vorgestellt).

Zur Messung des Energieverbrauchs verwendet der Maker eine 9V-Blockbatterie oder eine andere Konfiguration. Zu diesem Zweck ist ein Multimeter (Amperemeter) mit der zu überprüfenden Elektronik in Serie zu schalten.

Suchen Sie den Punkt im Schaltkreis, an dem Sie die Stromstärke messen möchten. An diesem Punkt unterbrechen Sie den Schaltkreis und verbinden ein Ende mit dem COM-Port des Multimeters und das andere Ende mit dem mA/A-Port des Multimeters. Das Multimeter fungiert nun als Teil der Leitung, sodass der Stromkreis wieder geschlossen ist. Bei Spannungsmessungen schalten Sie hingegen das Multimeter parallel zum gemessenen Teil der Schaltung.

Insgesamt ergibt sich also folgendes Bild:

Die angezeigten mA-Werte zeigen den zu einem Zeitpunkt benötigten Energiebedarf der Schaltung. Die Spannung am Arduino-Board beträgt bekanntlich stets 5V (beziehungsweise 3.3V). Und die Leistung beträgt immer P = U * I = 5V * I.

Mit diesem Aufbau ist folglich die (Un-)Wirksamkeit der diversen Power-Save-Maßnahmen überprüfbar.

Übrigens lässt sich der Arduino mit Hilfe eines Spannungsteilers mit Widerständen sogar dazu verwenden, um seinen eigenen Stromverbrauch per Selbstreflektion zu ermitteln. Sie sind daran interessiert? Dann empfehle ich das entsprechende YouTube-Video von Matteo Corti.

MCU- und IC-Overkill vermeiden

Einen Arduino Mega oder einen Raspberry Pi einzusetzen, nur um regelmäßig einen schlichten Temperatursensor auszulesen, heißt mit Kanonen auf Spatzen schießen. Je leistungsfähiger der Mikrocontroller und je umfangreicher die auf dem Board verbauten Komponenten, desto höher der Verbrauch.

Schließlich konsumiert auch jeder nicht benötigte IC in einer Schaltung oder auf einem Mikrocontroller-Board Energie. Ein gutes Beispiel ist der UART-USB-TTL Adapter, der ständig rund 10 mA "verbrennt". Nur als Beispielsrechnung: Einen 9V-Block aus Alkali-Mangan mit 600 mAh würde allein der UART in maximal 60 Stunden völlig entleeren.

Arduino-MCUs wie Pro Mini besitzen keinen UART. Ihre Programmierung erfolgt über einen temporär angeschlossenen externen UART-USB-TTL-Adapter oder über eine Programmer-Hardware. Erwähnenswert an dieser Stelle ist, dass der Arduino Pro Mini im Prinzip ein um den UART-USB-TTL-Adapter abgespeckter Arduino Nano ist.

Zu den Stromfressern gehört des Weiteren die Power-on-LED, die mit rund 4 mA zu Buche schlägt. Eine drastische Massnahme besteht daher im Auslöten dieser LED beziehungsweise ihrem Aushebeln mittels Zange.

Auf der anderen Seite ver(sch)wenden lineare Spannungsregulatoren ebenfalls Energie und zwar abhängig davon, wie groß der Unterschied zwischen Eingangsspannung und Ausgangsspannung ist. Je höher dieser Wert, desto mehr Energie kommt durch Wärmeverluste abhanden. Die Formel hierfür lautet:

P = (Vout-Vin) * I.

Hier lässt sich entweder der Regulator ganz entfernen, und/oder ein effizienterer Regulator verwenden. Wer den Regulator entfernt, muss aber dafür sorgen, dass genau die notwendige Betriebsspannung (5V oder bei einigen Boards 3.3V) in V_in anliegt. Daher ist es zum Teil praktikabler, den internen Regulator zu deaktivieren und durch einen sparsamen, externen Regulator zu ersetzen. Experimentierfreudige Zeitgenossen haben hin und wieder den internen linearen Regulator auf dem Arduino-Board ausgelötet und durch einen effizienteren Regulator ersetzt. Es gibt zum Glück Arduino-Boards wie das Sparkfun Pro Mini, die das Deaktivieren des internen Regulators per Jumper erlauben.

Der Blogartikel empfiehlt zum Beispiel Regulatoren von Microchip wie MCP1700 und MCP1703, die es jeweils in Varianten für 3.3V und 5V zu kaufen gibt.

Richtigen Logik Level und richtige Frequenz wählen

Der Energieverbrauch steigt quadratisch mit der Spannung und linear mit der Frequenz. Kleinere Logik-Level reduzieren den Energieverbrauch, etwa Verwenden von 3.3V statt 5V. Zur Erinnerung, die Formel für die Leistung lautet

P = U2 / R.

Dann aber müssen Mikrocontroller wie der Atmel 328P herunter-getaktet werden. Laut Datenblatt verträgt der Prozessor bei 3.3V Versorgungsspannung keine 16MHz, weshalb Boards wie das Arduino Pro Mini im 3.3V-Betrieb unter 8 MHz laufen.

Der optimale Logik-Level hängt aber natürlich auch von den benützten Sensoren, Aktuatoren, Breakout-Boards oder Shields ab. Benötigen diese 5V, macht es eventuell nur wenig Sinn, mit einem 3.3V-Mikrocontroller-Board zu arbeiten. Und einige Bibliotheken könnten bei geänderter Taktfrequenz nicht oder nur eingeschränkt funktionieren.

Solarzellen

In Zeiten der Nachhaltigkeit kann das Thema alternative Energien natürlich nicht fehlen. Nur mit einer Solarzelle lässt sich eine Schaltung allerdings nicht betreiben, weil normalerweise tagsüber gerade einmal zwischen 10.00h und 14:00h optimale Sonneneinstrahlung herrscht. Die Solarzelle sollte also dazu dienen, NiMH-Akkus aufzuladen, von denen sich wiederum die Schaltung speist. Beispielsweise lässt sich ein 2 x 1.2V AA Doppel-Akkupack (gesamt 2.4V mit NiMh-Akkus) in Kombination mit einem Baustein (Voltage Booster, zum Beispiel XL6009) nutzen, der die Spannung auf die von den meisten Arduino-Boards benötigten 5V erhöht. Als Faustregel gilt: Die Spannung des Solarpanels muss ungefähr anderthalb (bis doppelt) so hoch sein. Im Falle eines Arduino Pro Mini mit 3.3V Spannung bietet sich ein >= 6V-Panel an. Beträgt die Kapazität der Akkus 1300mAh, sollte ihr Aufladen maximal mit einem Zehntel erfolgen (= 130 mA), aber mit 100 mA im Idealfall, sodass die Ladezeit rund 10-16 Stunden beträgt.

Mehr ist nicht immer besser: Je höher die Ladestrom, desto schneller zwar das Laden, aber auch desto geringer die Lebenszeit der Akkus. Empfehlenswert ist der Einsatz einer Diode (zum Beispiel Typ LN4148) zwischen positivem Terminal von Solarpanel und positivem Terminal des NiMh-Batteriepacks, wobei der positive Port des Batteriepacks mit der Plus-Seite der Diode verbunden ist, und das negative Ende der Diode mit dem positiven Potenzial des Batteriepacks. Negative Ports von Solarpanel und Batteriepack sind hingegen direkt verbunden. Für NiMh-Akkus gestaltet sich die Schaltung also recht pflegeleicht.

Wer stattdessen LiIon-Akkus wie ein 18650 nutzen möchte, hat ein bisschen mehr Aufwand, weil dafür ein LiIon-Ladecontroller benötigt wird, zum Beispiel ein TP4056. Das Überschreiten oder Unterschreiten gewisser Ladungsschwellwerte kann die Batterie zerstören, und nicht nur die.

Mehr Details zum Anschluss von Solarpanels liefert folgender guter Beitrag auf instructables.

Ewig schläft das Murmeltier

Schon aus den bisherigen Ausführungen ergibt sich die Schlussfolgerung, dass es Energieverbrauch für nicht benötigte Komponenten tunlichst zu vermeiden gilt. Dafür gibt es bei Embedded Controllern die Möglichkeit der Schlafmodi, d.h. die Komponenten laufen nur zu bestimmten Zeitpunkten. Ausserhalb dieser Zeitpunkte befinden sie sich in einem Schlafmodus, der weniger Energie benötigt. Nicht verwendete Komponenten wie ADC verbrauchen aber auch unter Umständen in einem Schlafmodus viel Strom, und lassen sich bei vielen Mikrocontrollern daher auch komplett abschalten.

Ein paar Worte speziell zu Arduino-Boards, bei denen die meisten einen ATMega328P oder einen ATMega168P beinhalten: Laut Datenblatt des ATMega328P (Kapitel 9) sind besonders folgende Komponenten Stromverbrauch-Kandidaten:

• Der ADC (Analog-Digital Converter) sollte generell oder vor dem Schlafmodus deaktiviert werden. ADCs verbrauchen sonst eine gehörige Portion Strom.
• Der Analog Comparator vergleicht positive Spannung an einem Pin mit der negativen Spannung an einem anderen Pin und setzt entsprechende Registerwerte oder kann einen Interrupt auslösen. Bis auf Idle-Mode und Noise-Reduction-Mode legt der Prozessor den Analog Comparator in allen Schlafmodi automatisch schlafen. In den vorgenannten beiden Modi empfiehlt es sich, falls möglich, den Baustein manuell zu deaktivieren.
• Der Brown-out-Detector (BoD) sorgt für ein Herunterfahren des Systems, sobald die Ist-Spannung die Soll-Spannung für einen bestimmten Zeitraum unterschreitet. Der BoD hat auch in diversen Schlafmodi großen Stromhunger, weshalb es eine gute Idee ist, ihn zu deaktivieren.
• Von der Internal-Voltage-Reference sind BoD, ADC, und Analog Comparator abhängig. Deaktiviert der Entwickler diese Bausteine, so bleibt auch die Internal-Voltage-Reference außer Betrieb
• Im Schlafmodus sollten die Port Pins ebenfalls nur minimale Energie verbrauchen. Gerade analoge Pins haben Umständen großen Appetit. Das lässt sich zum Beispiel bewerkstelligen, indem der Sketch alle nicht benötigten digitalen Pins im Set-up als Output-Pins deklariert und/oder Pull-Down-Widerstände aktiviert.
• Das On-Chip-Debug-System muss nur im Bedarfsfall aktiv sein, weil es im Betrieb substanziellen Energieverbrauch aufweist.

Der Watchdog Timer (WDT) hingegen darf im Normalfall nicht deaktiviert werden, auch wenn er einige wenige (Bruchteile von) mA verspeist. Ihn benötigt die MCU als externen Wecker, um den Schlafmodus aufzuheben. Allerdings lässt der WDT maximal 8 Sekunden (Tief-)Schlaf zu, weshalb er bei längeren Schlafzeiten mehrfach hintereinander zu nutzen ist.

Interrupts wie Interrupt 0 (Arduino-Port 2) oder Interrupt 1 (Arduino-Port 3) heben den Schlafmodus ebenfalls auf. Sie lassen sich durch externe Ereignisse triggern, etwa dem Betätigen eines an diesen Eingängen anliegenden Push-Buttons oder einer RTC-Uhr. Das macht Sinn, wenn das Gerät ohnehin nur bei bestimmten externen Ereignissen loslaufen sollte, etwa bei Benutzerinteraktion

Der ATMega328P besitzt einige Fuses und Register, die das Verhalten und den Energieverbrauch in den diversen Schlafmodi steuern. An dieser Stelle habe ich nicht genug Raum, um auf Fuses einzugehen. Jedenfalls ist bei Nutzung derselben zur Konfiguration des Prozessors Vorsicht die Mutter der Porzellankiste. Bei einem Fehler ist der Arduino sonst gegebenenfalls nicht mehr oder nur mit großem Aufwand in Betrieb zu nehmen.

Auch das Schreiben von Register-Bit-Manipulationen bei Registern und Inline-Assemblerinstruktionen zum Initialisieren der Schlafmodi gestaltet sich eher mühevoll und fehlerträchtig. Wer sich trotzdem dafür interessiert und dabei viel über Schlafmodi der AVR-Prozessorfamilie lernen will, sei auf das exzellente, englischsprachige YouTube-Video von Kevin Darrah verwiesen.

Rocket Scream LowPower Bibliothek

Statt sich mühsam und systemnah mit dem Sleep-Modi auseinanderzusetzen, empfiehlt sich die sehr gute Low-Power-Bibliothek von Rocket Scream. Sie macht auch das Verwenden der in der Arduino bereitgestellten sleep-API (sleep.h) überflüssig.

Die Bibliothek gibt es hier unter GitHub zum Download als ZIP-Datei. Nach dem Herunterladen fügen Sie über den Menü-Pfad Sketch > Include Library > Add .ZIP Library... die Bibliothek der Arduino IDE zu. In einem Sketch müssen Sie dann nur noch die Headerdatei LowPower.h inkludieren ...

... und die entsprechende Routine für den Tiefschlaf nutzen, die auch vom Typ des Mikrocontroller abhängt, wie Sie der Klassendefinition für LowPowerClass (siehe Headerdatei) entnehmen können. Beim Uno liegt ein ATMega328P vor, weshalb der nachfolgende Sketch folgenden Aufruf nutzt:

LowPower.idle(SLEEP_1S, ADC_OFF, TIMER2_OFF, TIMER1_OFF, TIMER0_OFF, 
              SPI_OFF, USART0_OFF, TWI_OFF); 

Die MCU wird für einen Zeitraum bis zu 8 Sekunden (Parameter SLEEP_xS) schlafen gelegt. Für eine Sekunde gibt es zum Beispiel SLEEP_1S. Währenddessen deaktiviert die Bibliothek ADC, Timer 0 bis 2, SPI-Bus, I2C-Bus (TWI), und den USART0 (serieller Ausgang 0).

Als Beispiel fungiert das Auslesen eines TMP36-Temperatursensors an einem Arduino Uno. Alle 8 Sekunden liest ein Sketch den aktuellen Sensorwert. Über den Einsatz dieses Sensors hatte ich bereits in einem vergangenen Beitrag geschrieben.

Gleichzeitig zeigen sowohl die eingebaute LED des Arduino-Boards als auch die am selben Pin liegende externe LED an, sobald die Messung erfolgt (LED an) und abgeschlossen ist (LED aus). Die LEDs dienen lediglich als zusätzliche Last.

Das Schaltungsdiagramm für das Experiment strukturiert sich wie der unteren Abbildung zu entnehmen ist. Der Sketch liest die Temperatur über den Analogport A0 aus, und steuert die LEDs am Digitalport 13 an, also sowohl die im Arduino-Board integrierte als auch die extra auf dem Breadboard hinzugefügte LED.

Sketch

Der Sketch zum Versuchsaufbau gestaltet sich sehr einfach und ist selbsterklärend. Interessant ist vor allem die Methode measure() mit den Aufrufen von LowPower.idle().

Die Ermittlung der Temperatur erfolgt ebenfalls in dieser Methode.

Durch Verstellen der boole'schen Variablen powerSave ist steuerbar, ob delay() oder der Tiefschlafmodus zum Einsatz kommt.

/******************************************************
 * 
 *    Auslesen eines TMP36 Temperatursensors
 *    
 * 
 *****************************************************/
 
#include "LowPower.h"  // Low-Power Bibliothek nutzen
bool powerSave = true; // Power-Save-Betrieb an oder aus

int  tmp36Pin = 0;   // TMP36 liegt am Analog-Port A0
int  extraLED = 13;  // Extra LED an Digitalport D13


void setup() {
  // Alle Pins als Ausgänge setzen:
  for (int  pin = 0; pin < 20; pin++)
    pinMode(pin, OUTPUT);
}

// Im Betrieb erfolgt eine kontinuierliche Messung:
void loop() {
  measure();
}

void measure() {
  // Extra LED an, weil Messung beginnt:
  digitalWrite(extraLED, HIGH); 
    
  // Wert am analogen tmp36Pin auslesen
  // und in Temperatur umrechnen:             
  int   whatIRead = analogRead(tmp36Pin);
  float voltage = whatIRead * 5.0 / 1024;
  float celsius = (voltage - 0.5)  * 100;

  // Statt delay() echter 1 Sekunden Tiefschlaf 
  if(powerSave)  
    LowPower.idle(SLEEP_1S, ADC_OFF, TIMER2_OFF, TIMER1_OFF, TIMER0_OFF, 
                  SPI_OFF, USART0_OFF, TWI_OFF); 
   else
     delay(1000);
   
  digitalWrite(extraLED, LOW); // Messung beendet
  
  // Statt delay() echter 8 Sekunden Tiefschlaf 
  if(powerSave)  
    LowPower.idle(SLEEP_8S, ADC_OFF, TIMER2_OFF, TIMER1_OFF, TIMER0_OFF, 
                  SPI_OFF, USART0_OFF, TWI_OFF); 
  else
    delay(8000);
}

Wem das zu aufwändig erscheint, kann auch einfach einen "leeren" Sketch (BareMinimum.ino) nutzen, und dort die Wirkung der Aufrufe von LowPower.idle() im Leerlauf untersuchen.

Arduino Pro Mini statt Arduino Nano

Wie bereits erwähnt, gibt es als Alternative zum Arduino Nano den Arduino Pro Mini, der rund ein Sechstel der Größe eines Arduino Uno aufweist, und über keinen USB-Adapter verfügt. Die Pro Minis gibt es in mehreren Varianten mit ATMega168P oder ATMega328P, sowie mit 3.3V bei 8MHz Taktfrequenz oder 5V bei 16MHz Taktfrequenz. Diese Arduino-Boards kamen ursprünglich von Sparkfun. Mittlerweile gibt es eine ganze Menge von geklonten chinesischen Pro Mini Boards zu Preisen von weit unter 2 Euro bei Alibaba.

Billigboards machen oft keine Angabe darüber, um welche Variante es sich handelt, im Gegensatz zum nachfolgend abgebildeten Board von Sparkfun (3.3V, 8MHz).

Um die bei Ihnen vorliegende Variante festzustellen, legen Sie am Raw-Eingang eine Spannungsquelle mit 5V an, zum Beispiel ein auf 5V gejumpertes FTDI-Board (oder einen anderen UART-USB-to-TTL-Adapter). GND des UART-USB-to-TTL-Adapters verbinden Sie mit einem GND-Pin des Pro Mini. Nun lesen Sie mit einem Multimeter die am VCC-Ausgang des Pro Mini anliegende Spannung aus. Sind es 3.3V, handelt es sich um einen Pro Mini mit 3.3V und 8MHz. Sind es hingegen 5V, liegt ein Pro Mini mit 5V und 16MHz vor.

Hier noch ein hilfreicher Überblick über die Pinbelegung eines Arduino Pro Mini.

Am besten, Sie nehmen einen FTDI-USB-TTL-Adapter und schließen daran den Pro Mini an, um ihn zu programmieren. Für den Betrieb können Sie dann eine Batterieversorgung statt des Adapters verwenden.

Arduino-kompatible Low-Power Boards

Wer auf Nummer sicher gehen möchte, greift gleich zu Arduino-kompatiblen Boards, die Hersteller auf niedrigen Energieverbrauch getrimmt haben.

Der Moteino von LowPowerLab verbraucht beim üblichen Blink-Sketch rund 8 mA. Daneben gibt es auch den Moteino Mega mit ähnlichem Energieverbrauch. Im kleinsten Energieverbrauchsmodus sind es nur um die 6.5 µA.

Der Mini Ultra 8 MHz von Rocket Scream verbraucht im extremen Low-Power-Modus nur rund 1.6 bis 1.7 µA. Die Pro-Variante bietet einen Anschluss für eine Lithium-Ionen-Batterie.

Arduino Raw Iron

Alternativ könnten Maker auch auf die Idee kommen, ihr eigenes Arduino-Board zusammenzuschustern, also eine Bare-Bone-Lösung. Wie das geht, hatte bereits mein Beitrag über einen Selbstbau-Arduino beschrieben. Einige der dort verwendeten Bauteile lassen sich dann gezielt durch weniger stromhungrige Varianten ersetzen oder ganz weglassen wie zum Beispiel die Onboard-LED.

ESP8266

Auch ESP8266-Boards wie NodeMCU und ESP32-Boards verfügen über die Möglichkeit des Tiefschlafs. Beispielsweise enthielt die Schaltung in der Folge über die Wetterstation mit dem Sensor BME680 einen ESP-01 für die Kommunikation über WiFi mit dem Dienst Thingspeak. Die ESP-MCUs verprassen reichlich Energie, auch wenn sie gerade nichts zu tun haben, weshalb der Maker die Controller schlafen legen sollte, sobald sie zur Untätigkeit verdammt sind. Dummerweise funktioniert beim ESP-01 das Schlafen legen weder über die Arduino-Core-Firmware noch über die dafür vorhandenen AT-Kommandos. Der Grund dafür ist, dass der externe RESET-Pin nicht mit dem XPD_DCDC-Pin (Deep Sleep Wake-up = GPIO16) verbunden ist.

Daher empfiehlt sich für diejenigen, die sich das Löten zutrauen, folgende Hardwaremodifikation (Hack). Man verbinde den RESET-Pin mit dem XPD_DCDC-Pin wie auf der folgenden Abbildung als blaue Linie illustriert.

Da ein ESP-01 nur Briefmarkengröße hat, muss das Löten sehr vorsichtig erfolgen. Dass der XPD_DCDC-Pin weit von der Antenne entfernt ist, erweist sich als Glück im Unglück.

Ist die Modifikation abgeschlossen, lässt sich der ESP-01 bei Firmwareprogrammierung oder im AT-Betriebsmodus zeitweise (bis etwa 71 Minuten) in den Tiefschlaf versetzen. Das entsprechende AT-Kommando lautet:

AT+GSLP=<Zeit in Millisekunden>

Wer noch mehr sparen will, kann auch beim ESP-01 wagemutig die Power-LED eliminieren (rote LED, ganz oben rechts neben der Antenne).

Fazit

Im Gegensatz zu stationären Embedded Geräten mit Netzanschluss sind autonom arbeitende oder mobile Geräte auf eine unabhängige Energieversorgung angewiesen. Bei naiver Hardware-/Software-Konfiguration und -Programmierung kommt spätestens dann keine Freude mehr auf, sobald alle paar Tage oder sogar schon alle paar Stunden die Batterien ersetzt werden müssen. Das lässt sich nur durch geschickte Wahl der Hardwarekomponenten und durch programmatische Massnahmen vermeiden, wodurch sich der Verbrauch von 25mA im idealen Fall auf unter 5µA reduzieren lässt. Wem auch das noch zu hoch erscheint, nutzt Arduino-kompatible Varianten wie Moteino oder Mini Ultra {Pro}, die speziell auf Low-Power-Operation getrimmt sind.

Alle beschriebenen Maßnahmen bestehen wie bei jeder Art von Energiesparen darin, den Verbrauch spürbar zu senken, und zusätzlich regenerative Energiequellen wie die Sonne zu nutzen.

Es genügt aber nicht, nur den verwendeten Mikrocontroller zu betrachten. Auch komplexere Sensoren wie ein BME680 oder Zusatzhardware wie zum Beispiel Kommunikationshardware (ESP-01) besitzen Sleep-Funktionalität, da sie sonst im Standby-Betrieb signifikant Strom ziehen würden. Der verbrauchssensitive Maker sollte daher stets die Datenblätter all seiner Hardwarekomponenten zur Hand haben.

Stromverbrauch ist übrigens eines der Gebiete, in denen sich in der Regel normale Softwareentwicklung von der Entwicklung von Embedded Systemen unterscheidet. Entwickler von Smart Phones, Watches und Tablets können ein Lied davon singen.

()