Auf der Suche nach einer Möglichkeit den Eigenverbrauch zu erhöhen, fiel ein Batteriespeicher aufgrund der hohen Anschaffungskosten raus. Was tun?

Vor einigen Jahren wurde der Kachelofen mit Wassertasche vom Schornsteinfeger wegen Umweltauflagen still gelegt (sehr schade drum). Dadurch ist aber noch der Warmwasserspeicher im Heizungsraum vorhanden. Diese hatte nach der Stilllegung des Kachelofen keine weitere Wärmequelle als die Ölheizung. Solarthermie ist leider nicht vorhanden und auch für eine Neu-Installation zu aufwändig.

Wir dachten dann über einen Heizstab nach. Der Wasserspeicher hat die Möglichkeit einen Heizstab von oben einzuschrauben. Leider ist es aber sehr schwierig, Heizstäbe mit entsprechend langer heiz-freier Zone zu bekommen, da das Wasser im Wasserspeicher ja nicht randvoll gefüllt ist. Bei anderen Herstellern von Warmwasserspeichern kann man den Heizstab seitlich einschrauben. Und der Heizstab vom Hersteller des Wasserspeichers ist leider raus, da er zu lang ist und wir den Warmwasserspeicher hätten kippen müssen. Es musste also eine andere Lösung her.

Wärmekreislauf im Selbstbau

Ein guter Freund meines Vaters ist Heizungsbauer und hat eine Vorrichtung gebaut, die analog der Wassertasche des alten Kachelofen das Wasser mittels Umwälzpumpe, an einem Heizstab vorbei, in den Warmwasserspeicher pumpt. Die Pumpe war noch vom Kachelofen vorhanden und der Heizstab ist ein günstiger ~ 2KW Heizstab mit 1 1/2 Zoll Gewinde. Dieser steckt nun in einem Eisenrohr/T-Stück mit entsprechendem Gewinde und ist über Kupferleitungen an den Warmwasserspeicher angeschlossen. Zudem wurde dieser Kreislauf noch an das Ausdehnungsgefäß des normalen Heizkreislauf angeschlossen, damit wir uns ein zweites Ausdehnungsgefäß sparen konnten.

Im Bild erkennt man den Heizstab, der senkrecht in dem Eisenrohr steckt, die grüne Umwälzpumpe und die entsprechende Verrohrung. Später wurde die Konstruktion noch isoliert.

Jetzt soll der Heizstab aber nur eingeschaltet werden, wenn auch PV-Überschuss vorhanden ist. Kauflösungen wie z.B. „intelligente“ Heizstäbe von ELWA kosten > 500 €. Soviel wollten wir aber nicht ausgeben, da die Ausbeute und der Wirkungsgrad um Wasser mit elektrischer Energie mittels Heizstab zu erhitzen nicht sehr effizient ist und sich schlecht amortisiert. Eine kleine Wärmepumpe schied übrigens vorerst aus Kostengründen auch aus.

Die Daten…woher bekommen?

So, wie kommt man nun an die Daten wann die Anlage Überschuss produziert? Der SMA-Wechselrichter ist ohne „Sunny Boy“ nicht wirklich auskunftsfreudig (es war ja ein Low-Budget-Selbstbau-Anlage). Aber welche Daten werden denn benötigt?

• den Eigenverbrauch des Hauses und
• die aktuelle Leistung, die durch die Solaranlage geliefert wird

Die Werte für den Eigenverbrauch hatten wir schon relativ schnell nach Inbetriebnahme der Solaranlage durch Einbau eines Powerfox am digitalen Stromzähler erledigt. Dieser misst am Energiezähler die aktuell benötigte Leistung, sowie die elektrische Energie des Verbrauchs und der Einspeisung. Den Powerfox kann jeder einfach anbringen, da er nur mittels Magnet an der entsprechenden Stelle am Zähler befestigt wird. Hier sind keine Arbeiten im Stromkasten notwendig. Der Powerfox ist mit den meisten digitalen Stromzählern kompatibel. Ggf. in die Modell-Liste von Powerfox schauen. Ich selber nutze hier eine Selbstbaulösung, aber der Powerfox ist „adminfreundlicher“.

Die Messung der Leistung der Solaranlage kam dann etwas später durch den Einbau eines Shelly 3EM mit drei Stromzangen im Stromkasten dazu. Die Stromzangen werden einfach um die drei Phasen gelegt, die vom Wechselrichter kommen. Der 3EM kommt auf die Hutschiene im Stromkasten und benötigt noch Versorgungsspannung. Für den Einbau ggf. besser einen Elektriker zu Rate ziehen!

Damit hatte mein Vater schon vor der Idee mit dem Heizstab alle wichtigen Informationen der Solaranlage und des Hausverbrauches zur Verfügung. Allerdings über zwei unterschiedliche Apps und ohne zentrale Einheit wie ein Smart-Home-Server.

