Durch Zufall bin ich auf ein interessantes Projekt gestoßen, das mir endlich meinen Wunsch erfüllt, meinen bestehenden Wasserzähler auszulesen. Den Wert des Wasserzählers würde ich gern aus folgenden Gründen erfassen:

Besseres Verständnis des eigenen Wasserkonsums und damit mehr Bewusstsein
Erkennung von Defekten und damit Schadensprävention durch rechtzeitiges Abdrehen des Wassers.

Seit Release 2022.11 kann man den Verbrauch auch im Energie-Dashboard in Home Assistant erfassen. Weitere Informationen findest du dazu hier: Wasserverbrauch im Energie Dashboard.

Möglich wird dies durch ein Projekt von JomJol, der es geschafft hat eine kleine AI auf einem ESP32 laufen zu lassen, die gängige Wasserzähler anhand eines Fotos auswerten kann. Nach etwas Tüftelei funktioniert dies bei meinem Elster Wasserzähler gut.

Die Daten sende ich via MQTT an mein Homeassistant und errechne mir dort meinen Wasserverbrauch für den heutigen Tag.

Benötigte Hardcare: Eine Kombi aus . Kostet rund 13 bis 15 Euro mit Versand aus Deutschland.

Auf dieses kleine Stück Hardware muss anschließend die Firmware geflasht werden. Wie das geht, ergänze ich die Tage.

Zum Projekt: https://github.com/jomjol/AI-on-the-edge-device

Adapter für Elster Wasserzähler

Leider haben alle 3d gedruckten Adapter auf meiner Elster Wasseruhr nicht gut funktioniert. Daher habe ich mich daran versucht, ein entsprechendes 3D Modell zu entwerfen und zu drucken. Inzwischen habe ich eine Version, die gut funktioniert und optisch okay aussieht.

Das Modell ist noch nicht ganz fertig, aber fast. Wenn ich damit fertig bin, werde ich es auf Thingiverse einstellen. Inzwischen ist die Datei auch auf Thingiverse: https://www.thingiverse.com/thing:5674591

Falls du keinen 3D-Drucker zu Hand hast, gern bei mir melden

Letzte Sache, die noch zu tun ist, einen abnehmbaren Deckel zu entwerfen, damit der Fokus der Kamera besser einstellbar ist. Desertieren wollte ich testen, ob man mit einem kleinen Reflektor das Problem der Reflexion umgehen kann.

Flashvorgang – wie Ai on the Edge auf ESPCAM installiert wird

1. Release downloaden und entpacken
2. Firmware auf ESP32 Cam Flaschen
3. SD-Karte mit den Datensätzen für die AI beschreiben
4. WLAN Config auf SD-Karte schreiben
5. Positionieren und Referenzbild + auszulesende Positionen konfigurieren

Wenn du Python auf deinem System installiert hast, ist der Vorgang sehr einfach und schnell. Das funktioniert auf Mac und Windows.

pip 3 install esptool

Esptool flash etc

Alternativ gibt es für Windows noch ein Flash Tool. Den kompletten Vorgang, wie es dann zu handhaben ist, kannst du im offiziellen Wiki finden.

Konfiguration

Hat alles geklappt, dann solltest du dein Wasser-Zähler-Ausles-Gerät 😀 nun irgendwo im Netzwerk finden. Das findest du entweder in deinem Router, in einer Netzwerk-Scan-Anwendung oder du hast eine statische IP vergeben und weißt, wie du es aufrufen kannst.

Durch Aufrufen der IP in dem Browser deiner Wahl, kannst du die Cam konfigurieren. Der Startbildschirm sollte in etwa so aussehen:

Basisbild ausrichten und Regions of Interests makieren

Zu Beginn solltest du kontrollieren, ob dein Bild scharf ist und alle Messwerte vorhanden sind. Fehlt etwas oder sind die Messwerte nicht scharf, dann musst du die Kamera noch etwas feinjustieren in der Position.

Ist das Bild unscharf, dann kannst du über die drehbare Linse (Achtung verklebt! Den sichtbaren Kleber kann man mit einem Messer entfernen) den Fokus einstellen. Hier ist leider ausprobieren das einzige Hilfsmittel. Halbe Runde drehen, neues Foto machen, vergleichen, wiederholen.

