Heute nochmal ein Update bzw. eine vollständige Zusammenfassung zur Messung des Füllstands der Zisterne mittels Ultraschall. Ich habe den Sketch für den ESP8266 (den ich immer noch in Form eines NodeMCU betreibe) mal etwas aufgebohrt.

Zu den alten Artikeln geht es hier und hier.

Im folgenden werden alle notwendigen Schritte beschrieben um die Firmware auf den ESP8266 zu flashen und den Sensor in Betrieb zu nehmen.

Benötigte Hardware

Die benötigte Hardware besteht aus einem NodeMCU mit ESP8266 und einem HC-SR04 Ultraschallsensor. Die Beschaltung folgt weiter unten.

Dann noch ein mindestens vieradriges Kabel und ein Gehäuse zur Unterbringung des Ultraschallsensors in der Zisterne z.B. eine kleine Aufputzdose aus dem Baumarkt.

Firmware installieren

Zur Installation der Firmware auf dem ESP8266 muss zuerst die Arduino Software auf einem PC installiert werden. Diese ist für Linux, Windows und MAC unter https://www.arduino.cc/en/main/software verfügbar.

Um in der Arduino IDE den ESP8266 nutzen zu können, muss in den Einstellungen (Datei -> Voreinstellungen) in das Feld „Zusätzliche Boardverwalter URLs“ folgende URL eingetragen werden: http://arduino.esp8266.com/stable/package_esp8266com_index.json

Dann unter „Werkzeuge -> Board … -> Boardverwalter…“ nach „esp8266“ suchen und „esp8266 by ESP8266 Community“ installieren. Hiermit werden u.a. die Tools zum flashen der Firmware auf den ESP8266 installiert.

Herunterladen der aktuellsten Firmware für die Füllstandmessung der Zisterne www.bubux.de/heimautomatisierung/ota/zisterne_aktuell.bin.

Den NodeMCU mit dem Rechner verbinden. In der Arduino IDE unter „Werkzeuge -> Port“ den COM-Port des NodeMCU ermitteln. Das Flashen der Firmware funktioniert leider nicht direkt aus der Arduino IDE heraus. Hierfür muss die Kommandozeile bemüht werden:

Flashen des ESP8266 unter Windows

Unter Windows dazu die Kommandozeile öffnen (cmd.exe) und dort den folgenden Befehl eingeben:

%USERPROFILE%\AppData\Local\Arduino15\packages\esp8266\tools\esptool\0.4.8\esptool.exe -vv -cd nodemcu -cb 57600 -ca 0x00000 -cp COMXY -cf Pfad_zur_Firmwaredatei

Wichtig: Die Versionsnummer des esptool kann ggf. abweichen, das Device hinter -cp (COMxy) muss entsprechend angepasst werden sowie der Pfad zur Firmwaredatei muss entsprechend angepasst werden.

Flashen des ESP8266 unter Linux

Auf der Kommandozeile folgenden Befehl ausführen:

~/.arduino15/packages/esp8266/tools/esptool/0.4.9/esptool -vv -cd nodemcu -cb 57600 -ca 0x00000 -cp /dev/ttyxxxx -cf Pfad_zur_Firmwaredatei

Wichtig: Die Versionsnummer des esptool kann ggf. abweichen, das Device hinter -cp muss entsprechend angepasst werden sowie der Pfad zur Firmwaredatei muss entsprechend angepasst werden.

Anschluss des Sensors

Von HC-SR04 an NodeMCU:

Vcc an VU
Gnd an GND
Trig an D2
Echo an D1

Inbetriebnahme

Ist die Firmware auf den NodeMCU geflasht und der SR04-Ultraschallsensor angeschlossen, kann die Inbetriebnahme erfolgen. Dazu den Sensor mit Strom versorgen.

Der Sensor versucht sich mit einem konfigurierten WLAN zu verbinden. Funktioniert dies nicht (was bei der ersten Inbetriebnahme der Fall ist), erstellt der Sensor einen WLAN Accesspoint mit dem Namen „WLAN-Zisterne“ der z.B. im Smartphone gefunden werden sollte. Mit diesem WLAN verbinden.

Nun im Browser des verbundenen Gerätes die Adresse http://192.168.4.1 aufrufen. Diese Adresse wird in der Regel auch in den Verbindungseinstellungen des verbundenen WLAN angezeigt und verlinkt. Es öffnet sich nun die Konfigurationsseite des Sensors.

