Extended SoC-Badge: Hausakku-Füllstand auf einen Blick – mit erweiterter Funktionalität

Bastelecke > Arduino > Extended SoC-Badge

Erst vor ein paar Tagen hatte ich hier den SoC-Badge vorgestellt. Dabei handelt es sich um ein kleines praktisches Gadget, welches dir dabei hilft den Ladezustand deines Hausakkus im Blick zu behalten, ohne überall Handys und Tablets an die Wände tackern zu müssen.

Solltest du den Artikel verpasst haben, kannst du es hier nachholen:

• SoC-Badge: Hausakku-Füllstand auf einen Blick – für unter 5 € selbst gebaut

Jetzt gehe ich einen Schritt weiter und werfe direkt die Version 2.0 hinterher, den Extended SoC-Badge.

Grundfunktion und Beschreibung

Wie bereits sein Vorgänger, basiert auch der Extended SoC-Badge auf einem kleinen und preisgünstigen Wemos D1 mini Klon mit einem ESP8266 Chip. Dieser baut über W-LAN eine Verbindung zu einem MQTT-Broker auf und bekommt von da den Ladezustand in Prozent des Hausakkus übermittelt.

Auch hier ist die Art der Smarthome-Zentrale wieder relativ egal, solange MQTT zur Verfügung steht. Ich verwende es mit ioBroker, Node-RED oder HomeAssistant gehen aber auch.

Im Gegensatz zum Vorgänger, verwende ich jedoch einen ARGB-Strip mit einer LED-Dichte von 144 LEDs/m. Diesen gibt es preisgünstig als Meterware bei Amazon und lässt sich beliebig unterteilen.

Für meine Version, die ich hier vorstelle, verwende ich Abschnitte mit jeweils 10 LEDs. Dadurch entspricht jede LED exakt 10% Ladezustand. Die Länge ist jedoch frei skalierbar und wird im Firmware-Code, gleich zu Beginn, in einer Konstante festgelegt. Das Scaling passt sich dann dynamisch an.

Auch lässt sich jetzt die Helligkeit der LEDs bestimmen. Für diese einfache Schaltung empfiehlt es sich jedoch nicht über 30% zu gehen, da sonst die Energieversorgung über USB und Controller, bei 10 LEDs, nicht mehr möglich ist und eine 5V-Stromquelle, mit mehr Leistung als USB, erforderlich wäre.

Optional kann man nun auch die Farbe der Anzeige von der Smarthome-Zentrale steuern lassen. Auch lässt sich nun übermitteln ob der Akku gerade geladen wird. Dann fängt die nächsthöhere LED an zu blinken – so ist leicht zu erkennen in welche Richtung es gerade geht.

Das Gehäuse wurde stark angepasst. Es wirkt nun professioneller und modern. Angelehnt an das Design eines Lichtschalters, lässt es sich nun problemlos unauffällig an der Wand montieren. Optional gibt es dazu auch den passenden Tischaufsteller für die frei stehende Positionierung im Raum.

Hardware: Teileliste und Aufbau

Lasst uns also mit dem Aufbau beginnen:

Stückliste

Was zum Nachbau benötigt wird:

• 1 x Wemos D1 mini auf ESP8266 Basis
  (oder vergleichbarer günstiger Nachbau, z. B. AZ-Delivery D1 mini auf Amazon)
• LED-Strip auf Basis von WS2812B ARGB LEDs, 144 LEDs/m
• Verdrahtungsleitung 0,25mm² Litze (flexibel)

Werkzeug:

• Lötkolben und Lötzinn
• Seitenschneider
• 3D-Drucker (fürs Gehäuse)

Arbeitsaufwand:

Da hier weder Vorwiderstände erforderlich sind, noch eine Platine bestückt werden muss, ist der Arbeitsaufwand nun mehr als überschaubar. Es müssen lediglich die 3 Drähte durchs Gehäuse geschoben und beidseitig angelötet werden. Anschließend werden die Gehäuseteile mit ein wenig Druck zusammengepresst.

Am längsten braucht auch hier wieder der 3D-Drucker fürs Gehäuse mit ca. 5 Stunden.

Schaltplan und Platinenlayout

Das Schema ist extrem simpel. Es werden lediglich die 3 Kontakte am LED-Strip direkt mit dem D1 Mini verbunden:

LED-Strip

(+) --------------->  D1 mini Pin +5V