Passt jetzt alles, können 2 Align Marks gesetzt werden. Diese dienen dazu, das Bild richtig zu drehen / zu positionieren, damit die AI auch richtig arbeiten kann.
Dazu klicke auf Align Marks und markiere Bereiche, die am Wasserzähler prägnant, gleichbleibend sind. Also keine Wertanzeigen oder runde Punkte, sondern eher Firmennamen, Seriennummern oder Ähnliches.

Wenn das gesetzt ist, musst du noch die ROIs (Regions of interest) setzen. Das sind die eigentlichen Zähler-Werte. Im Konfigrationsmodus oben auf Regions of Interests klicken. Die Konfiguration ist ähnlich wie bei den Align Marks.

Jetzt nacheinander alle digitalen Zahlen von links nach rechts anlegen. Bei meinem Set-up funktionieren etwas größere Rahmen besser als kleine. Hierbei ist aber etwas probieren notwendig.

Nachdem alle digitalen angelegt sind, gilt es noch die analogen Zählelemente anzulegen. Die Vorgehensweise ist hier wieder identisch.

Danach kannst du auf der Startseite prüfen, ob dein Zähler korrekt ausgelesen wird. Feintuning der einzelnen Parameter kann helfen, wenn du keine perfekten Resultate bekommst.

Bei mir tauchen immer noch falsch erkannte Werte auf, die durch das Filtering dann aber nicht gesendet werden. Mit diesen kann ich gut leben.

Empfohlene Einstellungen

Folgende Einstellungen habe ich gemacht, damit ich zuverlässige Ergebnisse bekomme. Viele Einstellungen sind nur sichtbar wenn der EXPERT MODE oben rechts aktiviert wird.

Als Model zur Zeichenerkennung verwende ich „dig-class-11-1411-sq-q“ für meinen Elster Wasserzähler. Damit habe ich die beste Trefferquote.

Um Reflektionen zu vermieden habe ich den Wert bei LEDIntensityauf 15 gestellt.

PreValueUse habe ich aktiviert, damit wird immer ein vergleich zur vorherigen Value gezogen. Ist AllowNegativeRates deaktiviert, so sind negative Veränderungen zum vorherigen Wert nicht möglich.

Um große Sprünge bei eventueller Falscherkennung zu vermeiden, habe ich MaxRateValue auf 10 und MaxRateType auf RateChange gesetzt.

Wasserzähler mit Smart Home verbinden

Wenn jetzt alles passt, kann der Zähler in dein Smart Home verbunden werden. 
Dafür stehen dir drei Möglichkeiten zur Verfügung. 


1. ESPCam sendet via MQTT Richtung deines Mqtt Brokers und kann in deiner Zentrale verarbeitet werden
2. Die Smart Home Zentrale liest die REST-API aus
3. ESPCam schreibt in eine InfluxDB und du verwendest die Werte aus dieser Datenbank in deiner Smart Home Zentrale

In den meisten Fällen wird sicher MQTT verwendet. Dazu gehe wieder in die Konfiguration und dort auf „edit configuration“.

Weiter unten gibt es einen Bereich für MQTT, hier aktiviere vorn die Checkbox. Jetzt kannst du die Werte deines Brokers angeben.

Uri: mqtt://deine-broker-Adresse:1883
MainTopic: dein gewählter Name für den Wasserzähler
UserName: …
Passwort: …

Mit dieser minimal Konfiguration bist du bei Homeassistant mit dem Mosquitto Broker schon sende-bereit und die ersten Werte sollten auftauchen.

Um das zu prüfen, kann man mit einem MQTT Client sich ebenso auf den Broker connecten. Hier sollte, wenn AI on the Edge einen gültigen Zählerstand extrahiert hat, nach kurzer Zeit ein Wert für dein gewähltes Topic auftauchen.

Zusammenfassung

Insgesamt ein super Projekt von JomJol. Ich finde es beeindruckend was inzwischen auf einem ESP verarbeitet werden kann und welche Einsatzzwecke sich für solche Mini-KIs in Zukunft noch ergeben können.

Vor allem freut es mich aber, dass ich endlich auch etwas über meinen Wasserverbrauch erfahre. Jetzt sind Wassermengen für Badewanne, Blumen gießen, Spülmaschine in Litern pro Tag greifbarer als einmal pro Jahr eine Abrechnung zu bekommen über sein verbrauchtes Wasser.

