# Schritt-für-Schritt-Anleitung: Wasserverbrauch der Gartenbewässerung mit Home Assistant tracken

Diese Anleitung zeigt, wie du mit Home Assistant 2025.6.3 den Wasserverbrauch deiner Gartenbewässerung (in Litern und Euro) basierend auf dem Gardena Smart System und einem digitalisierten Wasserzähler über MQTT erfassen und auswerten kannst.

## Voraussetzungen
- **Home Assistant**: Version 2025.6.3
- **Gardena Smart System Integration**: Version 1.2.1, protokolliert Start und Stopp der Bewässerung
- **Gardena Smart Water Control**: Steuerung über Gardena-App (täglich 4:57–5:02 und 5:27–5:52 Uhr)
- **Gardena Smart Sensor**: Liefert Bodenfeuchte
- **MQTT-Integration**: Liefert den aktuellen Wasserzählerstand (z. B. `sensor.wasserzaehler_stand` in Litern)
- **Wasserpreis**: Setze einen festen Preis pro Kubikmeter (z. B. 2,00 €/m³, an deine Region anpassen)

## Benötigte Tools
- **Helfer (Input Helpers)**: Zum Speichern von Wasserzählerständen zu bestimmten Zeitpunkten
- **Automationen**: Zum Erfassen des Wasserzählerstands zu Beginn und Ende der Bewässerung
- **Template-Sensoren**: Zur Berechnung von Verbrauch (Liter, Euro) pro Tag, Monat und Gesamt
- **Utility Meter**: Zur Aggregation des Verbrauchs (täglich, monatlich)
- **History Stats**: Optional für erweiterte Statistiken
- **Energy Dashboard**: Optional zur Visualisierung des Wasserverbrauchs

## Schritt-für-Schritt-Anleitung

### Schritt 1: Helfer für Wasserzählerstände erstellen
Erstelle Helfer, um die Wasserzählerstände zu Beginn und Ende der Bewässerung zu speichern.

1. Gehe in Home Assistant zu **Einstellungen > Geräte & Dienste > Helfer**.
2. Klicke auf **Helfer erstellen** und wähle **Zahl**.
3. Erstelle die folgenden Helfer:
   - **input_number.wasserzaehler_beginn**:
     - Name: `Wasserzähler Beginn Bewässerung`
     - Einheit: `Liter`
     - Minimum: 0
     - Maximum: 1000000
     - Schrittweite: 0.1
   - **input_number.wasserzaehler_ende**:
     - Name: `Wasserzähler Ende Bewässerung`
     - Einheit: `Liter`
     - Minimum: 0
     - Maximum: 1000000
     - Schrittweite: 0.1
   - **input_number.wasserpreis_pro_m3**:
     - Name: `Wasserpreis pro Kubikmeter`
     - Einheit: `€/m³`
     - Minimum: 0
     - Maximum: 10
     - Schrittweite: 0.01
     - Standardwert: 2.00 (passe dies an deinen regionalen Wasserpreis an)

### Schritt 2: Automationen zum Erfassen der Wasserzählerstände
Erstelle Automationen, um den Wasserzählerstand (`sensor.wasserzaehler_stand`) zu Beginn und Ende der Bewässerung zu speichern. Die Gardena Smart System Integration liefert den Status des Bewässerungscomputers (z. B. `switch.gardena_irrigation`).

1. Gehe zu **Einstellungen > Automationen & Szenen > Automationen > Erstellen**.
2. Erstelle die folgende Automation:

#### Automation 1: Wasserzählerstand zu Beginn der Bewässerung speichern
```yaml
alias: Wasserzählerstand zu Beginn der Bewässerung speichern
description: Speichert den Wasserzählerstand, wenn die Bewässerung startet
trigger:
  - platform: state
    entity_id: switch.gardena_irrigation
    to: "on"
condition: []
action:
  - service: input_number.set_value
    target:
      entity_id: input_number.wasserzaehler_beginn
    data:
      value: "{{ states('sensor.wasserzaehler_stand') | float }}"
mode: single
```

3. Erstelle eine zweite Automation:

#### Automation 2: Wasserzählerstand am Ende der Bewässerung speichern
```yaml
alias: Wasserzählerstand am Ende der Bewässerung speichern
description: Speichert den Wasserzählerstand, wenn die Bewässerung stoppt
trigger:
  - platform: state
    entity_id: switch.gardena_irrigation
    to: "off"
condition: []
action:
  - service: input_number.set_value
    target:
      entity_id: input_number.wasserzaehler_ende
    data:
      value: "{{ states('sensor.wasserzaehler_stand') | float }}"
mode: single
```

### Schritt 3: Template-Sensor für täglichen Verbrauch
Erstelle einen Template-Sensor, um den täglichen Wasserverbrauch in Litern und Euro zu berechnen.

1. Bearbeite die `configuration.yaml` (unter **Datei-Editor** oder via SSH).
2. Füge folgenden Code hinzu (passe `sensor.wasserzaehler_stand` an, falls dein Sensor anders heißt):