Dort die SSID und das Passwort des Heim-WLAN eingeben und auf „Konfiguration speichern“ klicken. Die weiteren Einstellungen können später erfolgen.

Der Sensor startet daraufhin neu und versucht sich mit dem Heim-WLAN zu verbinden. War dies erfolgreich ist der Accesspoint nicht mehr erreichbar und des Sensor sollte eine IP-Adresse im Netzwerk zugewiesen bekommen haben. Diese kann im Router nachgeschaut werden )in der Friztbox z.B. unter „Heimnetz -> Netzwerk„).

Ist der Accespoint „WLAN-Zisterne“ weiterhin sichbar, war die Verbindung mit den Heim-WLAN nicht erfolgreich. Dann die obigen Schritte erneut ausführen.

Betrieb

Die Oberfläche des Sensor ist nun im Browser nach Eingabe der IP-Adresse verfügbar. Für den weiteren Betrieb müssen zuerst weitere Einstellungen vorgenommen werden. Dazu den Bereich „Sonstiges“ aufklappen und auf „Konfiguration“ klicken.

Einstellungen des Sensors

Unter „Abstand Sensor/Boden“ muss der Abstand in Zentimeter zwischen Sensor und Boden der Zisterne angegeben werden. Unter „Abstand Sensor/Max. Höhe“ muss der Abstand zwischen Sensor und Wasseroberfläche bei maximalen Wasserstand angebenen werden. Ist die Zisterne nicht voll, kann der Wert auch jederzeit korrigiert werden

Daten an eigene API übergeben