(D) --------------->  D1 mini Pin D2

(-) ---------------->  D1 mini Pin G

Seitlich, neben den LEDs, befinden sich kleine Pfeile aufgedruckt. Das ist die Richtung, in welche die LED adressiert und gezählt werden. Auch müssen die Kabel an den Kontaktflächen vor der ersten LED angelötet werden, da sonst das Datensignal die davor liegenden LEDs nicht erreicht.

Der LED-Strip selbst ist frei, nach jeder einzelnen LED, teilbar.

Es empfiehlt sich den LED-Strip nicht exakt auf der Trennlinie durchzuschneiden, sondern immer ganz knapp hinter der jeweiligen LED. Das hat den Vorteil das eine größere Lötfläche an Anfang des Streifens zur Verfügung steht und die Kabel besser halten. Auch habe ich den Ausschnitt in dem Gehäuse, welches ich hier wieder weiter unten zur Verfügung stellen werde, darauf angepasst das hinter der letzten LED kein Trägerstreifen mehr übersteht.

Firmware: Einrichtung mit der Arduino IDE

Nichts läuft hier ohne Programmcode. Also schreiben wir nun unser Programm auf den Controller:

Arduino-IDE vorbereiten

Damit du nicht zwischen den Artikeln springen musst, wiederhole ich das hier nochmal:

Solltest du noch keine Unterstützung für den ESP8266 installiert haben, gehe hierfür folgendermaßen vor:

Gehe auf Datei – Einstellungen.

Anschließend trage in die unterste Zeile (Zusätzliche Boardverwalter-URLs) folgendes ein:

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Nun gehe auf Werkzeuge – Boards – Boardverwaltung und suche dort nach ESP8266.

Das dort angezeigte Paket muss installiert werden.

Außerdem werden noch folgende Bibliotheken benötigt: PubSubClient + WifiManager

In den Bibliotheksverwalter gelangt man durch Klicken auf das dritte (mittlere) Symbol in der Toolleiste an der linken Fensterseite. Dort einfach nach den Bibliotheken suchen und installieren.

Der Programmcodes

Wir erstellen wieder einen neuen Sketch und wählen zunächst das richtige Board aus. Dieses geschieht wieder unter Werkzeuge – Boards, wo nun auch unser ESP8266 auftauchen sollte. In dieser Kategorie nun den richtigen D1 mini auswählen.

Anschließend kannst du diesen Code einfach in deinen Sketch kopieren:

#include <ESP8266WiFi.h>
#include <WiFiManager.h>
#include <PubSubClient.h>
#include <EEPROM.h>
#include <Adafruit_NeoPixel.h>

// ======== Konfiguration ========
#define RESET_COUNTER_ADDR 300
#define AUTO_RESET_FLAG_ADDR 301
#define RESET_THRESHOLD 5
#define RESET_CLEAR_DELAY 10000

#define LED_PIN D2
#define LED_COUNT 10
#define BRIGHTNESS_PERCENT 5

WiFiClient espClient;
PubSubClient client(espClient);
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

// ======== Globale Variablen ========
unsigned long resetStartTime;

char mqtt_server[40] = "192.168.1.10";
char mqtt_user[20] = "user";
char mqtt_pass[20] = "";
char mqtt_topic[50] = "akku/soc";
char mqtt_topic_color[50] = "akku/farbe";
char mqtt_topic_charging[50] = "akku/charging";
int mqtt_port = 1883;

bool shouldSaveConfig = false;
int soc = 0;
bool socReceived = false;
bool mqttConnected = false;
unsigned long lastSocUpdate = 0;
static unsigned long wifiDisconnectTime = 0;
const unsigned long SOC_TIMEOUT = 15000; // 15 Sekunden
bool blinkState = false;
int colorOverride = 0;
bool isCharging = false;
unsigned long knightRiderStart = 0;
unsigned long wifiDisconnectStart = 0;
bool knightRiderActive = false;
unsigned long knightRiderStartTime = 0;

// Farben
uint32_t COLOR_RED, COLOR_YELLOW, COLOR_GREEN, COLOR_OFF;

// ======== Hilfsfunktion für automatischen Reset ========
void doAutoRestart() {
  Serial.println("Automatischer Neustart...");
  EEPROM.write(AUTO_RESET_FLAG_ADDR, 1); // Flag setzen
  EEPROM.commit();
  delay(100);
  ESP.restart();
}