```yaml
template:
  - sensor:
      - name: "Täglicher Bewässerungsverbrauch Liter"
        unit_of_measurement: "L"
        state: >
          {% if states('input_number.wasserzaehler_ende') | float > states('input_number.wasserzaehler_beginn') | float %}
            {{ (states('input_number.wasserzaehler_ende') | float - states('input_number.wasserzaehler_beginn') | float) | round(2) }}
          {% else %}
            0
          {% endif %}
        state_class: measurement
        device_class: water
      - name: "Täglicher Bewässerungsverbrauch Euro"
        unit_of_measurement: "€"
        state: >
          {% if states('input_number.wasserzaehler_ende') | float > states('input_number.wasserzaehler_beginn') | float %}
            {{ ((states('input_number.wasserzaehler_ende') | float - states('input_number.wasserzaehler_beginn') | float) / 1000 * states('input_number.wasserpreis_pro_m3') | float) | round(2) }}
          {% else %}
            0
          {% endif %}
        state_class: measurement
        device_class: monetary
```

### Schritt 4: Utility Meter für monatliche und jährliche Auswertung
Nutze den Utility Meter, um den Verbrauch monatlich und jährlich zu aggregieren.

1. Füge in der `configuration.yaml` folgendes hinzu:

```yaml
utility_meter:
  bewässerungsverbrauch_monatlich_liter:
    source: sensor.täglicher_bewässerungsverbrauch_liter
    cycle: monthly
  bewässerungsverbrauch_jährlich_liter:
    source: sensor.täglicher_bewässerungsverbrauch_liter
    cycle: yearly
  bewässerungsverbrauch_monatlich_euro:
    source: sensor.täglicher_bewässerungsverbrauch_euro
    cycle: monthly
  bewässerungsverbrauch_jährlich_euro:
    source: sensor.täglicher_bewässerungsverbrauch_euro
    cycle: yearly
```

2. Starte Home Assistant neu, damit die Änderungen übernommen werden (**Einstellungen > System > Neustart**).

### Schritt 5: Visualisierung im Energy Dashboard
Füge den Wasserverbrauch zum Energy Dashboard hinzu, um eine übersichtliche Darstellung zu erhalten.

1. Gehe zu **Einstellungen > Dashboards > Energy**.
2. Unter „Wasserverbrauch“ füge die Sensoren hinzu:
   - `sensor.täglicher_bewässerungsverbrauch_liter`
   - `sensor.bewässerungsverbrauch_monatlich_liter`
   - `sensor.bewässerungsverbrauch_jährlich_liter`
3. Optional: Erstelle eine separate Karte in einem Dashboard (z. B. via **Lovelace**) mit den Euro-Sensoren für die Kostenübersicht.

### Schritt 6: Optional – Erweiterte Statistiken mit History Stats
Falls du detailliertere Statistiken möchtest (z. B. durchschnittlicher Verbrauch pro Tag), füge einen History Stats-Sensor hinzu.

1. In der `configuration.yaml`:

```yaml
sensor:
  - platform: history_stats
    name: Bewässerungsdauer pro Tag
    entity_id: switch.gardena_irrigation
    state: "on"
    type: time
    start: "{{ now().replace(hour=0, minute=0, second=0) }}"
    end: "{{ now() }}"
```

2. Dies gibt dir die tägliche Bewässerungsdauer, die du mit dem Verbrauch korrelieren kannst.

### Schritt 7: Testen und Feinabstimmung
1. **Teste die Automationen**:
   - Starte die Bewässerung manuell über die Gardena-App oder Home Assistant und prüfe, ob `input_number.wasserzaehler_beginn` und `input_number.wasserzaehler_ende` aktualisiert werden.
2. **Prüfe die Sensoren**:
   - Öffne **Entwicklerwerkzeuge > Status** und suche nach `sensor.täglicher_bewässerungsverbrauch_liter` und `sensor.täglicher_bewässerungsverbrauch_euro`.
3. **Fehlerbehebung**:
   - Stelle sicher, dass `sensor.wasserzaehler_stand` korrekt über MQTT geliefert wird.
   - Überprüfe die Gardena-Integration, falls der Bewässerungsstatus nicht korrekt erfasst wird.

## Ergebnis
- **Täglicher Verbrauch**: `sensor.täglicher_bewässerungsverbrauch_liter` und `sensor.täglicher_bewässerungsverbrauch_euro`
- **Monatlicher Verbrauch**: `sensor.bewässerungsverbrauch_monatlich_liter` und `sensor.bewässerungsverbrauch_monatlich_euro`
- **Jährlicher Verbrauch**: `sensor.bewässerungsverbrauch_jährlich_liter` und `sensor.bewässerungsverbrauch_jährlich_euro`
- **Visualisierung**: Im Energy Dashboard oder via benutzerdefinierten Lovelace-Karten

## Hinweise
- Passe den Wasserpreis in `input_number.wasserpreis_pro_m3` an deine Region an.
- Falls die Bewässerungszeiten variieren, kannst du die Automationen mit Zeitbedingungen (z. B. zwischen 4:00 und 6:00 Uhr) ergänzen.
- Überprüfe regelmäßig die MQTT-Verbindung, um Datenverluste zu vermeiden.