Update: 2021-08-28
Esp8266 Nodemcu Gaszähler Thingspeak
Auslesen des Gaszählers Elster BK-G4M mittels Reedrelais.
Die meisten mechanischen Gaszähler besitzen bereits ab Werk einen Impulsmagneten in der letzten Stelle des Rollenzählwerkes
und können einfach mit einem Impulsnehmer ausgestattet werden. Ob der Gaszähler dafür geeignet ist, erkennt man an einem Aufdruck
wie z.B. "1 Imp ? 0,01 m³" auf dem Typenschild.
Funktionen
Zur Anzeige vom Zähler Impuls wird die Onboard Led des Nodemcu genutzt. Die OnBoardLed des Esp 12E wird als Heartbeat-LED verwendet.
Dein händisch eingegebener Zählerstand wird in einer Datei im Spiffs des Esp8266 gespeichert und bei jedem Neustart aus dieser eingelesen.
Der Zählerstand wird, vorausgesetzt der Wert hat sich geändert, aller 4 Stunden erneut abgespeichert.
Ansicht Gaszähler im Webrowser.

Webinterface
Hier kannst du den aktuellen Zählerstand eingeben. Die Leds der optischen Anzeige schalten.
Der Zählerstand im Browser wird aller 5 Sekunden aktualisiert.
Die vergangene Zeit seit dem letzten Sendefehler wird bei aufgeklappter Eingabemaske angezeigt.
Beim Klick auf dem grauen Bereich der Zähleranzeige erscheint die Eingabemaske.
Hier lassen sich auch beide Leds schalten.

Thingspeak Datenlogger
Aller 5 Minuten wird der aktuelle Stand der Gasuhr an deinen Thingspeak Account gesendet.
Die Antwort von Thingspeak, ob die Übertragung erfolgreich war, wird nicht blockierend ausgewertet. Im Fehlerfall wird der Zählerstand erneut zu Thingspeak gesendet.
Anzeige des letzten Sendefehler zu Thingspeak.

