Qalcosonic W1 mit ESPHome und NFC in Home Assistant auslesen

Mein Wasserzähler ist wahrscheinlich eines der besten Beispiele dafür, warum ich Smart Home überhaupt interessant finde.

Ich möchte nicht einfach möglichst viele Geräte miteinander vernetzen. Ich möchte Daten bekommen, mit denen ich tatsächlich etwas anfangen kann.

Wie viel Wasser verbrauchen wir eigentlich im Jahr? Was davon geht im Sommer in den Garten? Was kostet eine ausgiebige Dusche? Und verändert sich unser Verbrauch über die Jahre?

Also wollte ich unseren Wasserzähler in Home Assistant integrieren.

Was zunächst nach einem kleinen Projekt klingt, hat bei mir allerdings zwei Anläufe gebraucht.

Der erste Versuch bestand aus einer Kamera und Bilderkennung. Heute lese ich unseren Qalcosonic W1 dagegen direkt über NFC aus – mit einem PN5180, einem ESP32 und ESPHome.

Das Ergebnis ist eine deutlich zuverlässigere Lösung – und ein Wasserzähler, dessen Daten ich direkt in Home Assistant auswerten kann.

Mein erster Versuch: ESP32-CAM und ein analoger Wasserzähler

Unser alter Wasserzähler war noch analog.

Meine erste Lösung bestand deshalb aus einem ESP32-CAM-Modul. Eine kleine Kamera fotografierte den Zähler und der Zählerstand wurde anschließend automatisch aus dem Bild ausgelesen.

Theoretisch ziemlich genial.

In der Praxis bei mir leider weniger.

Der Wasserzähler sitzt in einer Umgebung, in der Feuchtigkeit ein Thema ist. Das Glas beschlug beziehungsweise lief an – und ausgerechnet die wichtigste Voraussetzung für die Bilderkennung war damit nicht zuverlässig gegeben:

ein vernünftiges Bild.

Link zum ursprünglichen Projekt: Link

Mal funktionierte die Erkennung, mal nicht. Dann musste wieder nachjustiert oder kontrolliert werden.

Für eine Spielerei wäre das okay gewesen.

Für einen Sensor, dessen eigentlicher Zweck darin besteht, vollkommen unauffällig im Hintergrund Daten zu sammeln, war es mir irgendwann schlicht zu viel Frust.

Ich wollte schließlich nicht regelmäßig überprüfen, ob meine automatische Wasserzählerablesung gerade automatisch funktioniert.

Dann wurde der Wasserzähler digital

Irgendwann wurde unser alter analoger Wasserzähler gegen einen digitalen Axioma Qalcosonic W1 ausgetauscht.

Damit war mein ESP32-CAM-Projekt zunächst erledigt.

Gleichzeitig stellte sich für mich sofort eine neue Frage:

Wenn der Qalcosonic W1 ohnehin ein digitaler Wasserzähler ist – muss es dann nicht eine bessere Möglichkeit geben, an die Daten zu kommen?

Also fing ich wieder an zu suchen.

Dabei bin ich auf eine für meinen Anwendungsfall wesentlich elegantere Lösung gestoßen:

Der Qalcosonic W1 lässt sich über NFC auslesen.

Keine Kamera. Keine Bilderkennung. Kein beschlagenes Glas.

Stattdessen liest ein PN5180 NFC-Modul die Daten des Wasserzählers aus und übergibt sie über einen ESP32 und ESPHome an Home Assistant.

Das war ziemlich genau die Lösung, nach der ich ursprünglich gesucht hatte.

Der Aufbau: Qalcosonic W1, PN5180 und ESP32

Das Grundprinzip ist ziemlich übersichtlich:

Qalcosonic W1 → PN5180 → ESP32 → ESPHome → Home Assistant

Für meinen Sensor verwende ich:

• ESP32-WROOM-32 DevKit
• Elechouse PN5180 NFC/RFID-Reader
• Jumperkabel
• USB C Netzteil

→ Zu den verwendeten Komponenten und Bezugsquellen

Der Qalcosonic W1 war natürlich bereits vorhanden – er wurde bei mir als Wasserzähler installiert.

Mein eigentlicher Eigenbau beginnt also beim PN5180 und ESP32.

Einige Komponenten hatte ich bereits zu Hause, andere habe ich günstig über AliExpress beziehungsweise andere Elektronikhändler gekauft.

Die tatsächlich verwendeten Komponenten und meine Einkaufspreise habe ich weiter unten zusammengestellt.

Die eigentliche Qalcosonic-W1-Integration

Das Protokoll des Wasserzählers musste ich glücklicherweise nicht selbst analysieren.

Bei meiner Recherche bin ich auf das Open-Source-Projekt Link gestoßen.

Dieses Projekt bildet die Grundlage für das Auslesen meines Qalcosonic W1.

Das ist für mich eine der großen Stärken von ESPHome, Home Assistant und Open Source allgemein:

