Füllstandmessung der Zisterne (2ter Ansatz)

diefenbecker — Tue, 21 Aug 2018 19:45:10 +0000

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 
#include 


#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.

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 . "
" . $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

Ultraschallsensor – bubuxblog