Zurück zum Heizstab. Alle Infos, um den Heizstab bei PV-Überschuss anzuschalten waren also schon vorhanden. Um nun aus diesen Infos den eigentlich Überschuss zu berechnen und den Heizstab zu schalten, kam ich nicht mehr drumherum, einen kleinen Server mit entsprechender Software aufzusetzen.

Die Steuerung

Das Erste was mir als Software in den Sinn kam war openWB. Ich habe eine openWB-Wallbox und nutze sie schon zum Überschussladen des E-Autos und hatte mich auch schon mal in das von mir nicht genutzte SmartHome-Menü der openWB verirrt. Die Software selber kann auch ohne Wallbox-Funktionalitäten auf einem RaspberryPI betrieben werden. Ich hatte noch einen Pi 3 hier liegen und die Software war schnell installiert. Der Powerfox und der Shelly 2EM (sowie andere Produkte von Shelly) werden bereits von openWB unterstützt. Die Integration funktioniert einfach mit Eingabe der Shelly-IP bzw. der Powerfox-Cloud-Daten über die Weboberfläche der OpenWB.

Danach zeigt die Startseite der openWB die gemessenen Werte an. Im Screenshot aktuell sehr wenig Sonne und relativ viel Hausverbrauch.

Verschiedene Smart-Home-Geräte (unter die auch der zukünftige Heizstab fällt) können nun in der openWB konfiguriert werden und mit Aktionen hinterlegt werden. Der Heizstab selber ist natürlich nicht „Smart“. Ein- und ausgeschaltet werden soll er über einen Shelly Plug S. Den Shelly sieht man auch auf dem ersten Bild oben links. Daran angeschlossen ist der Heizstab und die Umwälzpumpe. Auch dieser Shelly wird von openWB als Smart-Home-Gerät unterstützt.

Was jetzt noch bleibt, sind verschiedene Einstellung am Smart-Home-Gerät:

• Schwellenwerte (in Watt) zum Ein- und Ausschalten,
• Nachlaufzeiten (in Sekunden) damit der Stab nicht ständig an- und ausgeht wenn Wolken aufziehen,
• Zeiträume und Gesamtdauer pro Tag in denen überhaupt geschaltet wird (zur Sicherheit falls die openWB den Shelly Plug aus irgendwelchen Gründen nicht ausschaltet)
• und einige andere Einstellungen.

Das ist natürlich abhängig vom Heizstab, dem Warmwasserspeicher und der gesamten PV-Anlage. Hier muss ein bisschen ausprobiert werden welche Werte für die jeweilige Anlage am besten passen.

Zur Sicherheit wird der Shelly Plug an Pumpe und Heizstab auch noch täglich mit Sonnenuntergang durch die Shelly-App ausgeschaltet und der Heizstab besitzt noch ein eigenes Thermostat, wodurch er sich selber ab einer einstellbaren Temperatur ausschaltet. Mit diesen Mitteln und den Einstellungen in der openWB sollte ein überhitzen bzw. zu langes laufen des Heizstabes ausgeschlossen sein.

Die Apparatur läuft seit dem Herbst 2024. Die Tage, an denen Sonne war und der Schwellwert für den PV-Überschuss in der openWB erreicht wurde, schaltete den Heizstab und die Umwälzpumpe über den Shell Plug einwandfrei ein und aus. Den Status des Heizstabes (An/Aus) sowie die aktuell benötigte Leistung und die pro Tag in den Heizstab geflossene Energie zeigt die openWB auch auf der Startseite an.

Grundsätzlich funktioniert das also. Wirklich viel PV-Überschuss gab es aber leider nicht, so das wir das nächste Frühjahr abwarten müssen.

Wunder wird der kleine Heizstab im Warmwasserspeicher nicht vollbringen, aber auch im Sommer wird warmes Wasser benötigt und es sollte dann Wärme produziert werden, die mehr als 8 Cent wert ist. Die Ausgaben hielten sich auch sehr in Grenzen. Eigentlich war es nur der Heizstab für < 100 € und der Shelly Plug für 23 €. Der Rest war schon vorhanden (Powerfox und Shelly 3EM) bzw. lag irgendwo herum (Raspi, Umwälzpumpe). Das Installations-Material kostete ein Feierabendbier.

Ich werde mal berichten wie das Ganze im Sommer funktioniert.

Gruß
Chris

Das Zählen der Impulse habe ich bei mir mit einer kleinen PHP-Seite umgesetzt, die bei jedem Aufruf einen neuen Eintrag in eine Datenbank schreibt. Der Mikrocontroller ruft bei mir dazu die Seite „GasMeterImpuls.php“ auf, die auf einem Webserver liegt. Das PHP-Script macht dabei nicht anderes, als bei jedem Aufruf eine neue Zeile mit Zeitstempel und einer „1“ für den Impuls in eine Tabelle einer MariaDB zu speichern.

<?php
//********************************************
//Impuls vom Gaszaehler in Datenbank schreiben
//********************************************

$servername = "";
$username = "";
$password = "";
$dbname = "";

$conn = new mysqli($servername, $username, $password, $dbname);