Was ich unterschätzt habe ist der Zeitaufwand. Bis ich die Position, den Fokus, etc. richtig hatte, ist mehr Zeit vergangen als ich angenommen hätte.

Der Beitrag Wasserzähler mit EspCAM auslesen erschien zuerst auf Smartebude.

Ein Windsensor für meine Haussteuerung steht schon lange auf meiner ToDo Liste. Diesen brauche ich vor allem als Sicherheitsfunktion für die automatische Steuerung der Raffstores – und aus Datensammelwut.

Als Basis habe ich mir einen Ventus Ersatzsensor entkernt und dort einen ESP8266 + Arduino Mini Pro 3,3V untergebracht.

Die Komponenten

Folgende Komponenten habe ich verbaut:

• Ventus Ersatzwindmesser (link) ca. 23 € bei Reichelt .de
• Arduino Pro 3,3V 8Mhz (link) ca. 4 € bei Amazon.de
• Wemos D1 Mini (link) ca. 5 € bei Amazon.de
• 3 Volt Solarzelle (link) für 8 € bei Amazon.de
• 100k Widerstand zur Spannungsmessung

Macht insgesamt ca. 40 € für einen smarten Windsensor mit Batteriebetrieb. Deutlich Billiger als alle Modelle die auf dem Markt sind und auch etwas besser zu befestigen als die Stab-Bauweise von Homematic.

Warum 2 Boards?
Für die Akkulaufzeit – den ESP8266 kann ich nicht mit einem externen Interrupt wecken ohne einen vollen Reboot zur durchlaufen. Der Arduino kann jedoch an 2 Interrupt Pins geweckt werden und anschließend wieder schlafen, ohne einen Reboot zu durchlaufen.

Der Ablauf ist eigentlich recht einfach, der Arduino zählt an PIN 2 alle Umdrehung des Windsensors und lauscht auf PIN3 ob ein Low vom Wemos gesetzt wird. Kommt das Signal auf PIN3 erfolgt eine Serielle Ausgabe des Aktuellen Windcounters.

Der Wemos Rebootet alle 30 Sekunden neu, liest den Serial Input und sendet ggf. Daten via MQTT an IObroker. Ansonsten sind beide Geräte im Deep Sleep und verbrauchen nur Minimal Strom.

Der Ablauf nochmal grafisch dargestellt:

Aktuell läuft das ganze noch im Testbetrieb, um zu sehen, wie sich die Batterielaufzeit verhält. Um möglichst lange Betriebszeiten zu erreichen werden 2 NiMH Akkus durch eine 3V Solarzelle geladen – ohne Laderegler. Den Laderegler halte ich für überflüssig, da NiMH Zellen ein überladen mit geringer Stärke gut verkraften. Ich habe die Akkus vorher einem Kapazitätstest unterzogen und werde im Frühjahr einen weiteren Test mache.

Code Arduino Pro mini

#include <LowPower.h>


#define WIND_INTERRUPT 0
#define ESP_INTERRUPT 1
#define WIND_INTERRUPT_PIN 3
#define ESP_INTERRUPT_PIN 2


volatile int pulses = 0;
volatile long last_interrupt_time = 0;
volatile int sendcheck = false;


void pulse() {

  unsigned long interrupt_time = millis();

  // If interrupts come faster than 200ms, assume it's a bounce and ignore
  if (interrupt_time - last_interrupt_time > 10)
  {
    ++pulses;

  }
  last_interrupt_time = interrupt_time;
}


void ESP_awake() {
  sendcheck = true;
}


void sendWind() {

  int temppulse = pulses;

  delay(200);
  Serial.println("-");
  Serial.print("pulses:");
  Serial.println(temppulse);

  // gesendete vom Global Counter abziehen
  pulses -= temppulse;

}

void setup() {
  pinMode(WIND_INTERRUPT_PIN, INPUT_PULLUP);
  pinMode(ESP_INTERRUPT_PIN, INPUT);

  Serial.begin(9600);

  attachInterrupt(digitalPinToInterrupt(WIND_INTERRUPT_PIN), pulse, RISING);
  attachInterrupt(digitalPinToInterrupt(ESP_INTERRUPT_PIN), ESP_awake, FALLING);

}