// ======== Angepasste Reset-Counter-Prüfung ========
void checkMultipleReset() {
  byte autoResetFlag = EEPROM.read(AUTO_RESET_FLAG_ADDR);

  if (autoResetFlag == 1) {
    Serial.println("Automatischer Reset erkannt, Zähler wird nicht erhöht.");
    EEPROM.write(AUTO_RESET_FLAG_ADDR, 0); // Flag zurücksetzen
    EEPROM.commit();
    resetStartTime = millis();
    return; // Kein Hochzählen
  }

  // Normaler Boot - Zähler erhöhen
  byte counter = EEPROM.read(RESET_COUNTER_ADDR);
  counter++;
  EEPROM.write(RESET_COUNTER_ADDR, counter);
  EEPROM.commit();

  resetStartTime = millis();

  Serial.print("Reset-Counter erhöht auf: ");
  Serial.println(counter);

  if (counter >= RESET_THRESHOLD) {
    Serial.println("Reset-Schwelle erreicht, WiFi-Einstellungen werden zurückgesetzt.");
    WiFiManager wm;
    wm.resetSettings();
    EEPROM.write(RESET_COUNTER_ADDR, 0);
    EEPROM.commit();
    delay(500);
    ESP.restart();
  }
}

void resetCounterResetTask() {
  if (millis() - resetStartTime > RESET_CLEAR_DELAY) {
    EEPROM.write(RESET_COUNTER_ADDR, 0);
    EEPROM.commit();
    resetStartTime = millis() + 99999999;
  }
}

// ======== Restlicher Code ========

void callback(char* topic, byte* payload, unsigned int length) {
  String t = String(topic);
  String value;
  for (unsigned int i = 0; i < length; i++) value += (char)payload[i];

  if (t == mqtt_topic) {
    soc = value.toInt();
    socReceived = true;
    lastSocUpdate = millis();
    updateLEDs();
  } else if (t == mqtt_topic_color) {
    colorOverride = value.toInt();
  } else if (t == mqtt_topic_charging) {
    isCharging = (value.toInt() == 1);
  }

  Serial.print("MQTT empfangen auf Topic: ");
  Serial.println(topic);
  Serial.print("Payload als String: ");
  Serial.println(value);
  Serial.print("SOC als Integer: ");
  Serial.println(soc);
}

void updateLEDs() {
  strip.clear();
  int ledsOn = map(soc, 0, 100, 0, LED_COUNT);
  uint32_t color = COLOR_GREEN;

  if (colorOverride == 1) color = COLOR_RED;
  else if (colorOverride == 2) color = COLOR_YELLOW;
  else if (colorOverride == 3) color = COLOR_GREEN;
  else {
    if (soc < 20) color = COLOR_RED;
    else if (soc < 40) color = COLOR_YELLOW;
    else color = COLOR_GREEN;
  }

  for (int i = 0; i < ledsOn; i++) {
    strip.setPixelColor(i, color);
  }

  if (isCharging) {
    bool phase = (millis() / 500) % 2;
    int blinkLed = (ledsOn < LED_COUNT) ? ledsOn : (LED_COUNT - 1);

    if (!phase) {
      strip.setPixelColor(blinkLed, COLOR_OFF);
    } else {
      strip.setPixelColor(blinkLed, color);
    }
  }

  strip.show();
}

void blinkErrorPattern() {
  bool phase = (millis() / 500) % 2;
  uint32_t c1 = phase ? COLOR_RED : COLOR_OFF;
  uint32_t c2 = phase ? COLOR_YELLOW : COLOR_OFF;

  for (int i = 0; i < LED_COUNT; i++) {
    strip.setPixelColor(i, i % 2 == 0 ? c1 : c2);
  }
  strip.show();
}

void knightRiderEffect() {
  static int pos = 0;
  static int dir = 1;
  static unsigned long lastUpdate = 0;
  const int delayMs = 50;

  if (millis() - lastUpdate < delayMs) return;
  lastUpdate = millis();

  strip.clear();

  float percent = (float)pos / (float)(LED_COUNT - 1);
  uint32_t color;

  if (percent < 0.2) {
    color = strip.Color(255, 0, 0);
  } else if (percent < 0.4) {
    color = strip.Color(255, 255, 0);
  } else {
    color = strip.Color(0, 255, 0);
  }

  strip.setPixelColor(pos, color);
  strip.show();

  pos += dir;
  if (pos <= 0) dir = 1;
  if (pos >= LED_COUNT - 1) dir = -1;

  client.loop();
}

