Der Sketch zum Gasuhr auslesen übersichtlich aufgeteilt in Tabs.

// ****************************************************************
// Sketch Gaszähler Modular(Tab)
// created: Jens Fleischer, 2018-03-30
// last mod: Jens Fleischer, 2019-12-08
// 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.2
// 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.
*******************************************************************/

#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[9];
  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.

// ****************************************************************
// 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.0 / 2.5.2 / 2.6.2
// 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());
}

// ****************************************************************
// Sketch Gaszähler Webinterface Modular(Tab)
// created: Jens Fleischer, 2018-04-08
// last mod: Jens Fleischer, 2019-10-03
// For more information visit: https://fipsok.de
// ****************************************************************
// Hardware: Esp8266
// Software: Esp8266 Arduino Core 2.4.2 / 2.5.2 / 2.6.2
// 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[39];
  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);
}

// ****************************************************************
// 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.2
// 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;
}