if ($conn->connect_error) {
        die("Connection failed: " . $conn->connect_error);
}

$sql="INSERT INTO gaszaehler (timestamp,zaehlerstand) VALUES (CURRENT_TIMESTAMP,1)";

if ($conn->query($sql) === TRUE) {
        //echo "Neuer Eintrag erzeugt";
} else {
        echo "Fehler: " . $sql . "<br>" . $conn->error;
}

$conn->close();
?>

Die Tabelle in der MariaDB ist sehr einfach und besteht nur aus zwei Spalten. Einmal eine Spalte mit einem Zeitstempel und eine weitere Spalte für den Impuls. Der Spaltenname „zaehlerstand“ ist evtl. etwas irreführend. Hier werden nur die einzelnen Impulse und kein Gesamtzählerstand gespeichert!

Hier das Create-Table für die Tabelle:

CREATE TABLE `gaszaehler` (
  `timestamp` datetime NOT NULL,
  `zaehlerstand` int(11) NOT NULL
) ENGINE=InnoDB

Heute würde ich anstelle der MariaDB eher eine auf Zeitreihen spezialisierte InfluxDB nehmen. InfluxDB arbeitet auch besser mit Grafana zusammen. Die Nutzung der MariaDB ist bei mir aber „historisch“ bedingt ;-).

Die Daten aus der MariaDB stelle ich dann mit Grafana graphisch dar. Diagramm-Typ ist hier ein „Bar Chart“.

Im Grafana verwende ich dazu für die Bar-Charts die drei folgenden SQL-Statements, die über Summen-Funktionen aus den einzelnen Impulsen die entsprechenden Tages-, Monats- und Jahreswerte berechnen:

SELECT
  timestamp as "time",
  sum(zaehlerstand)/100 as 'jährlicher Gasverbrauch'
FROM gaszaehler
GROUP BY year(timestamp)
ORDER BY year(timestamp) ASC;

SELECT 
  timestamp as "time",
  sum(zaehlerstand)/100 as 'monatlicher Gasverbrauch'
FROM gaszaehler
WHERE year(timestamp) >= YEAR(CURRENT_DATE - INTERVAL 7 MONTH)
GROUP BY month(timestamp), year(timestamp)
ORDER BY month(timestamp)

SELECT 
  timestamp as "time",
  sum(zaehlerstand)/100 as 'täglicher Gasverbrauch'
FROM gaszaehler
WHERE timestamp >= DATE_SUB(NOW(),INTERVAL 7 DAY)
GROUP BY day(timestamp),month(timestamp), year(timestamp)
ORDER BY year(timestamp),month(timestamp),day(timestamp) asc

Die Beschriftung der X-Achse erfolgt über einen „Override“ im Grafana, da die Beschriftung der X-Achse sonst eher unschön wird. Hier im Bild ist ein solcher Override z.B: für den täglichen Verbrauch dargestellt.

Anzeigen lasse ich mir die Diagramme von Grafana dann in der TabletUI von FHEM mittels iframe. Ja, ich nutze immer noch FHEM obwohl das sooo Old School ist und ich im Home Assistant doch alles per klicki klacki machen kann. Will ich aber nicht…

Mit TabletUI von FHEM schaut dann die Oberfläche mit den eingebundenen Diagrammen aus Grafana auch ganz nett aus.

Viel Spaß mit den Auswertungen.

Gruß Chris

Aber nun die drängende Frage: Wohin mit der Hülle der Vinylplatte während diese auf dem Plattenspieler dreht? Bisher lag die Hülle neben dem Plattenspieler. An sich ein guter Platz und kein Problem, aber es gibt ja auch schicke Halter im Internet. Diese zeigen meistens den Schriftzug „Now playing“ oder „Now spinning“ und halten die Platte mittels eines entsprechend geformten Holz-, Acryl- oder Metall-Konstruktes an der Wand, auf dem Sideboard oder wo auch immer. Das fand ich langweilig und daher musste eine andere Lösung her.

Wenn schon so ein Halter da rum steht, kann der auch was tun während keine Schallplattenhülle drin steht. Was liegt da näher als mal wieder einen Mikrocontroller mit einem Display zu bemühen. Heraus gekommen ist ein erster Prototyp meines „Now Spinning“-Plattenhalters.

Genutzt habe ich wieder einen NodeMCU mit ESP8266 und acht MAX7219 LED 8×8 Matrix-Module. Mittels Taster, der von der eingestellten Schallplattenhülle gedrückt bleibt, wird die Anzeige auf einen dauerhaften Text (bei mir „NOW SPINNING“) gesetzt. Das folgende kurze Video zeigt die Funktion des Tasters (Entschuldigung für die Focus-Probleme…ich werde in diesem Leben kein You-Tuber mehr…):

Wird der Taster nicht betätigt (also die Platte wieder woanders verstaut), werden auf dem Display verschiedene Informationen angezeigt deren Anzeige im 5-Sekunden-Takt wechselt. Das wäre einmal die Innentemperatur die mittels BME280-Sensor erfasst wird und dann noch verschiedene weitere Daten die nicht lokal gemessen werden, sondern durch den Aufruf eines HTTP-Endpunktes des NodeMCUs an diesen „von aussen“ übergeben werden.

