In der Webseite der Software kann in den Einstellungen zwischen den beiden Sensoren gewählt werden. Neu ist zudem noch der frei wählbare Name für den Sensor welcher auf der Sensor-Webseite oben links angezeigt wird. Hiermit kann man nun beim Einsatz mehrerer Sensoren in verschiedenen Zisternen unterscheiden oder auch einen Öltank-Füllstandssensor korrekt benennen.

Der ToF-Sensor besitzt eine I2C-Schnittstelle und wird an die gleichen PINs wie der Ultraschallsensor angeschlossen. Es geht aber nicht mit beiden Sensoren parallel, sondern nur der eine oder der andere!

Der ToF-Sensor wird wie folgt angeschlossen:

Die beiden übrigen Anschlüsse bleiben frei.

Hier gibt es die neue Version zum Download:
http://www.bubux.de/heimautomatisierung/ota/zisterne_1028.bin

Hier findet ihr die vorherigen Artikel zur Zisterne mit den grundlegenden Anleitungen und Anschlussschema.

Gruß
Chris

• Eine weitere Zisternenbauform (liegender Zylinder)
• Temperatur- und Luftfeuchterfassung mittels DHT22
• Literanzahl, Temperatur und Luftfeuchte mit in die MQTT-Topics aufgenommen

Falls ein Temperatursensor angeschlossen und aktiviert ist, werden dessen Messwerte auf der Startseite angezeigt. Die Anzeige der Temperaturdaten wird alle 60 Sekunden abgefragt und zeigt daher im ersten Moment nach Neustart keine Werte an.

Aktuell kann als Temperatursensor ein DHT22 genutzt werden (weitere Sensoren sind in Arbeit). Aktiviert wird der Sensor in der Konfiguration.

Die neuen MQTT-Topics können ebenfalls in der Konfiguration hinterlegt werden.

Die neue Zisternenbauform ist auch in der Konfiguration zu finden. Die Berechnung funktioniert bei einer runden liegenden Zisterne. Eine ovale Form wird aktuell nicht unterstützt.

Hier gibt es die aktuelle Version zum Download:
http://www.bubux.de/heimautomatisierung/ota/zisterne_aktuell.bin

Für den genauen Aufbau (Anschluss Sensor, Anschluss Diplay etc.) bitte die vorherigen Artikel beachten.

Dann euch noch einen guten Rutsch ins neue Jahr!

Gruß

Chris

Ich hatte das Glück auch zu Beginn der Corona-Zeit relativ normal Arbeiten gehen zu können was bis heute so geblieben ist. Das mit dem „Glück“ ist absolut ernst gemeint wenn ich da so einige gute Bekannte sehe die ganz schön zu knabbern hatten und immer noch haben.

Auffallend war aber, dass es in den letzten Monaten sehr viel mehr Anfragen bzgl. der Füllstandmessung der Zisterne mit dem ESP gab. Daher heute nochmal eine neue Version mit vielen größeren und kleineren Neuerungen.

Neuerungen in dieser Version (1022)

• Länge des WLAN-Passwortes auf 63 Zeichen verlängert (max. bei WPA2)
• Unterstützung unterschiedlicher Zisternenformen
• Integration von Displays
• Optionale tägliche Info per Pushover
• Weiterer Topic (Abstand) für MQTT hinzugefügt
• viele Kleinigkeiten…

Achtung! Aufgrund der Anpassung der maximalen Länge des Passwortes werden bei einem Update einer alten Version bereits vorhandene Konfigurationsdaten (z.B. Sensorabstände) im Speicher des ESP nach hinten geschoben und gehen dadurch verloren. Daher die Werte vorher merken!

Die Anleitung zur Installation der Software auf dem ESP und der grundsätzlichen Funktionen sind in einem älteren Artikel, der hier zu finden ist beschrieben.

Danach gab es noch zwei Artikel mit weiteren Hinweisen zu JSON und MQTT. Das neue MQTT-Topic für den Abstand in dieser Version funktioniert analog zu dem bisherigen für den Füllstand.

Externe Displays

Diesmal habe ich bei der Entwicklung anstatt der bisherigen „One-Man-Show“ nette Unterstützung gehabt. Vor allem bei der Integration der Displays. Vielen Dank an Patrick für Deine Arbeit und Hilfe!

Aktuell stehen drei Displays zur Auswahl, die an den ESP angeschlossen werden können:

• 1602 LCD mit I2C mit 2×16 Zeichen
• 1604 LCD mit I2C mit 4×16 Zeichen
• SSD 1106 oder 1306 OLED mit 128×64 Pixel

Die Displays zeigen neben Informationen zum Füllstand auch Informationen zur Verbindung mit dem voreingestelltem WLAN während des Boot-Vorganges. Ersteres Display ist die preisgünstigste Alternative und reicht für alle wichtigen Infos.

In den Bildern von Patrick ist auch zu sehen wie ein Aufbau der Elektronik aussehen kann. Sehr schön gemacht!

Bei mir schaut das seit der Inbetriebnahme wie folgt aus und ist im Holzschuppen untergebracht:

Hier das Anschluss-Schema inkl. optionalem Display. Der ebenso optionale Taster dient zum Aktivieren der Hintergrundbeleuchtung des Displays. Der Widerstand am Taster sollte mit 10kΩ gewählt werden.

Zisternenformen

Neben der bisher zylindrischen Zisternenform werden nun auch Zisternen mit anderen Grundflächen unterstützt. Die Berechnung des Füllstandes kann zudem basierend auf dem Maximalvolumen erfolgen. Voraussetzung für alle Berechnungen ist aber eine Form mit senkrechten Wänden.

Pushover Notifications

Auch wenn Pushover nicht kostenlos ist (die App selber, Versand der Nachrichten bis zu einer gewissen Menge (7400) schon), bietet es eine einfache und schnelle Möglichkeit Infos auf ein Handy zu senden die ich u.a auch schon im Homematic-Umfeld einsetze. Daher fand es auch Einzug in die Software zur Füllstandsanzeige.

Um Pushnachrichten senden zu können müssen die beiden Token die man in der App oder nach Login auf der Pushover-Webseite findet in der Konfiguration eingetragen werden.

Viel Spaß mit der neuen Version und nochmal Danke an Patrick!

Gruß 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