Für viele ziemlich spezielle Probleme hat irgendwo bereits jemand einen erstaunlich großen Teil der Arbeit erledigt und stellt seine Lösung anderen zur Verfügung.

Trotzdem versuche ich bei solchen Projekten zumindest grob zu verstehen, was ich dort eigentlich übernehme, statt einfach irgendeine YAML-Datei zu kopieren und darauf zu hoffen, dass sie funktioniert.

PN5180 mit dem ESP32 verbinden

Der PN5180 wird mit dem ESP32 verbunden und übernimmt anschließend die Kommunikation mit dem Wasserzähler.

Meine tatsächlich verwendete Pinbelegung sieht folgendermaßen aus:

Ich würde hier nicht einfach irgendeine Pinbelegung aus einem anderen Projekt übernehmen. Entscheidend ist die Kombination aus verwendetem ESP32-Board, PN5180 und der dazugehörigen ESPHome-Konfiguration.

Deshalb dokumentiere ich hier genau den Aufbau, der bei mir tatsächlich funktioniert.

ESPHome als Verbindung zu Home Assistant

Auf dem ESP32 läuft ESPHome.

Das ist für mich eine ziemlich angenehme Lösung, weil sich der ESP32 damit direkt in meine bestehende Home-Assistant-Umgebung integrieren lässt.

Nach dem Anlegen des Geräts in ESPHome habe ich die Firmware auf den ESP32 geflasht und anschließend unter anderem WLAN, API-Zugriff und einen Fallback Access Point konfiguriert.

Der Fallback Access Point ist gerade bei einem später fest installierten Gerät praktisch.

Sollte sich der ESP32 irgendwann nicht mehr mit meinem WLAN verbinden können, kann er ein eigenes WLAN bereitstellen, über das ich wieder Zugriff auf das Gerät bekomme.

Meine grundlegende ESPHome-Konfiguration sieht folgendermaßen aus:

Achtung bei Passwörtern und API-Keys

Bevor man seine ESPHome-Konfiguration beispielsweise auf GitHub veröffentlicht oder wie hier in einem Artikel zeigt, sollte man sie unbedingt bereinigen.

WLAN-Passwörter, API-Keys und andere Zugangsdaten gehören nicht in eine öffentlich zugängliche YAML-Datei.

Ich verwende dafür die Secrets-Funktion von ESPHome beziehungsweise ersetze sensible Angaben in veröffentlichten Beispielen durch Platzhalter.

external_components:
  - source:
      type: git
      url: https://github.com/dbmaxpayne/esphome_qalcosonicnfc
      #ref: refs/pull/5/head # Uncomment to test an active pull request 
  #- source:
  #    type: local
  #    path: my_components
    components: [ qalcosonicnfc ]
    #refresh: 1min # Refresh interval. Leave this commented if you're not testing any new pull requests
  

esphome:
  name: qalcosonic-w1-nfc-reader
  friendly_name: Qalcosonic W1 NFC Reader

esp32:
  #board: esp32-c3-devkitm-1
  board: esp32dev
  framework:
    type: esp-idf # You can use arduino, too

button:
  - platform: template
    name: "Force Sensor Update"
    on_press:
      - component.update: qalcosonicnfc_id