Dieser HTTP-Post erfolgt durch ein einfaches PHP-Script welches per Cron auf einem Raspberry Pi aufgerufen wird. Die anzuzeigenden Daten werden von diesen Script aus meinem FHEM (ja, ich nutze immer noch FHEM und bin weiterhin sehr zufrieden damit) ausgelesen und die URL des NodeMCUs mit den zu übergebenen Daten aufgerufen. Aktuell werden fünf übergebene Argumente verarbeitet:

• Aussentemperatur
• Akkustand der PV-Anlage
• Aktuelle Leistung der PV-Anlage
• Temperatur des Wasserpuffers oben
• Temperatur des Wasserpuffers unten

Der Aufruf der URL und die Übergabe der Daten an den NodeMCU schaut beispielhaft wie folgt aus:

<ip_des_nodemcu>/receivedata?aussentemperatur=17.3&akkustand=67&pv=1.5&pufferoben=70&pufferunten=56

Das folgende Video zeigt den Wechsel der Daten:

PHP-Script zum übermitteln der Messwerte

Im PHP-Script (nowspinning.php) werden die Reading-Daten aus FHEM per CURL abgefragt, dann die URL mit den Messwerten zusammen gebaut und anschliesend wiederum per CURL vom NodeMCU aufgerufen. Warum PHP: Weil´s für mich am schnellsten ging. Wenn ich mal Muße habe ändere ich es nach Python. Es funktioniert jedenfalls bisher völlig unproblematisch.

<?php
function getFhemReading($readingName, $fhemUrl) {
    $fhemCmd = "list $readingName";
    $cmd = "curl -s \"$fhemUrl/fhem?cmd=".urlencode($fhemCmd)."&XHR=1\"";    
    $output = shell_exec($cmd);
    $value = null;
    $match=explode(" ", $output);
    $match=array_filter($match);
    return str_replace(array("\r","\n"),'',end($match));
}

$fhemUrl = "http://<url_zum_fhem>:<fhem_port>";

$aussentemperatur = round(getFhemReading("Aussenthermometer temperature", $fhemUrl),1);
$akkustand = round(getFhemReading("MQTT2_openWB_Client SOC",$fhemUrl),1);
$pvleistung = round(getFhemReading("MQTT2_openWB_Client SolarPower",$fhemUrl)/1000,1);
$pufferoben = round(getFhemReading("HeizungPufferOben state",$fhemUrl),1);
$pufferunten = round(getFhemReading("HeizungPufferUnten state",$fhemUrl),1);

$cmd = "curl -s \"http://<ip_nodemcu>/receivedata?aussentemperatur=".$aussentemperatur."&akkustand=".$akkustand."&pvleistung=".$pvleistung."&pufferoben=".$pufferoben."&pufferunten=".$pufferunten."\"";

shell_exec($cmd);
?>

Hier der Aufruf des Scriptes in der Crontab alle 3 Minuten:

*/3 * * * * php /usr/local/bin/nowspinning.php

Code für den NodeMCU

Der Code für den NodeMCU ist bisher relativ schnörkelfrei. Die WLAN-Zugangsdaten müssen aktuell noch fest im Code vergeben werden. Für das MAX7219 nutze ich die Parola-Bibliothek . Für den BME280 die Bibliothek von Adafruit. Der Schalter hängt an D0 und GND.

#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
#include <ESP8266WebServer.h>

//WLAN
const char* ssid = "<wlan_ssid>";
const char* pass = "<wlan_passwort>";
ESP8266WebServer server(80);

// Hardwaretyp des MAX7219
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW

// PINs und Anzahl der MAX-Elemente
#define MAX_DEVICES 8
#define CS_PIN 15

MD_Parola display = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);

// BME280
#define SEALEVELPRESSURE_HPA (1013.25)
Adafruit_BME280 bme; // I2C

//Schalter um Platte zu erkennen
int pinNowSpinning = D0; 

//Warteschleifen
unsigned long startMillisTemp;
unsigned long currentMillisTemp;
unsigned long startMillisWechsel;
unsigned long currentMillisWechsel;

//Externe Daten deklarieren
String aussentemperatur = "keine Daten";
String akkustand = "keine Daten";
String puffer = "keine Daten";
String pvleistung = "keine Daten";

//Sonstiges
int anzeigennummer=0;