void reconnect() {
  Serial.println("MQTT: Verbindung prüfen...");

  WiFiClient testClient;
  if (!testClient.connect(mqtt_server, mqtt_port)) {
    Serial.println("MQTT-Server nicht erreichbar → Automatischer Neustart");
    doAutoRestart();
  }
  testClient.stop();

  Serial.print("MQTT verbinden... ");
  String clientId = "ESP-" + String(ESP.getChipId());

  if (client.connect(clientId.c_str(), mqtt_user, mqtt_pass)) {
    Serial.println("erfolgreich");
    client.subscribe(mqtt_topic);
    client.subscribe(mqtt_topic_color);
    client.subscribe(mqtt_topic_charging);
    mqttConnected = true;
  } else {
    Serial.print("fehlgeschlagen, rc=");
    Serial.print(client.state());
    Serial.println(" → Automatischer Neustart");
    doAutoRestart();
  }
}

void saveConfigCallback() {
  shouldSaveConfig = true;
}

void setup() {
  Serial.begin(115200);
  EEPROM.begin(512);
  checkMultipleReset();

  strip.begin();
  strip.setBrightness((255 * BRIGHTNESS_PERCENT) / 100);
  strip.show();
  COLOR_RED = strip.Color(255, 0, 0);
  COLOR_YELLOW = strip.Color(255, 100, 0);
  COLOR_GREEN = strip.Color(0, 255, 0);
  COLOR_OFF = strip.Color(0, 0, 0);

  EEPROM.get(0, mqtt_server);
  EEPROM.get(40, mqtt_user);
  EEPROM.get(60, mqtt_pass);
  EEPROM.get(80, mqtt_topic);
  EEPROM.get(130, mqtt_port);
  EEPROM.get(140, mqtt_topic_color);
  EEPROM.get(190, mqtt_topic_charging);

  WiFiManager wm;
  wm.setSaveConfigCallback(saveConfigCallback);

  char mqtt_port_str[6];
  snprintf(mqtt_port_str, sizeof(mqtt_port_str), "%d", mqtt_port);

  WiFiManagerParameter p_server("server", "MQTT Server", mqtt_server, 40);
  WiFiManagerParameter p_user("user", "MQTT User", mqtt_user, 20);
  WiFiManagerParameter p_pass("pass", "MQTT Passwort", mqtt_pass, 20);
  WiFiManagerParameter p_topic("topic", "MQTT Topic SoC", mqtt_topic, 50);
  WiFiManagerParameter p_port("port", "MQTT Port", mqtt_port_str, 6);
  WiFiManagerParameter p_topic_color("topiccolor", "MQTT Topic Farbe", mqtt_topic_color, 50);
  WiFiManagerParameter p_topic_charge("topiccharge", "MQTT Topic Laden", mqtt_topic_charging, 50);

  wm.addParameter(&p_server);
  wm.addParameter(&p_user);
  wm.addParameter(&p_pass);
  wm.addParameter(&p_topic);
  wm.addParameter(&p_port);
  wm.addParameter(&p_topic_color);
  wm.addParameter(&p_topic_charge);
  wm.setConfigPortalTimeout(600);

  if (!wm.autoConnect("SoC-Light")) {
    Serial.println("Verbindung fehlgeschlagen. Neustart...");
    doAutoRestart();
  }

  strncpy(mqtt_server, p_server.getValue(), 40);
  strncpy(mqtt_user, p_user.getValue(), 20);
  strncpy(mqtt_pass, p_pass.getValue(), 20);
  strncpy(mqtt_topic, p_topic.getValue(), 50);
  strncpy(mqtt_topic_color, p_topic_color.getValue(), 50);
  strncpy(mqtt_topic_charging, p_topic_charge.getValue(), 50);
  mqtt_port = atoi(p_port.getValue());

  if (shouldSaveConfig) {
    EEPROM.put(0, mqtt_server);
    EEPROM.put(40, mqtt_user);
    EEPROM.put(60, mqtt_pass);
    EEPROM.put(80, mqtt_topic);
    EEPROM.put(130, mqtt_port);
    EEPROM.put(140, mqtt_topic_color);
    EEPROM.put(190, mqtt_topic_charging);
    EEPROM.commit();
  }

  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
  reconnect();
}