qalcosonicnfc:
  id: qalcosonicnfc_id # ID used for the manual update button
  update_interval: 300s # How often should the component query the water meter for a value.
                        # Battery drain:
                        # 60s: ~ 1% per 75 days (added 10.02.2026, tested by dbmaxpayne)
  consecutive_errors_limit: 5 # Optional. Default: 5. How many consecutive failed readout
                              # attempts are allowed before sensors are set to unavailable (NAN).
                              # Set to 0 to never set sensors to unavailable.
  pn5180_mosi_pin: GPIO23
  pn5180_miso_pin: GPIO19
  pn5180_sck_pin:  GPIO18
  pn5180_nss_pin:  GPIO14
  pn5180_busy_pin: GPIO16
  pn5180_rst_pin:  GPIO17
  water_usage_sensor:
    # in m³
    name: "Wasser Verbrauch"
  water_usage_positive_sensor:
    # in m³
    name: "Water usage (only positive)"
    disabled_by_default: True
  water_usage_negative_sensor:
    # in m³
    name: "Water usage (only negative)"
    disabled_by_default: True
  water_flow_sensor:
    # in m³/h
    name: "Wasser Durchfluss"
  water_temperature_sensor:
    # in °C
    name: "Wasser Temperatur"
  external_temperature_sensor:
    # in °C
    # ambient temperature
    name: "External temperature"
  battery_level_sensor:
    name: "Battery level"
  timepoint_sensor:
    name: "Time point"
    timezone: "Europe/Berlin" # optional;
      # if not set, timezone will be inferred from ESPHome's timezone
      # Home Assistant requires a timezone to recognize a timestamp as a propper time and date instead of just text
      # if no timezone can be found, the time point will be emitted a plain text to Home Assistant
    disabled_by_default: True
  timepoint_sensor_raw:
    # shows the time received by the meter as a string without any conversions
    # format is YYYY-MM-DD HH:MM
    # it can be offset by one hour because the meter does not switch to/from DST
    name: "Time point (raw)"
    disabled_by_default: True
  operating_time_sensor:
    # in seconds
    name: "Operating time"
    disabled_by_default: True
  on_time_sensor:
    # in seconds
    name: "On time"
    disabled_by_default: True

  # Meter ID is derived from the M-Bus header and used to identify the meter during bus communication
  # Serial number is a separate data field, that may not always be present, and is used for billing purposes
  # When both are available, they are usually the same
  meter_id_sensor:
    # eight digits as text
    name: "Meter ID"
  serial_number_sensor:
    # eight digits as text
    name: "Serial number"

  manufacturer_id_sensor:
    # three letter manufacturer code
    name: "Manufacturer ID"
  meter_version_sensor:
    # version or revision of the meter
    name: "Meter version"

  # The following binary sensors are generated based on the error flags
  error_reconfiguration_warning:
    # Error digit 1, error code 1
    name: "Reconfiguration Warning"
  error_no_consumption:
    # Error digit 1, error code 2
    # Is set when there was no water usage for the last either 3/7/30 days
    # Not enabled by default
    name: "No consumption"
  error_damage_meter_housing:
    # Error digit 1, error code 4
    # This is the tamper alarm; occurs when meter is opened or damaged
    name: "Damage of meter housing"
  error_calculator_hardware_failure:
    # Error digit 1, error code 8
    name: "Calculator's hardware failure detected"
  error_leakage:
    # Error digit 2, error code 1
    # Is set, if the constant flow is either 0.25%/0.5%/1% (default 1%) of Q₃ (printed on meter) for 24 hours
    # Is unset if the flow is lower than the alarm threshold for one hour
    name: "Leakage"
  error_burst:
    # Error digit 2, error code 2
    # Is set, if the constant flow is either 5%/10%/20% (default 10%) of Q₃ (printed on meter) for one hour
    # Is unset if the flow is lower than the alarm threshold for 32 seconds
    name: "Pipe is cracked (Burst)"
  error_optical_communication:
    # Error digit 2, error code 4
    # Can also be a general communication error for meters with LoRa WAN communication type
    name: "Optical communication temporarily stopped"
  error_low_battery:
    # Error digit 2, error code 8
    name: "Low battery (less than 12 months lifetime left)"
  error_software_failure:
    # Error digit 3, error code 4
    name: "Software failure detected"
  error_hardware_failure:
    # Error digit 3, error code 8
    name: "Hardware failure detected"
  error_no_signal:
    # Error digit 4, error code 1
    # Empty pipe (pipe is not filled with water or air bubbles are detected)
    # Is set, if problem is detected for 30 seconds and is unset if the problem disappears for 30 seconds
    name: "No signal; the flow sensor is not filled with water"
  error_reverse_flow:
    # Error digit 4, error code 2
    # Is set when meter detects negative flow that is equal to 2× of starting flow
    # Is unset if reverse flow is stopped
    name: "Reverse flow"
  error_flow_rate:
    # Error digit 4, error code 4
    # Q₄ is the meter's maximal flow rate
    # Q₄ usually 1.25 times the meter's nominal flow rate (Q₃)
    # Q₃ should be printed on top of the meter
    name: "Flow rate is greater than 1.25×Q₄"
  error_freeze_alert:
    # Error digit 4, error code 8
    # Is set when water temperature is lower than either 2/3/4/5°C (default 5°C) for five minutes
    # Is unset when the temperature is higher than the alarm threshold for five minutes
    name: "Freeze alert"
  # On the meter's LCD, the codes are added as following
  #   3 - corresponds errors 2 + 1
  #   5 - corresponds errors 4 + 1
  #   7 - corresponds errors 4 + 2 + 1
  #   9 - corresponds errors 8 + 1
  #   A - corresponds errors 8 + 2
  #   B - corresponds errors 8 + 2 + 1
  #   C - corresponds errors 8 + 4
  #   D - corresponds errors 8 + 4 + 1
  #   E - corresponds errors 8 + 4 + 2
  #   F - corresponds errors 8 + 4 + 2 + 1

  error_flags_raw:
    # the four error bytes, as hex blocks seperated with space
    # correspond to the four error digits on the display
    # e.g.: "00 00 00 00"
    name: "Error flags raw"
  # This sensor allows me to maybe find more useful data in the future.
  # You should not need it and can disable it.
  raw_data_sensor:
    name: "M-BUS raw data"
    disabled_by_default: True
  # Sensor that indicates how many consecutive readout attempts have failed.
  # It will be 0 on a successful readout and increment on each failure.
  # Note: This value can exceed the consecutive_errors_limit, as the limit
  # only defines when the main sensors are set to unavailable (NAN).
  consecutive_errors_sensor:
    name: "Consecutive Errors"
    disabled_by_default: True