void setup() {

  Serial.begin(115200); 

  display.begin();
  display.setIntensity(0);
  display.displayClear();
  display.setTextAlignment(PA_CENTER);
  
  pinMode(pinNowSpinning, INPUT); 

  bool status;
  status = bme.begin(0x76);  
  if (!status) {
    Serial.println("Kann BME Sensor nicht finden. Verkabelung prüfen!");
    while (1);
  }

  startMillisTemp = millis();
  startMillisWechsel = millis();

  //WLAN
  Serial.print("Verbinde zu: ");
  Serial.println(ssid);
  display.print("Verbinde Wifi");
  WiFi.begin(ssid, pass);
   
  while(WiFi.status() != WL_CONNECTED){
    delay(500); 
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi verbunden");
  Serial.print("IP-Adresse des ESP8266: ");  
  Serial.println(WiFi.localIP());
  display.displayClear();
  display.print(WiFi.localIP());
  delay(3000);

  //Webendpunkte
  server.on("/",handleRoot);
  server.on("/receivedata", receiveData);

  server.begin();
}

void loop() {
  //Client-Anfragen abfragen
  server.handleClient(); 

  if (digitalRead(pinNowSpinning) == HIGH) {
    //Text wenn eine Platte abgestellt ist    
    display.print("NOW SPINNING");
    Serial.println("Now Spinning");  
  } else {
    currentMillisWechsel = millis();    
    if (currentMillisWechsel - startMillisWechsel >= 5000) {
      startMillisWechsel = currentMillisWechsel;
      anzeigennummer++;
      Serial.print("Anzeigenummer: ");
      Serial.println(anzeigennummer);
      switch (anzeigennummer) {
        case 1:
          //Temperatur alle 30 Sekunden abfragen
          currentMillisTemp = millis();        
          if (currentMillisTemp - startMillisTemp >= 10000) {
            startMillisTemp = currentMillisTemp;
            String temperatur = String(bme.readTemperature());
            display.print("> "+temperatur.substring(0,temperatur.length()-1)+" \"C");

            Serial.print("Temperatur: ");
            Serial.print(bme.readTemperature());
            Serial.println(" °C");

            Serial.print("Luftfeuchte: ");
            Serial.print(bme.readHumidity());
            Serial.println(" %");
          }
          break;
        case 2:
          display.print(aussentemperatur);
          Serial.println(aussentemperatur);          
          break;
        case 3:
          display.print(akkustand);
          Serial.println(akkustand);          
          break;
        case 4:
          display.print(pvleistung);
          Serial.println(pvleistung);          
          break;
        case 5:
          display.print(puffer);
          Serial.println(puffer);          
          break;
        default:
          // statements
          break;
      }
      if (anzeigennummer>=5) { 
        anzeigennummer=0; 
        Serial.println("Anzeigenummer reset");
      }
    }  
  }
}

void handleRoot() {
  String message="<h1>Now Spinning</h1>";
  message += "Das ist die lieblose Webseite des 'Now Spinning'-Anzeigers</br></br>";
  message += "Temperatur: ";
  message += bme.readTemperature();
  message += " °C<br>";
  message += "Luftfeuchte: ";
  message += bme.readHumidity();
  message += " rel%<br>";
  server.send(200, "text/html", message);
}

void receiveData() {
  String message="<h1>Empfange Daten</h1>";
  message += "Daten werden empfangen...</br></br>";
  server.send(200, "text/html", message);

  Serial.println("Daten empfangen...");
 
  //Aussentemperatur
  Serial.print(server.argName(0));
  Serial.print(F(": "));
  Serial.println(server.arg(0));
  aussentemperatur="< " + server.arg(0) + " \"C";

  //Akkustand
  Serial.print(server.argName(1));
  Serial.print(F(": "));
  Serial.println(server.arg(1));
  akkustand="Akku "+ server.arg(1) + "%";

  //PV Leistung
  Serial.print(server.argName(2));
  Serial.print(F(": "));
  Serial.println(server.arg(2));
  pvleistung="PV "+ server.arg(2) + "KW";

  //Puffer oben u. unten
  Serial.print(server.argName(3));
  Serial.print(F(": "));
  Serial.println(server.arg(3));
  Serial.print(server.argName(4));
  Serial.print(F(": "));
  Serial.println(server.arg(4));
  puffer = "- " + server.arg(3) + "  _ " + server.arg(4); 
}

Schaltungsplan von Fritzing kommt noch und wenn ich mal Zeit finde, packe ich den Code auch noch nach Github.

Holzarbeiten

Hier hat mir dankenswerterweise Arnim (der immer mit meinen Kritzeleien zurecht kommen muss) sehr geholfen und hat mir einen ersten Prototyp aus Fichte gebaut.

Die Nut um die Platte zu halten, wurde mit leicht schräg gestelltem Sägeblatt der Tischkreissäge angefertigt und ist etwa 1 cm breit. Der vordere Ausschnitt um den NodeMCU und das Display unter zu bringen ist mit der Oberfräse gefräst.

Den Taster hab ich von unten in ein zweistufig gebohrtes Loch mit Heißkleber befestigt. Im Bild unten ist der Taster als kleines schwarzes Ding zu erkennen. Die Kabel des Schalters sind dann schräg nach vorne in die Ausfräsung verlegt.

Das Anschlusskabel verläuft duch eine Bohrung unter der Nut für die Platte und dann auch schräg nach oben in die Ausfräsung. Hier hab ich ein normales Micro-USB-Kabel genutzt, kurzerhand durchgeschnitten und wieder zusammengelötet.

Für die Unterbringung des Temperatursensors brauche ich noch eine gute Lösung. Dieser liegt aktuell einfach mit in der Ausfräsung in der Ecke. Ich kann mir aber vorstellen, dass dort durch das Display und den NodeMCU die Messung verfälscht wird.

Todo´s

Es ist ja der erste Prototyp des „Now spinning“-Plattenhüllenhalters und an der Software als auch an der Hardware (für den Mikorcontroller und den Halter selber) ist noch ein bisschen was zu tun. Spontan fällt mir da noch folgendes ein:

• Acrylfront (dunkelrot oder milchig…muss ich mal testen) und Frage der Befestigung
• Helligkeitssensor mittels simplem LDR (wenn dunkel, dann dunkler. wenn Heller, dann heller)
• Uhrzeit (entweder per POST mit den anderen Messwerten übergeben oder Echtzeituhr-Modul)
• Übergabe der Messwerte etwas flexibler gestalten (ohne das bei neuen Werten der Code des NodeMCU geändert werden muss sondern nur beim Aufruf der URL)
• Maximalzeit nach der „Now Spinning“ wieder zu der Anzeige der anderen Daten wechselt
• „Now spinning“ abwechselnd mit einen Spektrum Analyzer (FFT) per Mikrofon aufgenommen
• Einen besseren Platz für den internen Temperatur-Sensor
• Den Halter aus Eiche anstatt Fichte (Grüße an die Fräser)
• Die Luftfeuchte vom BME280 anzeigen
• Befestigung des Temperatursensors

Das war´s erstmal. Falls ihr Den Plattenhalter nachbauen wollt, würde ich mich über Erfahrungen, Verbesserungen, weitere Ideen und Bilder freuen. Bis dahin

Gruß Chris

Hier findet ihr das Github-Repository: https://github.com/diefenbecker/zisternenmessung

Aber auch bei den Funktionen gibt es Neuigkeiten. Die Version 1030 unterstützt jetzt einen schaltbaren Ausgang an D4 mit dem z.B. eine Pumpe über eine Relais-Platine angesteuert werden kann. Gesteuert wird das über zwei prozentuale Werte die in der Konfigurationsseite zu finden sind.

Hier die bin-Datei zum direkten Download:

http://www.bubux.de/heimautomatisierung/ota/zisterne_aktuell.bin

Viel Spaß damit! Das kommende Wochende verspricht wettertechnisch ja den Einsatz der Zisterne…

Gruß

Chris

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

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

Meine Implementierung ist schon etwas älter und auch mit der Zeit gewachsen. Da es sich bei dieser Webseite um ein recht überschaubares Projekt handelt und ich mit dem Ergebnis zufrieden bin, habe ich mir nie die Mühe gemacht die Seite generischer zu gestalten. Daher muss bei nötigen Anpassungen der Code direkt geändert werden und es gibt auch keine Trennung von HTML und PHP, keine durchgehende allumfassende Fehlerbehandlung, evtl. „unschönes“ HTML usw.

Der Code soll als Anregung und Grundlage für eine eigene Seite dienen…nicht mehr, nicht weniger. Wem´s ausreicht kann es natürlich auch 1:1 übernehmen. Positiv an meiner Lösung finde ich immer noch die Flexibilität in den Auswertungen die direkt auf der Datenbank mittels SQL ausgeführt werden können.

Die Startseite

Die Startseite wird mittels „Meta-Refresh“ alle 180 Sekunden neu geladen und dient der Übersicht der wichtigsten Sensordaten. Mit Klick auf die (verlinkten) Boxen gelangt man jeweils zu einer detaillierteren Übersicht der Sensordaten. In der Übersicht werden keine komplizierten Datenbankauswertungen gemacht. Hier werden die Snapshot-Tabellen mit den aktuellen Werten ausgelesen und einige SQL-Aggregat-Funktionen genutzt. Das ging auch auf einem alten Raspi einigermaßen schnell. Das hängt natürlich von den Tabellengrößen in den Datenbanken ab. Da bei mir einige Tabellen mit den Jahren relativ groß geworden sind (~500k Zeilen), bin ich irgendwann auf einen Odroid umgestiegen.

Übersicht der Außentemperaturen

Die Übersicht der Außentemperatur wird aus den Daten des Außenfühlers der Viessmann-Heizung generiert. Die Übersichten für anderen Sensoren sehen analog dieser Ansicht aus.

Die Übersicht der Heizungsdaten

Die Übersicht der Heizungsdaten stellt verschiedene Daten dar die mittels openv aus der Heizung ausgelesen werden. Aktuell lese ich mit openv nur aus und setze keine Werte (z.B. Sommer-/Winterumschaltung).

Voraussetzung und Grundlagen

Details zum Auslesen der verschiedenen Sensordaten findet ihr in vorangegangenen Artikeln hier im Blog:

• Viessmann Heizung mittels openv auslesen
• M-Bus Wasserzähler auslesen
• Gaszähler mit Reed auslesen
• Stromzähler mit optischem Lesekopf auslesen

Die Webseite liest die Datenbanken des Wasserzähler, des Gaszählers, der Heizung und des Stromzählers aus. Folgend nochmal eine Übersicht der Tabellenstrukturen welche auch in den Artikel oben zu finden sind. In MySQL (bzw. MariaDB) habe ich zwei Datenbanken angelegt (vito, haus) mit verschiedenen Tabellen.

Die Tabellen der Datenbank „vito“:

 CREATE TABLE `brenner` (
 `timestamp` datetime NOT NULL,
 `brennerstarts` float NOT NULL,
 `brennerstunden` float NOT NULL,
 `brennerstatus` int(11) NOT NULL,
 KEY `timestamp` (`timestamp`)
 ) ENGINE=InnoDB DEFAULT CHARSET=latin1

CREATE TABLE `snapshot` (
 `timestamp` datetime NOT NULL,
 `brennerstatus` float NOT NULL,
 `brennerstarts` float NOT NULL,
 `brennerstunden` float NOT NULL,
 `solarstunden` float NOT NULL,
 `solarleistung` float NOT NULL,
 `aussentemperatur` float NOT NULL,
 `warmwasser` float NOT NULL,
 `speicher_unten` float NOT NULL,
 `kollektor` float NOT NULL,
 `kesseltemperatur` float NOT NULL,
 `vorlauftemperaturM2` float NOT NULL,
 `vorlaufsolltemperaturM2` float NOT NULL,
 `raumsolltemperaturM1` float NOT NULL,
 `raumsolltemperaturM2` float NOT NULL,
 `raumsolltemperaturredM1` float NOT NULL,
 `raumsolltemperaturredM2` float NOT NULL,
 `warmwassersoll` float NOT NULL,
 `kesseltemperatursoll` float NOT NULL,
 `pumpestatusM1` float NOT NULL,
 `pumpestatusSP` float NOT NULL,
 `pumpestatussolar` float NOT NULL,
 `statusstoerung` varchar(100) CHARACTER SET latin1 COLLATE latin1_german1_ci NOT NULL,
 `systemzeit` varchar(100) CHARACTER SET latin1 COLLATE latin1_german1_ci NOT NULL,
 `error0` varchar(500) CHARACTER SET latin1 COLLATE latin1_german1_ci NOT NULL,
 `BetriebArt` varchar(20) NOT NULL,
 `BetriebArtM2` varchar(20) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1

CREATE TABLE `solar` (
 `timestamp` datetime NOT NULL,
 `solarstunden` float NOT NULL,
 `solarleistung` float NOT NULL,
 `solarpumpe` int(11) NOT NULL,
 KEY `timestamp` (`timestamp`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

CREATE TABLE `temperaturen` (
 `timestamp` datetime NOT NULL,
 `aussentemperatur` float NOT NULL,
 `warmwasser` float NOT NULL,
 `speicher_unten` float NOT NULL,
 `kollektor` float NOT NULL,
 `vorlaufsolltemperaturM2` float NOT NULL,
 KEY `timestamp` (`timestamp`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

Die Tabellen der Datenbank „haus“:

CREATE TABLE `gaszaehler` (
 `timestamp` datetime NOT NULL,
 `zaehlerstand` float NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1

CREATE TABLE `stromzaehler` (
 `timestamp` datetime NOT NULL,
 `public_key` varchar(100) NOT NULL,
 `zaehlerstand` float DEFAULT NULL,
 `active_power` float NOT NULL,
 KEY `strom_index` (`timestamp`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

CREATE TABLE `strom_snapshot` (
 `zeitstempel` date NOT NULL,
 `zaehlerstand` float NOT NULL,
 `wirkleistung` float NOT NULL,
 `aktuelles_jahr` float NOT NULL,
 `aktueller_monat` float NOT NULL,
 `aktueller_tag` float NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1

CREATE TABLE `wasserzaehler` (
 `timestamp` datetime NOT NULL,
 `zaehlerid` int(11) NOT NULL,
 `zaehlerstand` float NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1

CREATE TABLE `wasser_snapshot` (
 `timestamp` date NOT NULL,
 `zaehlerstand` float NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1

„Installation“

Einen funktionierenden Webserver (z.B. Apache) mit PHP und eine MySQL oder MariaDB vorausgesetzt, muss das unten verlinkte tar.gz in ein beliebiges Verzeichnis im www-Verzeichnis des Webservers entpackt werden.

Das funktioniert mit 

tar -xvzf webseite_sensordaten.tar.gz

Konfiguration

In der Datei config.inc müssen ein paar wenige Einstellungen vorgenommen werden. Folgende Einstellungen werden für die Verbindung zur Datenbank benötigt:

$mysqlhost="<hostname>";
$mysqluser="<username>";
$mysqlpwd="<passwort>";
$mysqldbvito="<name_der_db_mit_den_vito_tabellen>";
$mysqldbhaus="<name_der_db_mit_den_haus_tabellen>";

Die folgenden Werte dienen der Auswertung des Gaszählers. Da dieser per Reed-Kontakt ausgelesen keinen Gesamtstand ausgibt und nur die einzelnen Impulse zählt, kann hier ein Startwert definiert. Auch die Werte zur Umrechnung von m³ in KW werden hier eingetragen. Diese Informationen gibt es beim Gaslieferanten.

Zudem kann noch definiert werden wie viel Tage in der Übersicht angezeigt werden sollen. Entsprechender Werte gibt es auch für den Wasserzähler und den Stromzähler.

$gas_startwert="2311650";
$brennwert_gas=10.097;
$zustandszahl_gas=0.9309;
$anz_tage_gas=7;

$anz_tage_wasser=7;

$anz_tage_strom=7;

Wichtiger und letzter Schritt: Das Verzeichnis „tmp“ muss schreibbar für den Webserver sein. Dort werden die generierten Graphen als PNG gespeichert. Das war es schon!

Fehlt nur noch das Paket mit den PHP-Seiten: webseite_sensordaten.tar.gz

Viel Spaß mit

Chris

Mit dem freiwilligen Check des Heizungsfachhandwerks wird erstmals die gesamte Heizungsanlage sozusagen „auf Herz und Nieren“ untersucht. Das Alter der Heizung, eine mögliche Kesselüberdimensionierung, die Dämmung von Leitungen und die Funktionstüchtigkeit von Thermostatventilen spielen beispielsweise eine wichtige Rolle bei der Bewertung. Der Fachmann kann auf dieser Grundlage sinnvolle Modernisierungsmaßnahmen vorschlagen. Schon niedrig investive Maßnahmen steigern die Energieeffizienz der Heizungsanlage.

Will der Hausbesitzer allerdings die optimale Energieeffizienz im Haus erzielen, dann sollte die fortschrittliche Brennwerttechnik mit Erdgas oder Heizöl zum Einsatz kommen. In Verbindung mit Solarthermie, lassen sich somit bis zu 40 Prozent der Heizkosten einsparen. Aber auch Zentralheizungen, die mit Wärmepumpen, Holz oder Pellets betrieben werden, bieten wirtschaftliche Lösungen.

Die Inspektion erstreckt sich über:

• Abgasverlust
• Wärmeverluste über Kesseloberfläche
• Wärmeverluste über das Abgassystem der Heizung
• Brennwertnutzung
• Überdimensionierung des Heizungskessels
• Heizkesselregelung
• Hydraulischer Abgleich der Heizungsanlage
  
• Überdimensionierung der Heizpumpe
• Dämmung der Rohrleitung
• Regelungseinrichtungen der Heizkörper

Pro untersuchtem Bereich vergibt der Fachhandwerker eine bestimmte Anzahl von Punkten. Je höher diese Zahl, umso weiter ist die Heizung vom energetischen Idealzustand entfernt. Viele Punkte bedeuten also ein besonders großes Verbesserungs-potenzial. Die Kosten des Heizungs-Check`s für ein Einfamilienhaus belaufen sich je nach Region zwischen 100€ und 250€ und nimmt ca. 1,5 Stunden Zeit in Anspruch! Wenn im Nachgang aus dem Heizungsscheck ein Auftrag für den Installateur entsteht, kann in der Regel dieser Betrag in Abzug gebracht werden.

Entwickelt wurde der Test für Heizungsanlagen von der VdZ in Zusammenarbeit mit dem Zentralverband Sanitär Heizung Klima (ZVSHK) und dem Institut für Technische Gebäudeausrüstung Dresden. In ersten Feldtests wurden laut VdZ bereits die häufigsten Verursacher von unnötigen Energiekosten identifiziert: schlecht eingestellte Brenner, überdimensionierte Heizkessel, ungeregelte Heizungspumpen sowie zu alte Thermostate an den Heizkörpern.

Bei größeren Mehrfamilienhäusern oder gar Gewerbeeinheiten sind spezielle Kenntnisse erforderlich. Diese bieten daher Ingenieur- oder Planungsbüro`s oder Messdienstleister an. Da es sich hier in der Regel nicht um Standardanlagen handelt, sich die eingesetzte Technik nicht nur auf die Heizenergie beschränkt, greift der einfache Heizungs-Check hier nicht.

Neben den benannten Punkten der Inspektion, werden auch:

• Lüftungsanlagen
• Kälte- und Klimaanlagen
• Wärmerückgewinnungssysteme
• Trinkwassererwärmungsanlagen
• Druckerhöhungsanlagen
• Hausautomatisation
• etc.

bewertet und für den Kunden und die Immobilie zugeschnittene Konzepte erstellt. Daraus resultiert auch das sich der Preis für solche Ingenieurtechnische Leistungen zwischen 1.500€ und 30.000€ bewegen kann.

Anbei die Broschüre der Vereinigung der Deutschen Zentralheizungswirtschaft e.V.

          VdZ_HC_Leitfaden_090210

 follow me https://twitter.com/EU_EnergyCOACH