Die Daten des Sensors können an eine eigene Schnittstelle übergeben werden. Hierzu kann ein Server, Port und der Pfad angegeben werden. Die Sensordaten werden als Argumente in der URL angehangen. So kann z.B. ein PHP-Script auf dem Server aufgerufen werden welches die angehangenen Argumente empfängt und weiter verarbeitet (z.B. an FHEM übergibt oder in eine Datenbank schreibt.

Update 20.07.2019

Die URL für die eigene API kann mit zwei Variablen frei definiert werden. Dazu die Variablen „_abstand“ und „_fuellstand“ in einer beliebigen URL nutzen. Im NodeMCU werden die beiden Platzhalter durch die echten Werte ersetzt.

Zum Beispiel wird aus der konfigurierten URL:
/umwelt/zisterne_neu.php?abstand=_abstand&fuellstand=_fuellstand
beim Aufruf der eigenen API dann:
/umwelt/zisterne_neu.php?abstand=29&fuellstand=100.00&vcc=2.75

Hier ein Beispielscript welches das Schreiben der Werte in eine Textdatei und in eine MySQL-Datenbank vornimmt sowie die Übergabe der Werte an eine FHEM-Installation:

<?php

$fuellstand=$_GET["fuellstand"];
$abstand=$_GET["abstand"];
$vcc=$_GET["vcc"];

//*************************
// Werte in Datei schreiben
//*************************
$datum = date("d.m.Y H:i");
$handle = fopen ('zisterne.txt', 'a');
fwrite ($handle, $datum.",".$fuellstand.",".$abstand."\n");
fclose ($handle);

//****************************
//Werte in Datenbank schreiben
//****************************
$servername = "localhost";
$username = "benutzer";
$password = "passwort";
$dbname = "dbname";

$connection = new mysqli($servername, $username, $password, $dbname);
if ($connection->connect_error) {
        die("Connection failed: " . $connection->connect_error);
}
$sql = "INSERT INTO zisterne (timestamp,fuellstand,spannung) VALUES (CURRENT_TIMESTAMP,$fuellstand,$vcc)";
if ($connection->query($sql) === TRUE) {
        //echo "INSERT war erfolgreich";
} else {
        echo "Error: " . $sql . "<br>" . $connection->error;
}

//***********************
//Werte an FHEM übergeben
//***********************
$fhemhost = "192.168.178.1";
$fhemport = 7072;
$fhemsock = fsockopen($fhemhost, $fhemport, $errno, $errstr, 30);
$fhemcmd = "set ZisterneFuellstand ".$fuellstand."\r\nquit\r\n";
fwrite($fhemsock, $fhemcmd);
fclose($fhemsock);

$fhemsock = fsockopen($fhemhost, $fhemport, $errno, $errstr, 30);
$fhemcmd = "set ZisterneSpannung ".$vcc."\r\nquit\r\n";
fwrite($fhemsock, $fhemcmd);
fclose($fhemsock);
?>

Daten an bubux.de übergeben

Steht kein eigener Server zur Historisierung der Daten zur Verfügung, können die gemessenen Werte an bubux.de gesendet werden. Dort ist (aktuell) eine Auswertung des letzten 30 Tage verfügbar und wird graphisch dargestellt. Nach der Aktivierung mittels der Checkbox ist ein entsprechender Link auf der Startseite des Sensors verfügbar.

Es werden der prozentuale Füllstand, die MAC-Adresse zur Zuordnung der Daten, die lokale IP des Sensors zur Verlinkung von der Webseite auf bubux.de zur Webseite des Sensors und die Version der Firmware übergeben.

Startseite des Sensors

Sind alle Einstellungen vorgenommen kann der Sensor genutzt werden. Auf der Startseite werden der prozentuale Füllstand und der aktuelle Abstand zwischen Sensor und Wasseroberfläche angezeigt.

Einbau

Da der Einbau je nach Zisterne individuell ist, will ich nicht viel Worte darüber verlieren. Nur soviel, das ich den Sensor in ein Baumarkt-Aufputzdose gepackt habe und mit Heißkleber „vergossen“ haben. Harz wäre wahrscheinlich besser gewesen, aber der Sensor funktioniert bisher einwandfrei. Der Sensor hängt nach unten an einem Brett in der Zisterne. Der NodeMCU ist an ein etwa 6m langes Kabel angeschlossen und ist in einem Lagerräumchen untergebracht.

Ich würde mich über Rückmeldungen (Fehler, Verbesserungswünsche, …) bzgl. der neuen Firmwareversion freuen. Todo wäre noch die Daten per JSON abrufbar zu machen und z.B. ein Plugin für FHEM zu bauen.

Viel Spaß beim basteln!

Chris

Die aktuelle Trockenheit zum Anlass genommen, habe ich den schon länger nicht mehr funktionierenden Füllstandsensor der Zisterne von Homematic gegen eine Eigenbaulösung ausgetauscht. Leider scheint der eigentlich recht teure Homematic-Sensor „Hm-Sen-Wa-Od“ den klimatischen Gegebenheiten in der Zisterne auf Dauer nicht gewachsen zu sein. Zudem hatte ich immer Empfangsprobleme bzw. war es auch extrem nervig das Ding zu eichen. Jedenfalls hat der Sensor an Undichtigkeit gelitten und hat seinen Dienst eingestellt.

Die Bilder zeigen die Platine, nachdem ich sie von Grünspan befreit hatte. Speziell das Funkmodul sieht etwas mitgenommen aus.

Da ich nicht nochmal soviel Geld zur Füllstandmessung der Zisterne ausgeben wollte, musste eine andere Lösung her.

Füllstandmessung mittels Ultraschall

Der neue Ansatz funktioniert mit einem Ultraschallsensor betrieben an einem NodeMCU mit ESP8266. Der Ultraschallsensor ist ein sehr kostengünstiger Sensor vom Typ HC-SR04 der im Dreierpack für unter 10€ zu bekommen ist. Der Sensor kann Distanzen von 2 –  300 cm messen. Das sollte für die meisten Zisternen ausreichend sein. Meine Zisterne hat etwa eine Höhe von 1,60 m zwischen Boden und dem Sensor. Die Versorgungsspannung des Sensors beträgt 5V. Das kommt dem Einsatz des NodeMCU entgegen, da er mit 5V betrieben wird und die für den „integrierten“ ESP8266 benötigten 3V selbst herstellt. Man spart sich somit eine separate Spannungsversorgung für den Sensor, wenn man einen „richtigen“ ESP8266 nutzen würde.

Ich verfolge bei der Füllstandmessung bezüglich der Software den gleichen Ansatz wie beim Windmesser. Der NodeMCU misst mittels des HC-SR04 den Abstand zu Wasseroberfläche und „übergibt“ das Messergebnis an ein PHP-Script. Das Intervall kann mittels sleepTimeS eingestellt werden. Im unten stehenden Sketch ist es Beispielhaft auf 10 Minuten eingestellt. In der anderen Zeit befindet sich der ESP im „Deep Sleep“. Das PHP-Script wiederum macht die eigentliche Verarbeitung der Daten. Im Beispielscript werden die Messwerte in eine Textdatei geschrieben, in einer MySQL-Datenbank gespeichert und per Telnet an den FHEM-Server übermittelt.

Das war der Schnelldurchlauf. Hier jetzt alles nochmal etwas detaillierter…

Sketch für den NodeMCU

Folgender Sketch muss mittels Arduino IDE auf den NodeMCU geladen werden (zu Beginn des Schreibens der Software auf den Mikrocontroller den „Flash“-Knopf am NodeMCU drücken). Das Hochladen des Sketch auf den NodeMCU ohne angeschlossenen Sensor und Verkabelung für den DeepSleep (siehe weiter unten) durchführen.

Vorher müssen die im folgenden Script gelb markierten Zeilen entsprechend angepasst werden: Den Wert der Variablen url zur Webadresse des PHP-Scriptes (siehe weiter unten) setzen, welches z.B. auf einen Webserver auf einem Raspberry PI oder einem Odroid etc. erreichbar ist.

Der Sketch benötigt die Bibliothek NewPing von Tim Eckel sowie die auch schon beim Windsensor genutzte Wifi-Bibliothek. Mit der Variablen sleepTimeS kann man ggf. variieren um den ESP in einen DeepSleep zu versetzen. Allerdings ist die Maximalzeit etwa 71 Minuten, da die Angabe von ESP.deepSleep in Millisekunden angegeben werden muss und die Variable ansonsten überläuft.

Der NodeMCU misst dann mittels des Ultraschallsensors den Abstand zur Wasseroberfläche und übermittelt diesen Wert und die Betriebsspannung als Parameter in der URL zum PHP-Script auf dem Webserver.

/*
***********************************
* Ultraschallsensor SR04 an NodeMCU
***********************************
*/

#include <ESP8266WiFi.h>
#include <NewPing.h>


#define TRIGGER   4
#define ECHO      5
#define MAX_DIST  300
#define DEBUG true

NewPing sonar(TRIGGER, ECHO, MAX_DIST); 

// WLAN Zugangsdaten
const char* ssid      = "wlan_ssid";
const char* password  = "wlan_passwort";
// Host zum senden der Daten
const char* datahost  = "ip_des_hosts";
const int sleepTimeS = 10 * 60;  // 10 Min


int abstand;

WiFiServer server(80);
ADC_MODE(ADC_VCC);

// Verbindung zum WLAN aufbauen
void verbinden() {
  if(DEBUG) {
    delay(10);
    Serial.println("");
    Serial.print(F("Verbinde zu WLAN-Netzwerk '"));
    Serial.print(ssid);
    Serial.print("' ");
  }
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }
 
  if(DEBUG) {
    Serial.println(F("-> Verbunden"));  
    Serial.print(F("IP-Adresse: "));
    Serial.print(WiFi.localIP());
    Serial.println("");
  }
  //sendData();
}