# Enable logging
logger:
  logs:
    # This following can be set to DEBUG to get a lot of information like the raw SPI frames being exchanged between the ESP32 and the PN5180
    qalcosonicnfc: INFO
    PN5180: INFO
    PN5180ISO15693: INFO

# Enable Home Assistant API
api:
  encryption:
    key: "As generated by Home Asisstant when creating the device"

ota:
  - platform: esphome
    password: "As generated by Home Asisstant when creating the device"

# Network / WiFi component is needed for this component to work
wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Qalcosonic-W1-Nfc-Reader"
    password: "ChangeMe"

captive_portal:

Version 1: Hauptsache, es funktioniert

Mein erster NFC-Sensor war vor allem eines:

ein Proof of Concept.

ESP32 und PN5180 mit Jumper-Kabeln verbinden, ESPHome installieren, Firmware flashen, WLAN konfigurieren, das GitHub-Projekt einbinden und anschließend herausfinden:

Kann ich meinen Qalcosonic W1 damit tatsächlich zuverlässig auslesen?

Und irgendwann erschien tatsächlich der Zählerstand in Home Assistant.

Damit war das eigentliche Problem gelöst.

Der Sensor funktionierte.

Schön war der Aufbau allerdings nicht.

Jumper-Kabel, lose Komponenten und ein Aufbau, den ich nicht unbedingt dauerhaft irgendwo montieren wollte.

Im Nachhinein halte ich genau diese Vorgehensweise aber für richtig.

Ich hätte von Anfang an versuchen können, eine schöne Platine zu bauen, Kabel exakt abzulängen und mir Gedanken über ein perfektes Gehäuse zu machen.

Und anschließend feststellen können, dass die eigentliche Idee gar nicht funktioniert.

Deshalb:

Erst beweisen, dass die Technik funktioniert. Danach optimieren.

Vom Versuchsaufbau zum dauerhaft eingebauten Sensor

Nachdem der fliegend verdrahtete Aufbau funktioniert hatte, wollte ich aus dem Experiment einen Sensor machen, den ich dauerhaft am Wasserzähler betreiben kann.

Und damit kam ein Thema zurück, das mich bei meinen bisherigen Elektronikprojekten regelmäßig genervt hatte:

Das Löten.

Mit meiner alten Lötstation hatte ich teilweise selbst bei rund 400 °C Schwierigkeiten, vernünftige Lötstellen hinzubekommen.

Die Spitze war irgendwann schwarz, das Lötzinn floss schlecht und mehrere meiner bisherigen Platinen haben meine Lernversuche nicht überlebt.

Lange dachte ich deshalb schlicht, dass ich nicht besonders gut löten kann.

Für den zweiten Aufbau habe ich mir schließlich Pinecil V2 angeschafft.

Der Unterschied war deutlich größer als erwartet:

Der neue Lötkolben war leichter, die Temperatur konnte ich besser kontrollieren und vor allem konnte ich innerhalb von Sekunden Lötpunkte sauber setzen.

Das gehört für mich inzwischen ebenfalls zu diesem Projekt.

Nicht weil man für den Qalcosonic W1 unbedingt eine bestimmte Lötstation braucht, sondern weil ich dabei gelernt habe, wie stark vernünftiges Werkzeug das Ergebnis beeinflusst.

Version 2: Jetzt ordentlich

ESP32 und PN5180 habe ich dafür nicht noch einmal gekauft.

Ich habe meinen funktionierenden Versuchsaufbau zunächst dokumentiert, anschließend auseinandergebaut und dieselben Komponenten für die endgültige Version wiederverwendet.

Diesmal geht es schließlich nicht mehr darum herauszufinden, ob die Technik funktioniert.

Das weiß ich bereits.

Jetzt möchte ich daraus einen Sensor machen, den ich montiere und anschließend möglichst vergessen kann.

Das bedeutet für mich:

• saubere Lötstellen
• vernünftige Kabelführung
• mechanisch stabile Verbindungen
• keine fliegenden Jumper-Kabel
• sinnvoll befestigte Komponenten
• einen wartbaren Gesamtaufbau

Was ich bei Version 2 verändert habe

Beim zweiten Aufbau habe ich folgende Dinge gegenüber meinem ersten Versuchsaufbau verändert:

➡️ Keine fliegende Verkabelung

➡️ Auf Lochrasterplatine mit Buchsenleisten verlötet

➡️ Kompaktere Bauform für Integration in ein Gehäuse

Gerade dieser Vergleich gefällt mir an dem Projekt inzwischen fast genauso gut wie der eigentliche Sensor.

Denn zwischen Version 1 und Version 2 liegen nicht einfach nur ein paar neue Lötstellen.

Dazwischen liegt das, was ich beim ersten Versuch gelernt habe.

Was ich mit den Daten in Home Assistant mache

Nach erfolgreicher Einrichtung liefert mein Qalcosonic-W1-Sensor die ausgelesenen Werte direkt an Home Assistant.

Den Wasserzähler in Home Assistant zu sehen, ist ganz nett. Nur wegen eines zusätzlichen Messwerts auf meinem Dashboard hätte sich der Aufwand für mich allerdings nicht gelohnt.