void loop() {
  // MQTT-Verbindung prüfen
  if (!client.connected()) {
    reconnect();
  } else {
    client.loop();
  }

  // WLAN-Verbindung prüfen
  if (WiFi.status() != WL_CONNECTED || WiFi.localIP().toString() == "0.0.0.0") {
    Serial.println("WLAN-Verbindung verloren oder keine gültige IP → Automatischer Neustart");
    doAutoRestart();
  }

  // Prüfen, ob SoC veraltet ist (älter als 15 Sekunden)
  bool socTimedOut = (millis() - lastSocUpdate > SOC_TIMEOUT);

  if (!socReceived || socTimedOut) {
    knightRiderEffect();

    if (knightRiderStartTime == 0) {
      knightRiderStartTime = millis();
    }

    if (millis() - knightRiderStartTime > 60000) {
      Serial.println("Timeout im KnightRider-Modus → Automatischer Neustart");
      doAutoRestart();
    }

    return;
  }

  // Wenn gültiger SoC → KnightRider-Zeit zurücksetzen und normale Anzeige zeigen
  knightRiderStartTime = 0;
  updateLEDs();
  resetCounterResetTask();
}

Klickst du nun auf Hochladen, wird das Programm Kompiliert und über Micro-USB an den Controller gesendet.

Sollte keine Übertragung möglich sein, kann es unter Umständen daran liegen, dass das falsche Gerät ausgewählt ist. Oben in der Titelzeile ist ein Dropdown-Feld, wo der Anschluss ausgewählt werden muss. Taucht dort dein Controller nicht auf, obwohl er angeschlossen ist, liegt das meist am verwendeten Micro-USB Kabel. Viele im Umlauf befindliche Kabel sind nur noch zum Laden von irgendwelchen Geräten ausgelegt und können keine Daten mehr übertragen. Dann einfach anderes Kabel verwenden und den richtigen COM-Port auswählen.

Wenn alles passt, steht unten rechts, in der Statuszeile die aktive Verbindung. Anderenfalls würde dort (nicht verbunden) stehen. Dann kann mit dem Hochladen fortgefahren werden.

Bedienung und Inbetriebnahme

Solange noch kein W-LAN verbunden ist, startet unser SoC-Badge nun in den WifiManager. Das heißt, es wird ein Accesspoint mit dem Namen SoC-Light auf gemacht, auf welchen wir uns nun mit dem Smartphone, Tablet, PC, oder was auch immer verbinden können. Im Browser rufen wir nun die Konfigurationsseite unter 192.168.4.1 auf, wo wir unsere W-LAN Verbindungsdaten, sowie den MQTT-Server eingeben. 

Das ausgewählte Topic für den SoC muss ein Zahlenwert zwischen 0 und 100 sein, welcher regelmäßig, alle paar Sekunden, aktualisiert wird. Daher sollten wir uns im ioBroker selbst einen Wert hierfür in den Objekten anlegen, welchen wir per Script alle paar Sekunden aktualisieren. Das ist wichtig, da der Badge spätestens alle 15 Sekunden einen neuen Wert erwartet. Sollte dieser Wert ausbleiben, glaubt er das etwas mit der Verbindung nicht stimmt und wechselt in eine Art Wartemodus, welchen er durch ein Lauflicht signalisiert. So erkennt man auf den ersten Blick ob die Verbindung steht und der angezeigte Wert noch aktuell ist.

Die beiden zusätzlichen Topics, für Farbe (Color) und Ladestatus (Charge), sind optional. Gültige Farbangaben sind:

• 1 = rot
• 2 = gelb
• 3 = grün

Bleibt dieses Feld leer, färbt sich die Anzeige je nach Ladezustand:

• 0 – 19% = rot
• 20 – 39% = gelb
• 40 – 100% = grün

Der Topic für den Ladestatus bewirkt das die nächsthöhere LED anfängt zu blinken, wenn dort eine 1 übermittelt wird. Mit 0 stoppt man das Blinken wieder.

Neu hinzugekommen sind nun auch diverse Fehlerbehandlungs- und Abfangroutinen. So wird regelmäßig überprüft ob die Verbindung zum MQTT-Broker, sowie auch die W-LAN Verbindung noch besteht. So wird sichergestellt, dass der Controller nicht einfriert.