void setup() {  
  Serial.begin (115200);
  //abstand = sonar.ping_cm();
  verbinden();
  if(DEBUG) {
    Serial.println("Abstand: ");
    Serial.print(abstand);
  }
  sendData();
}


void loop() {
  if(DEBUG) {
    Serial.println("");
    Serial.print("Gehe schlafen fuer ");
    Serial.print(sleepTimeS);
    Serial.print(" Sekunden");
  }
  
  ESP.deepSleep(sleepTimeS * 1000000);

  verbinden();
  sendData();
}


// Verbindung zu Host herstellen und Sensordaten übermitteln
void sendData() 
{
  Serial.println("");
  Serial.print(F("Verbinde zu '"));
  Serial.print(datahost);
  Serial.print("'");
   
  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(datahost, httpPort)) {
    Serial.println(F(" Fehler beim Verbinden zum Host"));
    return;
  }

  abstand = sonar.ping_cm();  
  if(DEBUG) {
    Serial.println("Abstand: ");
    Serial.print(abstand);
  }

  // Batteriespannung auslesen
  float vcc = ESP.getVcc() / 1000.0;

  String url = "/umwelt/zisterne.php";
  url += "?abstand=";
  url += abstand;
  url += "&vcc=";
  url += vcc;

  Serial.println("");
  Serial.print("URL-Anfrage: ");
  Serial.println(url);
   
  client.print(String("GET ") + url + " HTTP/1.1\r\n" +
               "Host: " + datahost + "\r\n" + 
               "Connection: close\r\n\r\n");
  unsigned long timeout = millis();
  while (client.available() == 0) {
    if (millis() - timeout > 5000) {
      Serial.println("[Client Timeout]");
      client.stop();
      return;
    }
  }
   
  // Lese alle Daten aus der Antwort des Servers
  while(client.available()){
    String line = client.readStringUntil('\r');
    Serial.print(line);
  }
  Serial.println("");
  Serial.print(F("Verbindung zu '"));
  Serial.print(datahost);
  Serial.println(F("' beendet."));
}