Interessant wird die Integration erst dadurch, was ich mit den Daten machen kann.

Ich möchte nicht nur wissen, wie hoch der aktuelle Zählerstand ist. Mich interessiert vor allem, wie sich unser Wasserverbrauch entwickelt, wie viel Wasser wir beispielsweise im Sommer für den Garten benötigen und ob irgendwo Wasser verbraucht wird, obwohl eigentlich niemand zu Hause ist.

Dafür habe ich mir in Home Assistant ein eigenes kleines Wasser-Dashboard aufgebaut und einige Automationen eingerichtet.

Tages-, Monats- und Jahresverbrauch erfassen

Der Qalcosonic W1 liefert mir über ESPHome zunächst den aktuellen Gesamtverbrauch in Kubikmetern. Für die tägliche Nutzung finde ich einen Zählerstand wie 132,644 m³ allerdings wenig interessant.

Viel hilfreicher sind für mich Fragen wie:

• Wie viel Wasser haben wir heute verbraucht?
• Wie hoch war der Verbrauch diesen Monat?
• Wie sieht es über das gesamte Jahr aus?

Dafür lassen sich in Home Assistant über Einstellungen → Geräte & Dienste → Helfer sogenannte Verbrauchszähler anlegen.

Als Quelle verwende ich jeweils den vom Qalcosonic bereitgestellten Sensor für den Wasserverbrauch und habe drei Helfer für den täglichen, monatlichen und jährlichen Verbrauch angelegt.

Zusätzlich habe ich einen Template-Helfer erstellt, der den vom Wasserzähler gelieferten Durchfluss von m³/h in die für mich wesentlich anschaulicheren Liter pro Minute umrechnet.

Damit stehen alle Werte zur Verfügung, die ich für mein Dashboard benötige.

Über das Energiedashboard gibt es eine ähnliche Ansicht. Es ist hier einfach Geschmackssache wie man es löst.

Mein Wasser-Dashboard in Home Assistant

Die Werte habe ich anschließend in einem eigenen Home-Assistant-Dashboard zusammengefasst.

Dort sehe ich auf einen Blick den aktuellen Durchfluss und die Wassertemperatur sowie den Verbrauch für den aktuellen Tag, Monat und das Jahr. Zusätzlich zeigt mir ein Diagramm die Entwicklung des Wasserverbrauchs der vergangenen Tage.

Interessant sind aber auch die Statusinformationen, die der Qalcosonic W1 über die verwendete ESPHome-Integration bereitstellt. Dazu gehören unter anderem Warnungen für Leckage, ungewöhnlich hohen Wasserfluss, Rückfluss oder Frost.

So muss ich nicht verschiedene Sensoren durchsuchen, sondern habe Verbrauch und Zustand des Wasserzählers an einer Stelle.

Wer das Dashboard als Ausgangspunkt für den eigenen Aufbau verwenden möchte, kann den folgenden YAML-Code übernehmen und die Entity-IDs an die eigene Installation anpassen.