void loop() {

  delay(100);
  LowPower.powerDown(SLEEP_FOREVER, ADC_OFF, BOD_OFF);


  // Wake up ab hier
  if (sendcheck) {
    sendcheck = false;
    sendWind();
  }
}

Code Wemos / Esp8266

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <PubSubClient.h>
#include <RTCVars.h>
RTCVars state; // create the state object

int reset_counter;
int program_step;
int sumwindcount;

unsigned int raw = 0;
float volt = 0.0;

WiFiClient espClient;
PubSubClient client(espClient);


const char* ssid = "****";
const char* password = "****";

const char* mqttServer = "192.168.****";
const int   mqttPort = 1886;
const char* mqttUser = "*****";
const char* mqttPassword = "*****";


int sleepTimeS = 30;
volatile unsigned long ContactBounceTime; // Timer to avoid contact bounce in interrupt routine


void setup() {
  Serial.begin(9600);

  state.registerVar( &reset_counter );
  state.registerVar( &sumwindcount );

  if (state.loadFromRTC()) {
    reset_counter++;
  } else {
    reset_counter = 0;
    sumwindcount = 0;
    program_step = 0;
  }

  // Pin 4 Aktivieren / Deaktiveren >> Signal für Arudino Interrupt
  pinMode(4, OUTPUT);
  digitalWrite(4, HIGH);
  delay(500);
  digitalWrite(4, LOW);

}


String getValue(String data, char separator, int index)
{
  int found = 0;
  int strIndex[] = { 0, -1 };
  int maxIndex = data.length() - 1;

  for (int i = 0; i <= maxIndex && found <= index; i++) {
    if (data.charAt(i) == separator || i == maxIndex) {
      found++;
      strIndex[0] = strIndex[1] + 1;
      strIndex[1] = (i == maxIndex) ? i + 1 : i;
    }
  }
  return found > index ? data.substring(strIndex[0], strIndex[1]) : "";
}



void senddata(int windspeed, int boe, float battery) {

  WiFi.begin(ssid, password);
  byte wifiCNT = 0;
  byte mqttCNT = 0;


  while (WiFi.status() != WL_CONNECTED  && wifiCNT < 10) {
    delay(500);
    wifiCNT++;
    Serial.println("Connecting to WiFi..");
  }

  Serial.println("Connected to the WiFi network");


  client.setServer(mqttServer, mqttPort);
  while (!client.connected() && mqttCNT < 10) {
    mqttCNT++;
    Serial.println("Connecting to MQTT...");
    if (client.connect("windsensor", mqttUser, mqttPassword )) {
      Serial.println("connected");
    } else {
      Serial.print("failed with state ");
      Serial.print(client.state());
      delay(200);

    }
  }


  if (windspeed != -1) {
    boolean rc = client.publish("windsensor/windspeed", String(windspeed).c_str());
  }

  if (battery != -1) {
    client.publish("windsensor/battery", String(battery).c_str());
  }
  if (boe != -1) {
    client.publish("windsensor/boe", String(boe).c_str());

  }

  delay(100);
}
void loop() {
  Serial.begin(9600);

  delay(100);
  String a;
  int aktwindcount = -1;

  while (Serial.available()) {
    Serial.println("wait for data");
    a = Serial.readString(); // read the incoming data as
    Serial.println(a);
    if (a.indexOf("pulses") > 0) {
      a.replace("\n", "");
      a.replace("⸮-", "");
      a = getValue(a, ':', 1);

      Serial.println(a);
      aktwindcount = a.toInt();
      break;
    }

    delay(100);

  }


  if (aktwindcount > 150) {
    senddata(-1, aktwindcount, -1);
  }

  // summe windcount erhöhen
  sumwindcount =  aktwindcount + sumwindcount;

  // aller 12 durchgänge senden oder wenn starker wind
  if (reset_counter >= 12) {
    int raw = analogRead(A0);
    int windavg = sumwindcount / reset_counter;
    volt = raw / 1023.0;
    volt = volt * 4.2;


    senddata(windavg, -1, volt);
    reset_counter = 0;
    sumwindcount = 0;

  }

  state.saveToRTC();
  delay(100);
  ESP.deepSleep(29e6); // 20e6 is 20 microseconds


}

Der Beitrag DIY Windsensor mit MQTT mit Esp8266 für IObroker erschien zuerst auf Smartebude.