PHP Script

Das PHP-Script muss auf einem Webserver (z.B. Apache)  gelegt werden. Die URL, unter der diese Seite zu erreichen ist, muss ohne Hostnamen oder IP in dem obigen Arduino-Sketch eingetragen werden.

Das Script berechnet die Menge des enthaltenen Regenwassers nicht in m³ oder Liter sondern nur den prozentualen Füllstand. Um das auf die jeweilige Zisterne anzupassen, müssen die beiden Werte „Abstand Sensor-Wasseroberfläche“ (bei Maximalstand) und der „Abstand des Sensors zum Zisternenboden“ gemessen und eingetragen werden (beide Werte in cm). Das ist recht einfach und wesentlich schneller erledigt als die Eichung des Homematic-Sensors.

Je nachdem wie die gemessenen Daten verarbeitet werden sollen, müssen verschiedene Anpassungen im Script vorgenommen werden:

1) Das Script sieht aktuell eine Speicherung der Messwerte in einer Datei auf dem Server vor (Pfad & Name anpassen),

2) Die Speicherung in einer MySQL-Datenbank (Verbindungsdaten anpassen und Tabelle in MySQL anlegen (DDL für Datenbanktabelle ist unter dem PHP-Script zu finden).

3) Die Übergabe der Messwerte an einen FHEM-Server (Hostname oder IP und ggf. Port eintragen). In FHEM müssen dazu zwei Dummy-Felder ZisterneFuellstand und ZisterneSpannung eingerichtet werden.

Die ggf. zu ändernden Zeilen sind im Script gelb markiert.

<?php

$fuellstand=$_GET["abstand"];
$abstand=$fuellstand;
$vcc=$_GET["vcc"];

//******************************************
// Umrechung des Abstandes in die Fuellhoehe
//******************************************
$abstand_sensor_wasser_max=40;  //Sensor bis Wasseroberfläche bei max. Wasserstand
$abstand_sensor_wasser_min=151; //Sensor bis Grund Zisterne
$fuellstand=(($fuellstand-$abstand_sensor_wasser_min)/($abstand_sensor_wasser_max-$abstand_sensor_wasser_min))*100;

//*************************
// Werte in Datei schreiben
//*************************
$datum = date("d.m.Y H:i");
$handle = fopen ('tmp/zisterne.txt', 'a');
fwrite ($handle, $datum.",".$fuellstand.",".$abstand."\n");
fclose ($handle);

//****************************
//Werte in Datenbank schreiben
//****************************
$servername = "dbserver";
$username = "dbuser";
$password = "dbpasswort";
$dbname = "dbname";

$connection = new mysqli($servername, $username, $password, $dbname);
if ($connection->connect_error) {
        die("Connection failed: " . $connection->connect_error);
}
$sql = "INSERT INTO zisterne (timestamp,fuellstand,spannung) VALUES (CURRENT_TIMESTAMP,$fuellstand,$vcc)";
if ($connection->query($sql) === TRUE) {
        //echo "INSERT war erfolgreich";
} else {
        echo "Error: " . $sql . "<br>" . $connection->error;
}

//***********************
//Werte an FHEM übergeben
//***********************
$fhemhost = "ip_fhem_host";
$fhemport = 7072;
$fhemsock = fsockopen($fhemhost, $fhemport, $errno, $errstr, 30);
$fhemcmd = "set ZisterneFuellstand ".$fuellstand."\r\nquit\r\n";
fwrite($fhemsock, $fhemcmd);
fclose($fhemsock);