title: Wasser
views:
  - title: Wasser
    path: wasser
    icon: mdi:water
    cards:
      - type: markdown
        content: |
          # 💧 Wasser
          Verbrauch, Durchfluss und Überwachung unseres Qalcosonic W1
      - type: grid
        columns: 2
        square: false
        cards:
          - type: tile
            entity: sensor.qalcosonic_w1_nfc_reader_water_usage
            name: Zählerstand
            icon: mdi:counter
            vertical: true
          - type: tile
            entity: sensor.wasser_durchfluss_liter_minute_2
            name: Aktueller Durchfluss
            icon: mdi:water-pump
            vertical: true
            features_position: bottom
          - type: tile
            entity: sensor.qalcosonic_w1_nfc_reader_water_temperature
            name: Wassertemperatur
            icon: mdi:thermometer-water
            vertical: true
          - type: tile
            entity: sensor.qalcosonic_w1_nfc_reader_external_temperature
            name: Kellertemperatur
            icon: mdi:home-thermometer
            vertical: true
      - type: markdown
        content: |
          ## Verbrauch
      - type: grid
        columns: 3
        square: false
        cards:
          - type: tile
            entity: sensor.keller_qalcosonic_w1_fuxbau_wasserverbrauch_heute
            name: Heute
            icon: mdi:calendar-today
            vertical: true
            features_position: bottom
          - type: tile
            entity: sensor.keller_qalcosonic_w1_fuxbau_wasserverbrauch_monatlich
            name: Monat
            icon: mdi:calendar-month
            vertical: true
            features_position: bottom
          - type: tile
            entity: sensor.keller_qalcosonic_w1_fuxbau_wasserverbrauch_jahrlich
            name: Jahr
            icon: mdi:calendar
            vertical: true
            features_position: bottom
      - type: statistics-graph
        title: Verbrauch der letzten 14 Tage
        chart_type: bar
        period: day
        days_to_show: 14
        stat_types:
          - change
        entities:
          - entity: sensor.qalcosonic_w1_nfc_reader_water_usage
            name: Wasserverbrauch
      - type: markdown
        content: |
          ## Aktueller Wasserfluss
      - type: gauge
        entity: sensor.wasser_durchfluss_liter_minute_2
        name: Durchfluss
        needle: true
        min: 0
        max: 25
        severity:
          green: 0
          yellow: 8
          red: 15
      - type: history-graph
        entities:
          - entity: sensor.wasser_durchfluss_liter_minute_2
            name: Liter / Minute
        title: Durchfluss – letzte 6 Stunden
        hours_to_show: 6
      - type: markdown
        content: |
          ## Sicherheit
      - type: grid
        columns: 2
        square: false
        cards:
          - type: tile
            entity: binary_sensor.qalcosonic_w1_nfc_reader_leakage
            name: Leckage
            icon: mdi:pipe-leak
            vertical: true
          - type: tile
            entity: binary_sensor.qalcosonic_w1_nfc_reader_pipe_is_cracked_burst
            name: Rohrbruch
            icon: mdi:water-alert
            vertical: true
          - type: tile
            entity: binary_sensor.qalcosonic_w1_nfc_reader_reverse_flow
            name: Rückfluss
            icon: mdi:swap-horizontal
            vertical: true
          - type: tile
            entity: binary_sensor.qalcosonic_w1_nfc_reader_freeze_alert
            name: Frostwarnung
            icon: mdi:snowflake-alert
            vertical: true
      - type: markdown
        content: |
          ## Zustand des Wasserzählers
      - type: entities
        show_header_toggle: false
        entities:
          - entity: >-
              binary_sensor.qalcosonic_w1_nfc_reader_low_battery_less_than_12_months_lifetime_left
            name: Batterie schwach
          - entity: >-
              binary_sensor.qalcosonic_w1_nfc_reader_no_signal_the_flow_sensor_is_not_filled_with_water
            name: Kein Messsignal
          - entity: binary_sensor.qalcosonic_w1_nfc_reader_damage_of_meter_housing
            name: Gehäusemanipulation
          - entity: binary_sensor.qalcosonic_w1_nfc_reader_hardware_failure_detected
            name: Hardwarefehler
          - entity: binary_sensor.qalcosonic_w1_nfc_reader_software_failure_detected
            name: Softwarefehler
          - entity: >-
              binary_sensor.qalcosonic_w1_nfc_reader_optical_communication_temporarily_stopped
            name: Kommunikationsfehler
          - entity: binary_sensor.qalcosonic_w1_nfc_reader_reconfiguration_warning
            name: Rekonfigurationswarnung
      - type: entities
        title: Technische Informationen
        show_header_toggle: false
        entities:
          - entity: sensor.qalcosonic_w1_nfc_reader_meter_id
            name: Meter ID
          - entity: sensor.qalcosonic_w1_nfc_reader_serial_number
            name: Seriennummer
          - entity: sensor.qalcosonic_w1_nfc_reader_manufacturer_id
            name: Hersteller
          - entity: sensor.qalcosonic_w1_nfc_reader_meter_version
            name: Zählerversion
          - entity: sensor.qalcosonic_w1_nfc_reader_error_flags_raw
            name: Error Flags
          - entity: button.qalcosonic_w1_nfc_reader_force_sensor_update
            name: Daten jetzt aktualisieren
      - type: statistics-graph
        title: Wasserverbrauch pro Monat
        chart_type: bar
        period: month
        days_to_show: 365
        stat_types:
          - change
        entities:
          - entity: sensor.qalcosonic_w1_nfc_reader_water_usage
            name: Wasserverbrauch

Wasserverbrauch erkennen, obwohl niemand zuhause ist

Noch interessanter als die reine Visualisierung finde ich die Möglichkeit, auf ungewöhnlichen Wasserverbrauch zu reagieren.

Wenn niemand zu Hause ist, sollte normalerweise auch kein Wasser verbraucht werden. Genau diese Information kennt Home Assistant bereits über die Anwesenheitserkennung.

Ich kombiniere deshalb den Wasserzähler mit dem Status meiner Home-Zone.

Sobald niemand mehr zuhause ist und sich der Zählerstand trotzdem erhöht, startet eine Automation. Dabei verwende ich bewusst den Gesamtzählerstand und nicht nur den momentanen Durchfluss.

Der Grund dafür ist das Ausleseintervall meines Aufbaus. Der Qalcosonic wird nicht permanent, sondern in regelmäßigen Abständen per NFC ausgelesen. Ein kurzer Wasserverbrauch könnte beim nächsten Auslesen bereits wieder beendet sein und der aktuelle Durchfluss wieder bei null liegen.

Der Gesamtzählerstand hat sich in dieser Zeit aber trotzdem erhöht.

Damit lässt sich auch ein Verbrauch erkennen, der zwischen zwei Messungen stattgefunden hat.

Nach dem ersten erkannten Verbrauch wartet meine Automation noch einen definierten Zeitraum und berechnet anschließend aus der Differenz des Zählerstands die verbrauchte Wassermenge.