Debugging: Fehlersuche leicht gemacht

Du hast deinen SoC-Badge fertig programmiert und eingerichtet, er zeigt aber trotzdem keine Werte an, und du weißt nicht woran es liegt? Kein Problem.

Solange er noch über USB am PC hängt, kannst du den seriellen Monitor verwenden. Gehe hierfür in der Arduino IDE auf Werkzeuge – Serieller Monitor und stelle diesen auf 115200 Baud ein. Jetzt kannst du die Statusmeldungen sehen, die der Controller ausgibt. Hier siehst du auch wo etwas hängt.

Hast du beim MQTT-Server etwas falsch eingegeben und möchtest die Werte korrigieren, musst du den Controller zurücksetzen um wieder in den Wifi Manager zu gelangen. Drücke hierfür 5 mal hintereinander, in Abständen von ca. 1 Sekunde, den Resetknopf am Controller. Alternativ kannst du auch 5 mal die Stromversorgung trennen. Er geht dann wieder in den Einrichtungsmodus, wo der Accesspoint aktiv ist. Einfach wieder per W-LAN verbinden und die Konfigurationsseite unter 192.168.4.1 aufrufen.

Das gleiche passiert auch, wenn er beim Start mit keinem W-LAN verbinden kann. Dann startet er auch automatisch in den Wifi-Manager, wo die Konfigurationsseite über den Accesspoint aktiv ist.

Gehäuse: 3D-Druck

Das Hauptaugenmerk des neuen Extended SoC-Badge ist sein modernes, schlichtes Gehäuse. Hier gibt es fast keine wirkliche Alternative zum 3D-Druck.

Die Komplette Projektdatei gibt es wieder auf Onshape unter:

https://cad.onshape.com/documents/56254221642274a25e4592fe/w/1ccd922144ba226c19e23fe8/e/62462bec3e4d6d74c82f4ade
(kostenloser Account erforderlich)

Die druckfertigen .STL-Files könnt ihr euch als ZIP-Paket hier herunter laden:

https://www.mykaefer.net/wp-content/uploads/2025/07/xSoC-Badge.zip

Ich empfehle den Druck mit PLA+ Filament. Das Gehäuse sollte in weiß, oder zumindest möglichst hell, gedruckt werden, damit die LEDs später gut hindurch scheinen können.

Beim Gehäuse erzielt man die besten Ergebnisse, wenn man es mit der Rückseite nach unten auf dem Druckbett positioniert. Für die Vertiefungen ist dabei eine Stützstruktur erforderlich. Ein Z-Abstand zwischen Stützstruktur und Gehäuse von 0,4mm hat sich als guter Kompromiss zwischen guter Ablösbarkeit und sauberem Druckbild herausgestellt. Eine Schichtdicke von 0,2mm ist vollkommen ausreichend für ein sauberes Ergebnis.

Der rückseitige Deckel kann ohne Stützstruktur gedruckt werden und wird mit der flachen Rückseite auf dem Druckbett positioniert.

Den Ständer kann man am besten stehend positionieren. Bei der Kabeldurchführung bekommt man mit einer Stütze ein saubereres Druckergebnis, es geht aber auch ohne.

Kein 3D-Drucker zur Hand, oder es fehlen noch Einzelteile? Hier gibt es den kompletten Bausatz, mit allem was du brauchst, zu kaufen:

Nutze den Gutscheincode Y7XQBDRTmkNET und erhalte 20% Rabatt auf deine erste Bestellung, sowie den Versand kostenlos!

Fazit

Wer bereits den ersten SoC-Badge nützlich fand, bekommt hier eine ausgereifte und professionelle Anzeige, für den Ladezustand des Heimspeichers geliefert.

Neben dem Ladezustand des Heimspeichers, lassen sich natürlich auch sämtliche anderen prozentualen Werte visualisieren, wie zum Beispiel:

• Öffnungsgrad Rollläden
• Füllstand Zisterne
• Ladeanzeige E-Auto
• usw…

Wer eine schlichte prozentuale Anzeige sucht, welche unauffällig über dem Lichtschalter an der Wand positioniert werden kann, der bekommt hier das ideale Bastelprojekt zur schnellen Umsetzung – das ganze offline, ohne Cloud und Anbieterzwang – quellcodeoffen, zur freien Anpassung.