$fhemsock = fsockopen($fhemhost, $fhemport, $errno, $errstr, 30);
$fhemcmd = "set ZisterneSpannung ".$vcc."\r\nquit\r\n";
fwrite($fhemsock, $fhemcmd);
fclose($fhemsock);
?>

DDL für MySQL-Tabelle

CREATE TABLE `zisterne` (
  `timestamp` datetime NOT NULL,
  `fuellstand` float NOT NULL,
  `spannung` float NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

Verkabelung

Die Verkabelung des Ultraschall-Sensors mit dem NodeMCU ist sehr einfach. Da der NodeMCU 5V am Pin „VU“ vom USB-Anschluss durchreicht, braucht es keine weitere Beschaltung mit Widerständer etc.

Der „Trigger“ des Sensors ist im Arduino-Script an Pin 4 definiert. GPIO 4 entspricht beim NodeMCU dem Anschluss D2 (Grün).

„Echo“ ist im Script an Pin 5 definiert. GPIO 5 ist beim NodeMCU der Anschluss D1 (Blau).

„GND“ des Sensors an einen der GND-Pins des NodeMCU (Schwarz).

„VCC“ an VU am NodeMCU. Hier werden die 5V des USB-Anschlusses durchgereicht (Rot).

Wichtig: Damit der ESP auch wieder aus seinem 10-minütigem Tiefschlaf erwacht, muss der RST-Eingang des NodeMCU mit D0 verbunden werden (Violett). D0 ist ein spezieller Pin mit einer Wake-Eigenschaft. Mehr dazu im Internet, wenn ihr nach „ESP8266 deepsleep“ sucht. Ist diese Brücke nicht angeschlossen, übermittelt der NodeMCU genau einmal einen Wert und geht dann für immer Schlafen solange er am Strom bleibt.

Das war es dann auch schon mit der Verkabelung. Hier noch zwei Bilder meines NodeMCU den ich außerhalb der Zisterne in einem Nebenraum betreibe.

Einbau

Der Ultraschallsensor ist nicht wasserdicht! Ich habe die Platine daher in eine kleine Aufputzdose aus dem Baumarkt gepackt und vorsichtig mit Heißkleber eingegossen. Ich hatte etwas bedenken das mir die SMD-Widerstände durch den heißen Kleber entgegen geschwommen kommen, es hat aber funktioniert. Dann noch die Kabeldurchführung und die Bohrungen rund um die beiden Sensoren mit Kleber füllen. Da der Sensor preisgünstig ersetzt werden kann, versuche ich es erstmal mit deser Lösung. Falls ich alle 3 Wochen in die Zisterne krabbeln muss um den Sensor zu erneuern, kommt vielleicht die wasserdichte Variante K-14WP10 zum Einsatz.

Der Sensor hängt nun wie auch schon der erste Sensor von Homematic einfach an einem Brett, welches auf dem oberen Ring der Zisterne aufliegt.

Ergebnis

Der NodeMCU übermittelt die vom Sensor gemessen Abstände im 10 Minutentakt an das PHP-Script. Dort werden die Werte mittels der im Script hinterlegten Abstände in den aktuellen prozentualen Füllstand gerechnet und in die Datei/Datenbank/FHEM geschrieben.

In den folgenden Bildern sind die Graphen der TabletUI aus den FHEM-Daten zu sehen. Es sind einige Peaks zu erkennen deren Grund ich noch nicht weiß. Vielleicht verrichtet eine Spinne ihre Arbeit unterhalb des Sensors…

Allerdings lässt sich auch trotz dieser Peaks der Füllstand gut ablesen. Man sieht wenn es geregnet hat und wann Wasser entnommen wurde.

Bevor ich diesen Artikel fertig geschrieben hatte, hat es geregnet und die Zisterne war fast voll. Aktuell sind keine seltsamen Werte mehr gemessen worden. Evtl. hängt es mit dem Abstand des Sensor zur Wasseroberfläche zusammen.

Ich muss gießen um das heraus zu finden…

In der Gesamtübersicht von TabletUI stelle ich den Füllstand als Balkendiagramm mit 2 Schwellenwerten dar. Nach dem letzten Regen schaut es wieder gut uas.

Mal sehen wie sich der neue Aufbau so schlägt wenn das Klima in der Zisterne wieder etwas rauer wird. Ich werde berichten!

Gruß Chris