Die Benachrichtigung kann dann beispielsweise so aussehen:

💧 Wasserverbrauch bei Abwesenheit
Seit Beginn des erkannten Wasserverbrauchs wurden ca. 8,4 Liter Wasser verbraucht. Niemand ist zuhause.

Für mich ist diese Information wesentlich hilfreicher als eine Meldung mit dem aktuellen Gesamtzählerstand.

Meine aktuelle Automation sieht folgendermaßen aus:

alias: Wasserverbrauch bei Abwesenheit
description: >
  Meldet Wasserverbrauch, wenn niemand zuhause ist, und zeigt den Verbrauch
  innerhalb des Alarmzeitraums in Litern an.
triggers:
  - trigger: state
    entity_id:
      - sensor.qalcosonic_w1_nfc_reader_water_usage
conditions:
  - condition: numeric_state
    entity_id: zone.home
    below: 1
  - condition: template
    value_template: |
      {{ trigger.from_state is not none
         and trigger.to_state is not none
         and trigger.to_state.state | float(0)
             > trigger.from_state.state | float(0) }}
actions:
  - variables:
      start_value: '{{ trigger.from_state.state | float(0) }}'
  - delay: '00:15:00'
  - variables:
      current_value: |
        {{ states('sensor.qalcosonic_w1_nfc_reader_water_usage') | float(0) }}
      used_liters: |
        {{ ((current_value - start_value | float(0)) * 1000) | round(1) }}
  - condition: numeric_state
    entity_id: zone.home
    below: 1
  - action: notify.mobile_app_iphone_von_matthias
    data:
      title: 💧 Wasserverbrauch bei Abwesenheit
      message: >
        Obwohl niemand zuhause ist, wurden in den letzten 15 Minuten ca. {{
        used_liters }} Liter Wasser verbraucht.
mode: single

Die Entity für die Anwesenheitserkennung und den Benachrichtigungsdienst muss natürlich an die eigene Home-Assistant-Installation angepasst werden.

Leakage und Burst als zusätzliche Warnung

Die Überwachung bei Abwesenheit ist eine Logik, die ich selbst in Home Assistant aufbaue. Zusätzlich liefert der Qalcosonic W1 aber eigene Statusinformationen, die sich ebenfalls über die ESPHome-Integration auslesen lassen.

Besonders interessant sind für mich dabei die beiden Zustände Leakage und Burst.

Leakage dient zur Erkennung eines kleinen, aber dauerhaft vorhandenen Wasserflusses. In der von mir verwendeten Integration wird die Warnung bei der Standardeinstellung ausgelöst, wenn über 24 Stunden kontinuierlich mindestens 1 % des Nenndurchflusses Q3 gemessen wird. Das könnte beispielsweise bei einer undichten Toilettenspülung oder einem anderen unbemerkten Dauerverbrauch interessant sein.

Burst reagiert auf einen deutlich höheren dauerhaften Wasserfluss. Bei der Standardeinstellung wird dieser Zustand ausgelöst, wenn der Durchfluss eine Stunde lang mindestens 10 % von Q3 beträgt.

Wichtig ist deshalb: Burst ist kein sofortiger Rohrbruchalarm. Die Bezeichnung stammt aus den vom Wasserzähler bereitgestellten Statusinformationen. Bei einem plötzlich auftretenden größeren Wasserverlust kann meine zuvor beschriebene Abwesenheitsüberwachung deshalb deutlich früher auf einen ungewöhnlichen Verbrauch aufmerksam machen.

Leakage und Burst möchte ich trotzdem nicht nur im Dashboard sehen. Sobald der Qalcosonic einen dieser Zustände meldet, schickt Home Assistant mir eine Push-Benachrichtigung – unabhängig davon, ob gerade jemand zuhause ist.

Damit ergänzen sich für mich zwei unterschiedliche Arten der Überwachung:

• Home Assistant erkennt ungewöhnlichen Wasserverbrauch aufgrund meiner eigenen Logik, beispielsweise wenn niemand zuhause ist.
• Der Qalcosonic W1 liefert zusätzlich seine eigenen Leakage- und Burst-Warnungen für länger anhaltende ungewöhnliche Durchflüsse.

Meine Automation für diese beiden Warnungen sieht folgendermaßen aus:

alias: Qalcosonic Wasserwarnung
description: Meldet Leckage oder Rohrbruch sofort.
triggers:
  - trigger: state
    entity_id:
      - binary_sensor.qalcosonic_w1_nfc_reader_leakage
    to: 'on'
  - trigger: state
    entity_id:
      - binary_sensor.qalcosonic_w1_nfc_reader_pipe_is_cracked_burst
    to: 'on'