Da sich bei mir, als Holzheizer, der Gaszähler nur an extrem kalten Wintertagen dreht,
nochmals vielen Dank an Andreas für die ausführlichen praktischen Tests und Rückmeldungen.
Download Projekt
Der Sketch zum Gasuhr auslesen übersichtlich aufgeteilt in Tabs.
Gaszaehler.ino
// ****************************************************************
// Sketch Gaszähler Modular(Tab)
// created: Jens Fleischer, 2018-03-30
// last mod: Jens Fleischer, 2021-08-28
// For more information visit: https://fipsok.de
// ****************************************************************
// Hardware: Esp8266
// D2 = GPIO4 Anschluss Reedrelais vom GPIO4 auf GND
// 10k Pullup-Widerstand von VCC auf GPIO4
// Versorgung über USB
// Software: Esp8266 Arduino Core 2.4.2 / 2.5.2 / 2.6.3 / 2.7.4
// Getestet auf: Nodemcu
/******************************************************************
Copyright (c) 2018 Jens Fleischer. All rights reserved.
This file is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
*******************************************************************/
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include <ESP8266WebServer.h> // http://arduino-esp8266.readthedocs.io/en/latest/esp8266wifi/readme.html#server
#include <ArduinoOTA.h> // http://arduino-esp8266.readthedocs.io/en/latest/ota_updates/readme.html
#include <FS.h> // http://arduino-esp8266.readthedocs.io/en/latest/filesystem.html
const byte inputPIN = D2; // Reedrelais
const byte HeartbeatLed = D4; // OnBoardLed Esp 12E
const byte CounterLed = D0; // OnBoardLed NodeMcu 1.0
unsigned long value, oldvalue;
bool ledz = HIGH, ledh = HIGH; // Merker für ZählerLed AN/Aus , Merker für HeartbeatLed AN/Aus
unsigned long fehlerZeit; // Zeitpunkt des letzten Fehlers
ESP8266WebServer server(80);
void setup() {
Serial.begin(115200);
delay(100);
Serial.printf("\n\nSketchname: %s\nBuild: %s\t\tIDE: %d.%d.%d\n%s\n\n",
(__FILE__), (__TIMESTAMP__), ARDUINO / 10000, ARDUINO % 10000 / 100, ARDUINO % 100 / 10 ? ARDUINO % 100 : ARDUINO % 10, ESP.getFullVersion().c_str());
pinMode(HeartbeatLed, OUTPUT);
pinMode(CounterLed, OUTPUT);
digitalWrite(HeartbeatLed, HIGH);
Connect(); // ruft die Funktion zum Verbinden mit dem Wlan auf
homepage(); // ruft die Funktion zum bereitstellen einer Webseite auf
Serial.println(SPIFFS.begin() ? "SPIFFS gestartet!" : "Sketch wurde mit \"no SPIFFS\" kompilliert!\n");
server.begin();
Serial.println("HTTP Server gestartet!\n");
ArduinoOTA.onStart([]() { // Zählerstand speichern bevor OTA Update
speichern();
});
ArduinoOTA.begin();
File f = SPIFFS.open("/value.txt", "r"); // Zählerstand beim Start aus Datei lesen
String str = f.readStringUntil('\n');
value = str.toInt();
oldvalue = value;
f.close();
}
void loop() {
static unsigned long letzterAufruf = 0;
ArduinoOTA.handle();
server.handleClient();
zaehlerauslesen(); // Funktionsaufruf
char buf[12];
snprintf(buf, sizeof(buf), "%li.%02li", value / 100, value % 100);
if (!thingspeak(buf)) {
fehlerZeit = millis() / 1000;
}
ledh ? digitalWrite(HeartbeatLed, millis() % 500 >= 250) : digitalWrite(HeartbeatLed, HIGH); // LED zeigt an das der Sketch läuft
unsigned long aktuelleMillis = millis();
if (aktuelleMillis - letzterAufruf >= 60000UL * 240 && value != oldvalue) { // Zählerstand speichern() aller 4 Stunden, wenn der Wert sich geändert hat
speichern();
oldvalue = value;
letzterAufruf = aktuelleMillis;
}
}
void zaehlerauslesen() {
bool aktueller = 1;
static bool vorheriger = 1;
static unsigned long letzteMillis = 0;
unsigned long aktuelleMillis = millis();
if (aktuelleMillis - letzteMillis >= 1000) { // Das Reedrelais wird einmal pro Sekunde abgefragt
aktueller = digitalRead(inputPIN);
if (!aktueller && aktueller != vorheriger) {
value++;
}
vorheriger = aktueller;
letzteMillis = aktuelleMillis;
}
!ledz ? digitalWrite(CounterLed, HIGH) : !vorheriger ? digitalWrite(CounterLed, millis() % 500 >= 250) : digitalWrite(CounterLed, HIGH); // LED blinkt wenn Reedrelais geschlossen
}
void speichern() {
File f = SPIFFS.open("/value.txt", "w");
f.printf("%li\n", value);
f.close();
}
In diesem Tab, deine Zugangsdaten vom Netzwerk eintragen.
Connect.ino
// ****************************************************************
// Sketch Esp8266 Connect Modular(Tab) mit optischer Anzeige
// created: Jens Fleischer, 2018-04-08
// last mod: Jens Fleischer, 2019-04-14
// For more information visit: https://fipsok.de
// ****************************************************************
// Hardware: Esp8266
// Software: Esp8266 Arduino Core 2.4.2 / 2.5.2 / 2.6.3 / 2.7.4
// Getestet auf: Nodemcu, Wemos D1 Mini Pro, Sonoff Dual
/******************************************************************
Copyright (c) 2018 Jens Fleischer. All rights reserved.
This file is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
*******************************************************************/
// Diese Version von Connect sollte als Tab eingebunden werden.
// #include <ESP8266WebServer.h> oder #include <ESP8266WiFi.h> muss im Haupttab aufgerufen werden
// Die Funktion "Connect();" muss im Setup eingebunden werden.
/**************************************************************************************/
//#define CONFIG // Einkommentieren wenn der ESP dem Router die IP mitteilen soll.
#define NO_SLEEP // Auskommentieren wenn der Nodemcu den deep sleep Modus nutzt.
const char* ssid = "Netzwerkname"; // << kann bis zu 32 Zeichen haben
const char* password = "PasswortvomNetzwerk"; // << mindestens 8 Zeichen jedoch nicht länger als 64 Zeichen
#ifdef CONFIG
IPAddress staticIP(192, 168, 178, 99); // statische IP des NodeMCU ESP8266
IPAddress gateway(192, 168, 178, 1); // IP-Adresse des Router
IPAddress subnet(255, 255, 255, 0); // Subnetzmaske des Netzwerkes
IPAddress dns(192, 168, 178, 1); // DNS Server
#endif
void Connect() { // Funktionsaufruf "Connect();" muss im Setup eingebunden werden
byte i = 0;
//WiFi.disconnect(); // nur erforderlich wenn Esp den AP Modus nicht verlassen will
WiFi.persistent(false); // auskommentieren wenn Netzwerkname oder Passwort in den Flash geschrieben werden sollen
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
#ifdef CONFIG
WiFi.config(staticIP, gateway, subnet, dns);
#endif
while (WiFi.status() != WL_CONNECTED) {
#ifdef NO_SLEEP
pinMode(LED_BUILTIN, OUTPUT); // OnBoardLed Nodemcu, Wemos D1 Mini Pro
digitalWrite(LED_BUILTIN, 0);
#endif
delay(500);
digitalWrite(LED_BUILTIN, 1);
delay(500);
Serial.printf(" %d sek\n", ++i);
if (i > 9) {
Serial.print("\nVerbindung zum AP fehlgeschlagen !\n\n");
ESP.restart();
}
}
Serial.println("\nVerbunden mit: " + WiFi.SSID());
Serial.println("Esp8266 IP: " + WiFi.localIP().toString());
}
HTML.ino
// ****************************************************************
// Sketch Gaszähler Webinterface Modular(Tab)
// created: Jens Fleischer, 2018-04-08
// last mod: Jens Fleischer, 2021-08-28
// For more information visit: https://fipsok.de
// ****************************************************************
// Hardware: Esp8266
// Software: Esp8266 Arduino Core 2.4.2 / 2.5.2 / 2.6.3 / 2.7.4
// Getestet auf: Nodemcu
/******************************************************************
Copyright (c) 2018 Jens Fleischer. All rights reserved.
This file is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
*******************************************************************/
void homepage() { // Funktionsaufruf "homepage();" muss im Setup eingebunden werden
server.on("/", handleRoot);
server.on("/detail", handledetail);
server.on("/ledh", []() {
ledh = !ledh;
handledetail();
});
server.on("/ledz", []() {
ledz = !ledz;
handledetail();
});
}
void handledetail() {
if (server.arg(0).length() > 0 && server.arg(0).length() <= 7) {
value = server.arg(0).toInt();
speichern(); // Benutzer Eingabe in der Datei speichern
Serial.printf("Zählerstand vom Client: %ld\n", value);
}
char buf[43];
snprintf(buf, sizeof(buf), "[\"%05ld,%02ld9 m³\",\"%d\",\"%d\",\"%s\"]", value / 100, value % 100, ledh, ledz, Fehlerzeit().c_str());
server.send(200, "application/json", buf); // Zählerstand und Led Status an Html Seite senden
}
String Fehlerzeit() { // ermittelt die vergangene Zeit seit dem letztem Verbindungsfehler zu Thingspeak
if (fehlerZeit > 0) {
String Time = "";
uint8_t mm = (millis() / 1000 - fehlerZeit) / 60 % 60;
uint16_t hh = ((millis() / 1000 - fehlerZeit) / 60) / 60;
if (hh > 240) fehlerZeit = 0; // nach 10 Tagen ohne Fehler, wird die Fehleranzeige zurückgesetzt
if (hh < 10)Time += "0";
Time += (String)hh + ":";
if (mm < 10)Time += "0";
Time += (String)mm;
return Time;
}
return "0";
}
void handleRoot() { // Html Webseite, der Zählerstand wird aller 5 Sekunden mittels fetch.api aktuallisiert
String temp = "<!DOCTYPE HTML><html lang='de'><head><meta charset='UTF-8'><meta name='viewport' content='width=device-width, initial-scale=1.0,'><title>Gaszähler</title><script>";
temp += "window.addEventListener('load',function(){document.querySelector('#grey').addEventListener('click',function(){e()});document.querySelector('#ledz').addEventListener";
temp += "('click',function(){d('ledz')});document.querySelector('#ledh').addEventListener('click',function(){d('ledh')});document.querySelector('input').addEventListener('blur',";
temp += "function(){b(inObj=document.querySelector('input'))});var c=document.querySelector('#note');function b(f){!f.checkValidity()?(c.innerHTML=f.validationMessage,";
temp += "c.classList.add('note')):d('detail',inObj.value)};var a;function e(){document.getElementById('no').style.display=a?'none':'flex';a=!a;c.innerHTML='';";
temp += "c.classList.remove('note');document.querySelector('form').reset()}function d(g,f){if(Number.isInteger(parseInt(f))){e()}fetch(g,{method:'POST',body:f})";
temp += ".then(function(h){return h.json()}).then(function(j){document.querySelector('#wert').innerHTML=j[0];var h=document.querySelector('#ledh');var i=document.querySelector";
temp += "('#ledz');if(j[1]=='0'){h.innerHTML='LED On',h.classList.remove('buttonon')}else{h.innerHTML='LED Off',h.classList.add('buttonon')}if(j[2]=='0'){i.innerHTML=";
temp += "'LED On',i.classList.remove('buttonon')}else{i.innerHTML='LED Off',i.classList.add('buttonon')}if(j[3]!='0')document.querySelector('#led').innerHTML='Sendefehler vor '";
temp += "+j[3]+' hh:mm';})}document.addEventListener('DOMContentLoaded',d('detail'));setInterval(d,5000,'detail')});</script><style>body{background-color:tan;display:flex;";
temp += "flex-flow:column;align-items:center;padding:10px;font-size:18px}#grey,#no{display:flex;flex-flow:column;align-items:center;background-color:#c5c3c3;width:280px;";
temp += "height:150px;border:.3em solid #aeaeab;box-shadow:5px 10px 5px rgba(0,0,0,0.7);border-radius:.5em}#black{background-color:black;width:14em;height:2em;";
temp += "border-radius:.2em}#red{border:.27em solid red;position:relative;width:3.7em;height:1.5em;left:6.4em}#wert{color:white;position:relative;top:-2.2em;left:.1em;";
temp += "letter-spacing:.2em;font-size:1.6em;font-weight:bold}#no{display:none}.note{background-color:#fecdee;padding:.3em;margin-top:1.5em;text-align:center;max-width:17em;";
temp += "border-radius:.5em;position:relative;top:-13.3em}input,#led{height:30px;margin-top:1em}.button{background-color:#75a27e;height:40px;width:120px;font-size:16px;";
temp += "box-shadow:5px 5px 5px rgba(0,0,0,0.7)}.buttonon{background-color:#cf848c}</style></head><body class='flexg'> <div id ='grey'><h1>Zählerstand</h1><div id='black'>";
temp += "<div id='red'></div></div></div><span id='wert'></span><div id ='no'><form><input placeholder=' Zählerstand eingeben' pattern='[0-9]{1,7}' title='Nur 1 bis";
temp += " 7 Ziffern sind erlaubt' required></form><div id='led'> Zähler - Led - Heartbeat</div><div><button id='ledz' class='button'>LED On/Off</button> <button id='ledh' ";
temp += "class='button'>LED On/Off</button></div></div><div id='note'></div></body></html>";
server.send(200, "text/html", temp);
}
Thingspeak.ino
// ****************************************************************
// Sketch Thingspeak Modular(Tab) (Antwort nicht blockierend)
// created: Jens Fleischer, 2018-04-08
// last mod: Jens Fleischer, 2018-05-05
// For more information visit: https://fipsok.de
// ****************************************************************
// Software: Esp8266 Arduino Core 2.4.2 / 2.5.2 / 2.6.3 / 2.7.4
// Getestet auf: Nodemcu
/******************************************************************
Copyright (c) 2018 Jens Fleischer. All rights reserved.
This file is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
*******************************************************************/
WiFiClient client;
bool thingspeak(const char* value) { // Funktionsaufruf "thingspeak();" muss in loop eingebunden sein
static bool error = false, response = true;
const uint16_t httpPort = 80;
const char* host = "184.106.153.149";
const char* APIKEY = {"Geheimer ApiKey"}; // trage deinen ApiKey von https://thingspeak.com
const unsigned long interval = 1000UL * 300; // Interval in Sekunden einstellen
static unsigned long letzteMillis = 0 - interval / 2; // Sendebeginn einstellen ("- interval" = sofort, "0" = nach Ablauf von Interval)
const uint16_t timeout = 2000; // Zeitraum für Fehlerrückgabe in Millisekunden einstellen
const String path = (String)"&field1=" + value + "&field2=" + value; // "field1 bis 8" anpassen
/*************** Thinkspeak senden *********************/
unsigned long aktuelleMillis = millis();
if (aktuelleMillis - letzteMillis >= interval || error) { // senden im Interval und erneut im Fehlerfall
error = false;
letzteMillis = aktuelleMillis;
if (!client.connect(host, httpPort)) {
Serial.println("Thingspeak Verbindung fehlgeschlagen !");
error = true;
return false;
}
else {
client.printf("POST /update?key=%s%s HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n\r\n", APIKEY, path.c_str(), host);
response = 0;
return true;
}
}
/************** Thinkspeak auf Anwort prüfen *****************/
if (!response) {
if (millis() - letzteMillis > timeout) {
Serial.println("Thingspeak Client Timeout !");
error = true;
return false;
}
if (client.available()) { // einlesen der Antwort
//Serial.printf("Thingspeak Antwort nach: %4ld ms\n", millis() - letzteMillis); // zeigt die Zeit bis zur Antwort --> passe den Timeout entsprechend an
String line = client.readStringUntil('\n');
if (line.startsWith("HTTP/1.1 200 OK")) { // wenn Antwort mit "HTTP/1.1 200 OK" beginnt war das Senden erfolgreich
client.stop();
response = true;
}
}
}
return true;
}
Cooles Projekt!
Habe mir einige Bestandteile daraus gemopst und in meins übernommen, da ich noch einen Zwischenchache benötige wenn kein WLAN da ist und das Ganze in eine InfluxDB schiebe und nicht nach ThinkSpeak.
Läuft bestens, nur in einem Punkt bin ich mir unsicher.
Wenn aus welchen Gründen auch immer meine InfluxDB nicht erreichbar ist, dauert es einige Sekunden bis HTTP abbricht und nen Fehler auswirft.
Wenn ich das korrekt sehe fängst Du das mit einem 2Sekunden Timeout ab in Deiner Thinkspeak.ino?
Aber in 2 Sekunden kann ja der Magnet vom Zähler am Reed vorbeigeflitzt sein, ohne das dies abgefragt wurde, oder übersehe ich da was?
Gruß
Stefan
Antwort:
So schnell läuft er bei mir nicht!
Sollte es bei dir zu knapp werden, ruf doch die Funktion "zaehlerauslesen()" zwischendurch auf.
Gruß Fips
'esp_delay' was not declared in this scope
'esp_suspend' was not declared in this scope
Antwort:
Mit welcher EspCoreVersion erhälst du den Fehler?
Gruß Fips
Danke, tolle Sache, vor allem mit dem Zwischenspeicher im ESP. Das ist ein Problem bei vielen anderen Lösungen. Allerdings wäre mir eine Datenübertragung z.B. per MQTT ins eigene Smart Home lieber. Das ist nicht zufällig angedacht?
Viele Grüße, Dieter
Antwort:
Bisher habe ich noch nie was mit MQTT gemacht, will aber nicht ausschließen zukünftig damit zu spielen.
Gruß Fips
es ist wirklich erstaunlich: Sketch geladen, ein paar Sekunden warten, und es funktioniert!
Alle Achtung, was du da programmiert hast!
Vielen Dank!
Antwort:
Freut mich, zu hören das es für dich unkompliziert war!
Gruß Fips
Würde mich interessieren.
Jürgen
Antwort:
Nicht das ich wüsste.
Gruß Fips
Da ich den Strom mit einer Brennstoffzelle herstelle würde ich den Gasverbrauch da gerne mit einfließen lassen.
Da ich den da genutzten vzlogger nicht für ESP gefunden habe hatte ich überlegt ob man das hier umbauen könnte um in den volkszaehler zu comitten?
Hat sowas schon wer versucht?
Habs erst beim zweiten lesen bemerkt das du den Gaszähler als Wasserzähler nutzen willst.
Schick mir doch bitte eine Mail über das Kontaktformular welcher Impulszähler sich eignet.
Das lässt sich anpassen, ich guck mir das die Tage mal an.
Danke für die nachricht. Mein Wasserzähler hat einen Internen Pulsgeber. DerImpuls kommt nach jedem Litter.
Also 0.001
Antwort:
Sowas modernes habe ich nicht!
Für 0.001 müssen zwei Zeilen geändert werden.
Gaszaehler.ino
Zeile 71 -> snprintf(buf, sizeof(buf), "%li.%03li", value / 100, value % 100);
HTML.ino
Zeile 43 -> snprintf(buf, sizeof(buf), "[\"%05ld,%03ld m³\",\"%d\",\"%d\",\"%s\"]", value / 1000, value % 1000, ledh, ledz, Fehlerzeit().c_str());
Gruß Fips
Das mit dem Wasserzähler(welcher Impulsgeber kann verwendet werden) würde mich auch interessieren. Kann man das hier einfach reinwerfen, was hier verwendet wird?
Danke
Konrad
Antwort:
Mal sehen ob sich "Kass" noch meldet.
Gruß Fips
1. Reed Schalter gekauft.
2. ESP8266 dran gehängt.
3. Gecheckt wo am Gaszähler der Kontakt zustande kommt.
4. Verkabelt und drangeklebt.
5. Sketche draufgeladen (ohne Thingspeak!, externe Speicher sind mir einfach zu suspekt - zumindest vorerst)
--> Läuft!
6. Sketch angepasst, dass eine separate Datei mit den Aufzeichnungen nach meinen Wünschen per txt auf LittleFS läuft. (Hat ein bischen gedauert, bis ich auf die Lösung gekommen bin) PASST PERFEKT.
Vielen, vielen Dank an Dich fipsok.
Ich habe bei meiner Gasheizung inzwischen schon die ein oder andere Überraschung beim prüfen der Daten erlebt und werde dadurch den Verbrauch sicher senken können.
Ein ziemlich happy
Konrad
Antwort:
Danke für dein Feedback.
Gruß Fips
Verbrauch richtig zählt. Jetzt wird nach jedem Impuls die Zehnlitter weiter geschrieben allso 0,010
Gruß Kass
Antwort:
Na das ist ja eine coole Idee!
Habs erst beim zweiten lesen bemerkt das du den Gaszähler als Wasserzähler nutzen willst.
Schick mir doch bitte eine Mail über das Kontaktformular welcher Impulszähler sich eignet.
Das lässt sich anpassen, ich guck mir das die Tage mal an.
Gruß Fips