actions:
  - action: notify.mobile_app_iphone_von_matthias
    data:
      title: ⚠️ Wasserwarnung
      message: |
        {% if trigger.entity_id ==
          'binary_sensor.qalcosonic_w1_nfc_reader_pipe_is_cracked_burst' %}
          Der Qalcosonic W1 meldet einen ungewöhnlich hohen,
          dauerhaften Wasserfluss (Burst). Bitte prüfen!
        {% else %}
          Der Qalcosonic W1 meldet eine mögliche Leckage.
          Bitte Wasserverbrauch und Installation prüfen!
        {% endif %}
mode: single

Auch diese Überwachung ersetzt natürlich keinen Wasserstopper oder ein motorisches Absperrventil. In meinem Aufbau kann Home Assistant mich auf einen ungewöhnlichen Verbrauch aufmerksam machen, das Wasser aber nicht selbst abstellen.

Welche Komponenten habe ich verwendet?

Hier noch einmal mein tatsächlicher Aufbau:

Die Lötstation rechne ich bewusst nicht zu den Kosten des Sensors.

Sie ist Werkzeug und wird hoffentlich noch bei einigen weiteren Projekten zum Einsatz kommen.

Bezugsquellen

Die folgenden Komponenten habe ich für meinen Aufbau tatsächlich verwendet:

• ESP32-WROOM-32 DevKit: ➡️ LINK*
• Elechouse PN5180: ➡️ LINK*
• Lötstation/Lötkolben: ➡️ LINK* oder LINK
• Platine/Lochraster: ➡️ LINK*
• Litzen: ➡️ LINK*
• Buchsenleiste: ➡️ LINK*

Bei günstigen Standardkomponenten wie ESP32-Boards lohnt sich meiner Erfahrung nach auch ein Blick auf AliExpress. Wer die Teile kurzfristig benötigt, findet viele davon natürlich ebenfalls bei deutschen Elektronikhändlern.

Werbung / Affiliate-Hinweis: Mit * gekennzeichnete Links sind Affiliate-Links. Als Amazon-Partner verdiene ich an qualifizierten Verkäufen. Für dich ändert sich der Preis dadurch nicht.

Was würde ich heute anders machen?

Drei Dinge würde ich beim nächsten Projekt von Anfang an anders angehen.

1. Erst den Proof of Concept bauen

Bevor ich Gehäuse plane, Platinen löte oder Kabel perfekt verlege, muss die eigentliche Idee funktionieren.

Jumper-Kabel sehen nicht schön aus.

Für den ersten Test müssen sie das aber auch nicht.

2. Vernünftiges Werkzeug verwenden

Wenn eine Lötstelle trotz 400 °C und langem Kontakt nicht funktioniert, würde ich heute nicht einfach die Temperatur weiter erhöhen.

Erst Lötspitze, Verzinnung, Lötzinn, Flussmittel und die eigene Technik überprüfen.

Mehr Hitze ist nicht automatisch die Lösung.

3. Währenddessen Fotos machen

Das merke ich gerade beim Schreiben dieses Artikels.

Viele interessante Zwischenschritte meines ersten Aufbaus existieren nur noch in meinem Kopf.

Beim nächsten Projekt werde ich deshalb nicht versuchen, während des Bauens bereits einen perfekten Artikel zu schreiben.

Ich mache einfach ein Foto.

Ist der Aufwand das wert?

Wenn man ausschließlich einmal im Jahr seinen Wasserverbrauch wissen möchte:

Nein.

Dann reicht es, den Zähler abzulesen.

Wer aber ohnehin Home Assistant betreibt, gerne eigene Sensoren baut und seine Verbrauchsdaten langfristig erfassen möchte, bekommt damit eine ziemlich elegante lokale Lösung.

Und für mich zeigt dieses Projekt noch etwas anderes.

Mein erster Versuch bestand darin, einen analogen Wasserzähler mit Kamera und Bilderkennung irgendwie digital zu machen.

Das funktionierte – irgendwie.

Mein heutiger Aufbau liest dagegen den digitalen Qalcosonic W1 direkt aus.

Keine Kamera. Keine Bilderkennung. Kein beschlagenes Glas.

Und gleichzeitig habe ich bei diesem kleinen Projekt einiges über ESPHome, NFC, ESP32 und sogar über das Löten gelernt.

Genau deshalb mag ich solche Projekte.

Man beginnt mit einem ziemlich konkreten Problem, stolpert unterwegs über fünf neue – und versteht am Ende deutlich mehr als vorher.

Und manchmal besteht die beste Smart-Home-Lösung eben nicht darin, eine komplizierte Lösung immer weiter zu optimieren.

Sondern eine bessere zu finden.

Und genau das verstehe ich unter einem sinnvollen Smart Home: nicht noch ein weiteres Gerät auf einem Dashboard, sondern Technik, die mir Informationen liefert und mich auf Dinge aufmerksam macht, die ich sonst möglicherweise gar nicht bemerken würde.

Hast du den Qalcosonic W1 ebenfalls in Home Assistant eingebunden oder bist beim Aufbau auf ein Problem gestoßen? Schreib es gerne in die Kommentare – wenn ich bei meinem Aufbau über dasselbe Thema gestolpert bin, teile ich gerne meine Erfahrung.