Smarte Gartenbewässerung: Vom starren System zur intelligenten Lösung
Die Bewässerung des eigenen Gartens klingt im ersten Moment nach einer simplen Aufgabe – bis man merkt, wie unterschiedlich die Anforderungen tatsächlich sind. Genau das war bei mir der Fall: Zwei getrennte Rasenflächen, mehrere Pflanzbereiche und überall andere Bedingungen.
Ein perfekt gepflegter Rasen dank smarter Bewässerungstechnik
Mit der Zeit wurde klar: Eine einfache, zentrale Steuerung reicht hier nicht aus. Also habe ich angefangen, mein System Schritt für Schritt zu hinterfragen – und letztlich komplett neu aufzubauen.
Warum klassische Bewässerungssysteme schnell an ihre Grenzen kommen
Viele klassische Bewässerungssysteme arbeiten nach einem einfachen Prinzip: feste Zeitpläne. Einmal eingestellt, laufen sie zuverlässig – egal ob es geregnet hat oder die Temperaturen plötzlich sinken.
Genau hier liegt aber das Problem. In der Praxis führt das oft dazu, dass entweder zu viel oder zu wenig bewässert wird. Nach einem regnerischen Tag läuft die Anlage trotzdem weiter, während an heißen Tagen die voreingestellte Laufzeit nicht ausreicht.
Mein Garten: Anforderungen und Herausforderungen
Mein Garten ist alles andere als homogen. Die beiden Rasenflächen sind nicht nur räumlich getrennt, sondern unterscheiden sich auch deutlich in ihrer Lage. Während ein Bereich den Großteil des Tages in der Sonne liegt, bekommt der andere nur zeitweise direkte Einstrahlung ab.
Entsprechend unterschiedlich ist auch der Wasserbedarf. Der sonnige Bereich trocknet deutlich schneller aus, während der schattigere Teil länger Feuchtigkeit hält. Hinzu kommen mehrere Pflanzbereiche mit ganz eigenen Anforderungen – von durstigen Beeten bis hin zu Pflanzen, die mit deutlich weniger Wasser auskommen.
Schnell wurde klar: Eine einheitliche Bewässerungslösung würde hier zwangsläufig zu Kompromissen führen.
Warum ich mich von meinem bisherigen System verabschiedet habe
Zu Beginn habe ich auf ein klassisches Bewässerungssystem gesetzt und dabei Komponenten von Gardena verwendet – konkret den Gardena smart Water Control* (Werbung) in Kombination mit dem Gardena Wasserverteiler* (Werbung). Die Einrichtung war unkompliziert und das System lief grundsätzlich zuverlässig. Gerade für einfache Gärten ist das sicherlich eine solide Lösung.
In meinem Fall haben sich jedoch schnell die Grenzen gezeigt. Der eingesetzte Wasserverteiler bietet maximal sechs Ausgänge – für meinen Garten mit mehreren Rasen- und Pflanzbereichen war das von Anfang an knapp bemessen.
Zusätzlich kam ein Gardena Bodenfeuchtesensor* (Werbung) zum Einsatz. Dieser konnte allerdings nur einen einzelnen Bereich abdecken, wodurch die gemessenen Werte nicht wirklich repräsentativ für den gesamten Garten waren. Das führte dazu, dass ich trotz vorhandener Sensorik keine wirklich bedarfsgerechte Steuerung umsetzen konnte. Während ein Bereich möglicherweise noch ausreichend feucht war, konnte ein anderer bereits deutlich zu trocken sein.
Hinzu kam die generelle Einschränkung durch feste Zeitpläne. Anpassungen waren nur manuell möglich und spontane Wetteränderungen wurden nicht berücksichtigt. Besonders im Alltag wurde das schnell mühsam: Ich musste regelmäßig nachjustieren, Laufzeiten anpassen oder die Bewässerung komplett deaktivieren.
Irgendwann war klar: Wenn ich das wirklich effizient und flexibel lösen will, brauche ich ein System, das sich besser an die tatsächlichen Gegebenheiten im Garten anpassen kann.
Die neue Lösung: Smarte Gartenbewässerung mit Home Assistant
Der entscheidende Schritt war die Umstellung auf ein modulares, smartes System. Statt einer zentralen Steuerung, die alles gleich behandelt, wird die Bewässerung jetzt in einzelne, unabhängig steuerbare Kreisläufe aufgeteilt.
Gesteuert wird das Ganze über Home Assistant, das als zentrale Plattform alle Komponenten miteinander verbindet.
Konkret setze ich dabei auf den SONOFF Bewässerungscomputer SWV-BSP* (Werbung) , eine ECOWITT Wetterstation GW1101* (Werbung) sowie den ECOWITT Bodenfeuchtigkeitssensor WH51* (Werbung).
Diese Kombination ermöglicht es mir, die Bewässerung nicht nur zentral zu steuern, sondern auch auf Basis realer Messwerte automatisiert zu optimieren.
Drei Sonoff Bewässerungscomputer für drei Individuelle Bewässerungs-Kreisläufe
Praxis: Durchfluss und Druck beim Sonoff Ventil
In der Praxis spielt beim Einsatz des SONOFF Bewässerungscomputer SWV-BSP* (Werbung) nicht nur die Steuerung eine Rolle, sondern auch der tatsächliche Wasserdurchfluss.
Wichtig vorweg: Für die meisten Anwendungen im Garten ist der Durchfluss absolut ausreichend – egal ob Rasensprenger oder Tropfbewässerung. Bei Tropfbewässerung ist der Durchfluss in der Regel ohnehin unkritisch, da hier üblicherweise Gardena Micro-Drip-System Druckminderer* (Werbung) eingesetzt werden (müssen). Diese begrenzen den Druck gezielt und sorgen für eine gleichmäßige Wasserabgabe.
Laut Hersteller liegt der maximale Durchfluss bei etwa 28 Litern pro Minute – allerdings unter optimalen Bedingungen mit einem Wasserdruck von rund 5 bar. Im Alltag sieht das meist etwas anders aus. Je nach Hausanschluss liegt der Druck häufig eher bei 2 bis 3 bar, wodurch sich der tatsächliche Durchfluss entsprechend reduziert.
Zusätzlich beeinflussen auch Faktoren wie Schlauchlänge oder verwendete Anschlüsse die Leistung. Ein längerer Gartenschlauch oder der Einsatz von Adaptern kann den Durchfluss etwas verringern.
In der Praxis bedeutet das: Statt zu viele Verbraucher gleichzeitig zu betreiben, lohnt es sich, die Bewässerung sinnvoll aufzuteilen. Genau das war auch einer der Gründe für mein Setup mit mehreren Kreisläufen.
Ein praktischer Hinweis zum Schluss: Im Winter sollte das Ventil unbedingt abgebaut werden. Restwasser im Inneren kann bei Frost zu Schäden am Gehäuse führen.
Aufteilung in 7 Bewässerungskreisläufe
Insgesamt habe ich meinen Garten in sieben Kreisläufe unterteilt: drei für den Rasen und vier für unterschiedliche Pflanzbereiche.
Diese Aufteilung war der Schlüssel, um die unterschiedlichen Anforderungen überhaupt sinnvoll abbilden zu können.
Rasenflächen: Warum 3 Zonen sinnvoll sind
Die Aufteilung des Rasens in drei separate Zonen ergibt sich nicht nur aus der räumlichen Trennung, sondern vor allem aus den unterschiedlichen Bedingungen vor Ort.
Für die Bewässerung setze ich hier auf Versenkregner, konkret beispielsweise den Gardena Versenkregner SD80* (Werbung) oder Gardena Versenkregner SD30* (Werbung). Diese eignen sich besonders gut für Rasenflächen, da sie gleichmäßig große Bereiche abdecken und sich bei Nichtbenutzung vollständig im Boden versenken.
Durch die getrennte Steuerung kann jeder Bereich genau so bewässert werden, wie es notwendig ist – abhängig von Sonneneinstrahlung und Feuchtigkeitsbedarf.
Pflanzenbereiche: Unterschiedliche Bedürfnisse berücksichtigen
Noch deutlicher werden die Unterschiede bei den Pflanzen. Einige Bereiche benötigen regelmäßig Wasser, andere kommen mit deutlich weniger aus.
Hier setze ich auf Tropfbewässerung, beispielsweise mit dem Gardena Micro-Drip-System* (Werbung) . Dieses gibt das Wasser gezielt und langsam direkt an die Pflanzen ab.
Der große Vorteil: Es geht deutlich weniger Wasser durch Verdunstung verloren und die Pflanzen werden gleichmäßiger versorgt.
Durch die Aufteilung in eigene Kreisläufe kann ich diese Unterschiede gezielt berücksichtigen und Über- oder Unterversorgung vermeiden.
Wetterdaten einbeziehen
Die Ecowitt-Wetterstation liefert präzise Wetterdaten direkt an Home Assistant
Über meine ECOWITT Wetterstation GW1101* (Werbung) werden aktuelle Wetterdaten wie Niederschlag, Temperatur und Luftfeuchtigkeit direkt in das System eingebunden.
Zusätzlich nutze ich auch Wettervorhersagen (OpenWheatherMap Integration) als Grundlage für die Steuerung. Diese geben zwar einen guten Überblick über die kommenden Stunden und Tage, sind jedoch nicht immer zuverlässig.
In der Praxis zeigen sich jedoch immer wieder Abweichungen zwischen Vorhersage und tatsächlichem Wetter. Angekündigter Regen bleibt aus oder tritt zu anderen Zeiten als erwartet auf. Wird die Bewässerung ausschließlich auf Basis solcher Prognosen gesteuert, kann das zu ungenauen oder ineffizienten Ergebnissen führen.
Deshalb kombiniere ich beide Ansätze: Die Wettervorhersage dient als zusätzliche Orientierung, während die lokalen Messwerte der Wetterstation die verlässliche Entscheidungsgrundlage bilden. Wenn beispielsweise Regen angekündigt ist, die Wetterstation aber keinen tatsächlichen Niederschlag registriert, wird die Bewässerung entsprechend nicht vorschnell deaktiviert. So entsteht eine deutlich robustere Steuerung, die nicht nur auf Prognosen vertraut, sondern reale Bedingungen mit einbezieht.
Bodenfeuchte als Entscheidungsbasis
Für jede Zone nutze ich einen ECOWITT Bodenfeuchtigkeitssensor WH51* (Werbung), der direkt im jeweiligen Bereich platziert ist.
Im Gegensatz zu meiner früheren Lösung, bei der nur ein einzelner Sensor den gesamten Garten abdecken musste, erhalte ich so für jede Zone einen eigenen, deutlich genaueren Messwert. Bewässert wird also nicht mehr pauschal, sondern gezielt auf Basis der tatsächlichen Bodenfeuchte in der jeweiligen Zone.
Hinweis: Es wird eine Ecowitt Wetterstation benötigt.
Alternativ gibt es auch den deutlich günstigeren Zigbee-Bodenfeuchtesensor* (Werbung), der sich problemlos in viele Smart-Home-Systeme integrieren lässt und für einzelne Zonen eine einfache Lösung darstellen kann.
In meinem Setup hat sich jedoch gezeigt, dass der Ecowitt-Sensor insgesamt zuverlässiger und konsistenter misst. Gerade bei der Bewässerung, wo es auf präzise Werte ankommt, war mir diese Genauigkeit letztlich wichtiger als der günstigere Preis.
Dynamische Laufzeiten statt fixer Zeitpläne
Auch die Dauer der Bewässerung ist nicht mehr statisch. Jeder Kreislauf hat seine eigenen Laufzeiten, die sich an Bedarf, Wetter und Bodenfeuchte orientieren.
Das führt dazu, dass manche Bereiche häufiger, aber kürzer bewässert werden, während andere seltener, dafür intensiver versorgt werden.
Vorteile im Alltag
Im Alltag zeigt sich der größte Vorteil schnell: Die Bewässerung läuft vollständig im Hintergrund und passt sich automatisch an Wetter, Bodenfeuchte und Tagesbedingungen an.
Dadurch muss ich nur noch selten eingreifen und habe gleichzeitig den Eindruck, dass der Garten insgesamt gleichmäßiger und stabiler versorgt wird.
- Bedarfsgerechte Bewässerung statt starrer Zeitpläne
- Reduzierter Wasserverbrauch durch Sensor- und Wetterdaten
- Deutlich weniger manueller Aufwand im Alltag
Fazit: Lohnt sich der Umbau?
Rückblickend war der Umbau auf ein smartes Bewässerungssystem mit Home Assistant, Sensoren und Wetterdaten die richtige Entscheidung.
Besonders bei Gärten mit unterschiedlichen Zonen und Anforderungen spielt dieser Ansatz seine Stärken aus, da jede Fläche individuell versorgt werden kann, ohne dass ständig manuell nachjustiert werden muss.
Insgesamt überwiegen für mich klar die Vorteile in Bezug auf Komfort, Effizienz und Flexibilität gegenüber dem früheren, starren System.
So habe ich die Bewässerung in Home Assistant umgesetzt
Die eigentliche Logik hinter der Bewässerung läuft in Home Assistant. Dabei kombiniere ich Bodenfeuchte, Wetterdaten und Vorhersagen, um zu entscheiden, ob und wie lange bewässert werden soll.
Steuerung über das Home Assistant Dashboard
Links: Statuswerte für das Dashboard | Rechts: Admin-Bereich zur Konfiguration der Bewässerungskreisläufe.
Neben der eigentlichen Automatisierung spielt auch die Benutzeroberfläche eine wichtige Rolle in meinem Setup.
Ich habe sie bewusst in zwei Bereiche aufgeteilt: ein Dashboard für den täglichen Überblick und einen separaten Admin-Bereich für detaillierte Einstellungen.
Das Dashboard läuft auf meinem Tablet und zeigt die wichtigsten Informationen auf einen Blick. Es ist auf schnelle Bedienung und Übersicht ausgelegt. Im Admin-Bereich auf einer Unterseite werden hingegen Parameter wie Bewässerungszeiten pro Zone, maximale Laufzeiten oder Schwellwerte für Bodenfeuchtigkeit und Wetterbedingungen konfiguriert.
So bleibt die Oberfläche im Alltag schlank, während Anpassungen bei Bedarf gezielt vorgenommen werden können – ganz ohne Änderungen im YAML.
Hinweis zur Code-Darstellung
Die YAML-Beispiele in diesem Artikel sind bewusst so dargestellt, dass sie möglichst gut nachvollziehbar und einfach anpassbar bleiben. Daher habe ich die Formatierung und Struktur im Code weitgehend beibehalten.
Außerdem wurde der Code absichtlich nicht zu stark zusammengefasst oder abstrahiert. So lassen sich die einzelnen Schritte und Logiken besser verstehen und bei Bedarf leichter auf das eigene Setup übertragen oder anpassen. Ziel ist es, den Einstieg in die Umsetzung zu erleichtern und nicht eine möglichst kompakte, aber schwer verständliche Darstellung zu erzeugen.
Für die Umsetzung des Dashboard-Layouts können zusätzlich weitere Home-Assistant-Integrationen bzw. über HACS installierbare Custom Cards erforderlich sein.
Admin-Bereich: Bewässerungszeiten und Limits definieren
In meinem Home-Assistant-Dashboard können für jeden Bewässerungskreislauf zwei Bewässerungszeiten festgelegt werden. So lässt sich flexibel auf unterschiedliche Wetterbedingungen oder längere Trockenperioden reagieren, ohne die Automatisierung grundlegend ändern zu müssen. Zusätzlich können für jeden Kreislauf individuelle Grenzwerte für Bodenfeuchte und Regenmenge definiert werden.
Die zugrunde liegende Logik bleibt dabei stets gleich. Zur besseren Veranschaulichung zeige ich im Folgenden beispielhaft nur einen Kreislauf.
Für weitere Kreisläufe muss dieser Code nur dupliziert werden und "k1" durch "k2", "k3" usw. ersetzt werden.
YAML-Konfiguration anzeigen: Admin-Bereich
type: vertical-stack
cards:
- type: custom:bubble-card
card_type: separator
name: Kreislauf 1 - Blumen
icon: mdi:flower
- type: vertical-stack
cards:
- type: horizontal-stack
cards:
- type: custom:button-card
show_icon: false
show_state: false
name: An/Aus
styles:
card:
- width: 80px
- border: none
- background: none
- box-shadow: none
- margin-right: "-20px"
- margin-bottom: "-10px"
name:
- font-size: 12px
- font-weight: bold
- text-align: center
- type: custom:button-card
show_icon: false
show_state: false
name: Start
styles:
card:
- border: none
- background: none
- box-shadow: none
- margin-bottom: "-10px"
name:
- font-size: 12px
- font-weight: bold
- text-align: center
- type: custom:button-card
show_icon: false
show_state: false
name: Ende
styles:
card:
- border: none
- background: none
- box-shadow: none
- margin-bottom: "-10px"
name:
- font-size: 12px
- font-weight: bold
- text-align: center
card_mod:
style: |
#root > * {
margin: 0 2px !important;
}
- type: custom:vertical-stack-in-card
card_mod:
style: |
ha-card {
border-radius: 100px;
padding-top: 3px;
height: 45px;
}
cards:
- type: horizontal-stack
cards:
- type: custom:button-card
entity: input_boolean.bewaesserung_k1_t1_aktiv
icon: mdi:toggle-switch
show_name: false
state:
- value: "on"
icon: mdi:toggle-switch
styles:
icon:
- color: green
- value: "off"
icon: mdi:toggle-switch-off
styles:
icon:
- color: grey
styles:
card:
- width: 80px
- height: 40px
- border: none
- margin-right: "-20px"
- type: custom:numberbox-card
border: false
entity: input_number.bewaesserung_k1_t1_start
unit: time
speed: 0
delay: 0
icon: false
name: false
step: 1
card_mod:
style: |
.cur-num { font-size: 14px !important; }
.cur-box ha-icon { transform: scale(0.7); }
- type: custom:numberbox-card
border: false
entity: input_number.bewaesserung_k1_t1_ende
unit: time
speed: 0
delay: 0
icon: false
name: false
step: 1
card_mod:
style: |
.cur-num { font-size: 14px !important; }
.cur-box ha-icon { transform: scale(0.7); }
- type: custom:vertical-stack-in-card
card_mod:
style: |
ha-card {
border-radius: 100px;
padding-top: 3px;
height: 45px;
}
cards:
- type: horizontal-stack
cards:
- type: custom:button-card
entity: input_boolean.bewaesserung_k1_t2_aktiv
icon: mdi:toggle-switch
show_name: false
state:
- value: "on"
icon: mdi:toggle-switch
styles:
icon:
- color: green
- value: "off"
icon: mdi:toggle-switch-off
styles:
icon:
- color: grey
styles:
card:
- width: 80px
- height: 40px
- border: none
- margin-right: "-20px"
- type: custom:numberbox-card
border: false
entity: input_number.bewaesserung_k1_t2_start
unit: time
speed: 0
delay: 0
icon: false
name: false
step: 1
card_mod:
style: |
.cur-num { font-size: 14px !important; }
.cur-box ha-icon { transform: scale(0.7); }
- type: custom:numberbox-card
border: false
entity: input_number.bewaesserung_k1_t2_ende
unit: time
speed: 0
delay: 0
icon: false
name: false
step: 1
card_mod:
style: |
.cur-num { font-size: 14px !important; }
.cur-box ha-icon { transform: scale(0.7); }
- type: custom:bubble-card
card_type: button
entity: input_number.bewaesserung_k1_limit_moisture
show_last_changed: false
show_attribute: false
tap_action:
action: none
name: "Bodenfeuchte: Keine Bewässerung über"
show_state: true
force_icon: false
scrolling_effect: false
show_icon: true
show_name: true
styles: |-
.bubble-icon {
color: var(--background-color) !important;
} .bubble-range-fill {
background-color:#49423e !important;
}
sub_button: []
icon: mdi:water-percent-alert
button_type: slider
hold_action:
action: none
double_tap_action:
action: none
slider_live_update: true
- type: custom:bubble-card
card_type: button
entity: input_number.bewaesserung_k1_limit_rain_today
show_last_changed: false
show_attribute: false
tap_action:
action: none
name: "Regen bisher: Keine Bewässerung über"
show_state: true
force_icon: false
scrolling_effect: false
show_icon: true
show_name: true
styles: |-
.bubble-icon {
color: var(--background-color) !important;
} .bubble-range-fill {
background-color:#49423e !important;
}
sub_button: []
icon: mdi:arrow-collapse-right
button_type: slider
hold_action:
action: none
double_tap_action:
action: none
slider_live_update: true
- type: custom:bubble-card
card_type: button
entity: input_number.bewaesserung_k1_limit_rain_forecast
show_last_changed: false
show_attribute: false
tap_action:
action: none
name: "Regen Vorschau: Keine Bewässerung über"
show_state: true
force_icon: false
scrolling_effect: false
show_icon: true
show_name: true
styles: |-
.bubble-icon {
color: var(--background-color) !important;
} .bubble-range-fill {
background-color:#49423e !important;
}
sub_button: []
icon: mdi:weather-pouring
button_type: slider
hold_action:
action: none
double_tap_action:
action: none
slider_live_update: true
Dashboard: Ausgabe Status Bewässerung
Im oberen Bereich wird die bisherige Regenmenge des heutigen Tages sowie die aktuelle Regenvorhersage angezeigt. Die Anzeige färbt sich blau, sobald bereits Niederschlag gefallen ist oder für den weiteren Tagesverlauf Regen erwartet wird.
Darunter folgt eine übersichtliche Darstellung aller Bewässerungskreisläufe. Für jeden Kreislauf werden die aktuelle Bodenfeuchte sowie der Status angezeigt: aktiv bewässert, aufgrund der Bedingungen übersprungen oder manuell deaktiviert.
Ganz oben rechts kann die Automatisierung zusätzlich global ein- oder ausgeschaltet werden.
YAML-Konfiguration anzeigen: Dashboard
type: vertical-stack
cards:
- type: custom:bubble-card
card_type: separator
name: Garten Bewässerung
icon: mdi:sprinkler-variant
sub_button:
- entity: automation.garten_bewasserung_2
show_state: false
show_name: false
tap_action:
action: toggle
styles: |-
.bubble-sub-button-1 {
/* Automation. Hintergrundfarbe: Grün wenn 'on', Grau wenn 'off' */
background-color: ${(() => {
const state = hass.states['automation.garten_bewasserung_2']?.state;
return state === 'on' ? 'rgba(50, 205, 50, 0.6)' : 'rgba(150, 150, 150, 0.3)';
})()} !important;
/* Icon-Wechsel: Pumpe wenn 'on', Pumpe-Aus wenn 'off' */
--card-mod-icon: ${(() => {
const state = hass.states['automation.garten_bewasserung_2']?.state;
return state === 'on' ? 'mdi:water-pump' : 'mdi:water-pump-off';
})()};
color: white !important;
}
- type: custom:bubble-card
card_type: button
button_type: state
entity: sensor.gw1100a_outdoor_temperature_2
name: Temperatur & Regenmenge
show_name: true
show_state: true
show_icon: true
icon: mdi:thermometer
scrolling_effect: false
sub_button:
- entity: sensor.gw1100a_daily_rain_rate_2
name: Bisher
show_state: true
icon: mdi:arrow-collapse-right
show_name: false
- entity: sensor.regenmenge_heute
name: Heute
show_state: true
icon: mdi:weather-rainy
show_name: false
styles: >-
/* Hintergrund wird blau, wenn es heute geregnet hat ODER es noch regnen soll */
.bubble-button-card-container {
background-color: ${(() => {
const rain = parseFloat(hass.states['sensor.regenmenge_heute']?.state);
const rate = parseFloat(hass.states['sensor.gw1100a_daily_rain_rate_2']?.state);
return (rain > 0 || rate > 0) ? 'rgba(0, 120, 255, 0.2)' : 'rgba(100, 100, 100, 0.2)';
})()} !important;
}
/* Sub-Button 1 (Regenrate) blau einfärben, wenn es heute Regen gab */
.bubble-sub-button-1 {
background-color: ${(() => {
const rate = parseFloat(hass.states['sensor.gw1100a_daily_rain_rate_2']?.state);
return rate > 0 ? 'rgba(0, 120, 255, 0.4)' : 'rgba(150, 150, 150, 0.1)';
})()} !important;
}
/* Sub-Button 2 (Gesamtmenge) blau einfärben, wenn es heute noch regnen soll */
.bubble-sub-button-2 {
background-color: ${(() => {
const rate = parseFloat(hass.states['sensor.regenmenge_heute']?.state);
return rate > 0 ? 'rgba(0, 120, 255, 0.4)' : 'rgba(150, 150, 150, 0.1)';
})()} !important;
}
- type: grid
columns: 2
square: false
cards:
Den folgenden Bereich pro Kreislauf duplizieren und dann "k1" durch "k2", "k3" usw. sowie den Namen des Sensors für den Bodenfeuchtesensor (blau markiert) ersetzen:
- type: custom:bubble-card
card_type: button
button_type: state
entity: sensor.gw1100a_soil_moisture_1
name: Blumen
show_name: true
show_state: true
show_icon: true
icon: mdi:flower
scrolling_effect: false
sub_button:
- entity: sensor.bewaesserung_k1_logik
show_state: false
styles: |-
/* Hintergrund der Hauptkarte (Bodenfeuchte) */
.bubble-button-card-container {
background-color: ${(() => {
const l = parseFloat(hass.states['sensor.gw1100a_soil_moisture_1']?.state);
if (l < 15) return 'rgba(255, 0, 0, 0.2)';
if (l <= 20) return 'rgba(255, 215, 0, 0.2)';
return 'rgba(0, 255, 0, 0.1)';
})()} !important;
}
/* Sub-Button Logik: Farbe & Icon */
.bubble-sub-button-1 {
background-color: ${(() => {
const s1 = hass.states['input_boolean.bewaesserung_k1_t1_aktiv'];
const s2 = hass.states['input_boolean.bewaesserung_k1_t2_aktiv'];
const sL = hass.states['sensor.bewaesserung_k1_logik'];
if (!s1 || !s2 || !sL || (s1.state === 'off' && s2.state === 'off')) return 'rgba(128, 128, 128, 0.5)';
return sL.state.toLowerCase() === 'aktiv' ? 'rgba(50, 205, 50, 0.5)' : 'rgba(255, 0, 0, 0.5)';
})()} !important;
--card-mod-icon: ${(() => {
const s1 = hass.states['input_boolean.bewaesserung_k1_t1_aktiv'];
const s2 = hass.states['input_boolean.bewaesserung_k1_t2_aktiv'];
const sL = hass.states['sensor.bewaesserung_k1_logik'];
if (!s1 || !s2 || !sL || (s1.state === 'off' && s2.state === 'off')) return 'mdi:water-remove-outline';
return sL.state.toLowerCase() === 'aktiv' ? 'mdi:water-check' : 'mdi:water-off';
})()};
}
Ergänzungen in der configuration.yaml
Die komplette Logik ist in einem Package gekapselt. Hier werden alle benötigten Sensoren und Komponenten zentral erstellt und verwaltet.
Folgende Zeilen in die configuration.yaml hinzufügen:
homeassistant:
packages: !include_dir_named packages
und folgende Ordnerstruktur anlegen:
/packages # wenn noch nicht vorhanden
/packages/bewaesserung
Package
Den Inhalt nach
/packages/bewaesserung/k1.yaml
legen. Für weitere Kreisläufe die Datei k1.yaml kopieren und als k2.yaml, k3.yaml usw. im gleichen Ordner speichern.
Package für Kreislauf 1 (k1.yaml)
# Package für Bewässerungskreislauf 1
#####################################
# Bewässerungszeiten in hh:mm als Trigger für Automation
input_datetime:
bewaesserung_k1_t1_start_trigger:
name: "K1 T1 Start"
has_date: false
has_time: true
bewaesserung_k1_t1_ende_trigger:
name: "K1 T1 Ende"
has_date: false
has_time: true
bewaesserung_k1_t2_start_trigger:
name: "K1 T2 Start"
has_date: false
has_time: true
bewaesserung_k1_t2_ende_trigger:
name: "K1 T2 Ende"
has_date: false
has_time: true
# Zwei Laufzeiten pro Tag
input_boolean:
bewaesserung_k1_t1_aktiv:
name: "K1 Termin 1 Aktiv"
icon: mdi:calendar-check
bewaesserung_k1_t2_aktiv:
name: "K1 Termin 2 Aktiv"
icon: mdi:calendar-check
# Bewässerungszeiten in Minuten
# Initiale Einstellung am Besten über die Entwicklerwerkzeuge
# Bsp:
# 420 = 07:00 Uhr
# 1140 = 19:00 Uhr
input_number:
bewaesserung_k1_t1_start:
name: "Startzeit T1 (Min)"
min: 0
max: 1439
bewaesserung_k1_t1_ende:
name: "Endzeit T1 (Min)"
min: 0
max: 1439
bewaesserung_k1_t2_start:
name: "Startzeit T2 (Min)"
min: 0
max: 1439
bewaesserung_k1_t2_ende:
name: "Endzeit T2 (Min)"
min: 0
max: 1439
# Limits für Bewässerung deaktivieren
bewaesserung_k1_limit_moisture:
name: "Grenzwert Bodenfeuchte"
min: 0
max: 99
unit_of_measurement: "%"
bewaesserung_k1_limit_rain_today:
name: "Limit Regen Heute"
min: 0
max: 50
unit_of_measurement: "mm"
bewaesserung_k1_limit_rain_forecast:
name: "Limit Regen Forecast"
min: 0
max: 50
unit_of_measurement: "mm"
template:
- sensor:
- name: "bewaesserung_bodenfeuchte_k1"
unique_id: bewaesserung_bodenfeuchte_k1
unit_of_measurement: "%"
device_class: moisture
# WICHTIG !!!
# Hier den jeweiligen Bodenfeuchtesensor eintragen!
state: "{{ states('sensor.gw1100a_soil_moisture_1') | float(0) }}"
- name: "bewaesserung_k1_logik"
unique_id: garten_bewaesserung_k1_logik
state: >
{# Überprüfung aller Parameter #}
{% set moist = states('sensor.bewaesserung_bodenfeuchte_k1') | float(0) %}
{% set lim_m = states('input_number.bewaesserung_k1_limit_moisture') | float(0) %}
{% set rain = states('sensor.regen_heute') | float(0) %}
{% set lim_r = states('input_number.bewaesserung_k1_limit_rain_today') | float(0) %}
{% set fc = states('sensor.regen_forecast') | float(0) %}
{% set lim_f = states('input_number.bewaesserung_k1_limit_rain_forecast') | float(0) %}
{# Ergebis ist entweder aktiv (wird bewässert) oder inaktiv (pausieren) #}
{% if moist < lim_m and rain < lim_r and fc < lim_f %}
aktiv
{% else %}
inaktiv
{% endif %}
# Simpler binärer Sensor für Dashboard und Automation
- binary_sensor:
- name: "bewaesserung_k1_ready"
unique_id: bewaesserung_k1_ready
device_class: moisture
state: "{{ is_state('sensor.bewaesserung_k1_logik', 'aktiv') }}"
Auch hier gilt für weitere Kreisläufe: "k1" durch "k2", "k3" usw. ersetzen sowie den Namen des Sensors für den Bodenfeuchtesensor (blau markiert) ersetzen.
Automatische Steuerung der Bewässerung
Die eigentliche Bewässerung wird über Automationen in Home Assistant gesteuert. Dabei wird für jeden Kreislauf definiert, wann die Bewässerung starten und wieder beendet werden soll.
Beim Erreichen des Startzeitpunkts wird zunächst geprüft, ob die Bewässerung für diesen Zeitraum aktiviert ist und ob die definierten Bedingungen erfüllt sind – beispielsweise in Bezug auf Bodenfeuchte oder Niederschlag. Erst wenn alle Bedingungen passen, wird der entsprechende Bewässerungskreislauf automatisch gestartet.
In meinem Setup sind die Sonoff-Ventile dabei fortlaufend als switch.garten_bewasserung_1 bis switch.garten_bewasserung_7 benannt, wodurch sich die jeweiligen Kreisläufe einfach über die entsprechende Nummer ansprechen lassen: switch.garten_bewasserung_{{ kreislauf }}.
Zum definierten Endzeitpunkt wird der Kreislauf wieder deaktiviert, sodass die Laufzeit klar begrenzt ist.
Automationen (2) anzeigen
Eigentliche Automation für die Bewässerung
alias: Garten Bewässerung
description: ""
triggers:
- at:
- input_datetime.bewaesserung_k1_t1_start_trigger
- input_datetime.bewaesserung_k1_t2_start_trigger
# - input_datetime.bewaesserung_k2_t1_start_trigger
# - input_datetime.bewaesserung_k2_t2_start_trigger
# Hier die Startzeiten für weiterer Kreisläufe ergänzen
id: start
trigger: time
- at:
- input_datetime.bewaesserung_k1_t1_ende_trigger
- input_datetime.bewaesserung_k1_t2_ende_trigger
# - input_datetime.bewaesserung_k2_t1_ende_trigger
# - input_datetime.bewaesserung_k2_t2_ende_trigger
# Hier die Endzeiten für weiterer Kreisläufe ergänzen
id: stop
trigger: time
actions:
- variables:
parts: "{{ trigger.entity_id.split('_') }}"
kreis_id: "{{ parts[2] }}"
termin_id: "{{ parts[3] }}"
kreis_nr: "{{ kreis_id | replace('k', '') }}"
valv_id: switch.garten_bewasserung_{{ kreis_nr }}
ready_sensor: binary_sensor.bewaesserung_{{ kreis_id }}_ready
active_switch: input_boolean.bewaesserung_{{ kreis_id }}_{{ termin_id }}_aktiv
logik_text: "{{ states('sensor.bewaesserung_' ~ kreis_id ~ '_logik') }}"
- choose:
- conditions:
- condition: trigger
id: start
sequence:
- if:
- condition: template
value_template: >-
{{ is_state(active_switch, 'on') and is_state(ready_sensor,
'on') }}
then:
- target:
entity_id: "{{ valv_id }}"
action: switch.turn_on
- conditions:
- condition: trigger
id: stop
sequence:
- target:
entity_id: "{{ valv_id }}"
action: switch.turn_off
mode: parallel
Automation für die Konvertierung der Triggerzeiten für die Bewässerung von Minutenwerten in Uhrzeiten:
alias: Konvertiere Triggerzeit für Bewässerung
description: Konvertiert die Minutenwerte in Uhrzeiten
triggers:
- trigger: state
entity_id:
- input_number.bewaesserung_k1_t1_start
- input_number.bewaesserung_k1_t1_ende
- input_number.bewaesserung_k1_t2_start
- input_number.bewaesserung_k1_t2_ende
#- input_number.bewaesserung_k2_t1_start
#- input_number.bewaesserung_k2_t1_ende
#- input_number.bewaesserung_k2_t2_start
#- input_number.bewaesserung_k2_t2_ende
actions:
- action: input_datetime.set_datetime
target:
entity_id: input_datetime.{{ trigger.entity_id.split('.')[1] }}_trigger
data:
time: >
{% set minutes = states(trigger.entity_id) | int(0) %} {{
'{:02d}:{:02d}:00'.format(minutes // 60, minutes % 60) }}
Mein Setup zum Nachbauen
Wenn du ein ähnliches System umsetzen möchtest, findest du hier die Komponenten, die ich aktuell verwende bzw. empfehlen kann.
Rasen und Pflanzenbewässerung
Für die eigentliche Bewässerung setze ich auf Komponenten von Gardena, da es hier ein sehr breites Sortiment für unterschiedlichste Anforderungen gibt. Je nach Gartenstruktur lohnt es sich, die einzelnen Bereiche individuell zu planen und die passenden Komponenten auszuwählen.
Gerade bei Rasensprengern sollte man auf die richtige Dimension achten: Zu große Regner benötigen entsprechend mehr Durchfluss, was in Kombination mit smarten SONOFF Bewässerungscomputer SWV-BSP* (Werbung) schnell zum limitierenden Faktor werden kann. Kleinere, gut abgestimmte Regner pro Zone sind hier oft die bessere Wahl.
Ich habe u.a. folgende Komponenten im Einsatz:
- Gardena Versenkregner SD30* (Werbung) - Für kleine Rasenflächen bis 30 m², Reichweite von 1.5-3 m, Anschluss über 25mm Installationsrohr
- Gardena Versenkregner SD80* (Werbung) - für kleine Rasenflächen bis 80 m², Reichweite von 3-5 m, Anschluss über 25mm Installationsrohr
- Gardena Kleinflächendüse* (Werbung) - Sprühdüse für Kleinflächen bis 40 cm Durchmesser, für 13 mm Verlegerohr
- Gardena Reihentropfer* (Werbung) - Regulierbarer Reihentropfer für Pflanzen, 0 bis 15 l/h, für 4.6 mm Verteilerrohr
Steuerung & Sensoren
- SONOFF Bewässerungscomputer SWV-BSP* (Werbung) – das Herzstück der smarten Bewässerung. Pro Kreislauf kommt jeweils ein Ventil zum Einsatz.
- ECOWITT Wetterstation GW1101* (Werbung) – liefert lokale Wetterdaten für die Steuerung.
- ECOWITT Bodenfeuchtigkeitssensor WH51* (Werbung) – ein Sensor pro Zone sorgt für präzise und unabhängige Messwerte.
- Zigbee-Bodenfeuchtesensor* (Werbung) als Alternative.
Zubehör & Infrastruktur
- Gardena Micro-Drip-System Druckminderer* (Werbung) - Wichtig und Voraussetzung für das Micro-Drip-System (Pflanzenbewässerung)
- Gardena Tropfrohr 4.6mm* (Werbung) - Oberirdisch verlegbar, 15m für u.a. Gardena Reihentropfer
- Gardena Verlegerohr 13 mm* (Werbung) - Ober- und unterirdisch verlegbar, 50 m für u.a. Gardena Kleinflächendüse
- Gardena Installationsrohr 25 mm* (Werbung) - Unterirdisch verlegbar, 50 m für u.a. Versenkregner
Zusätzlich sollte bei der Planung unbedingt auf das passende Zubehör geachtet werden – wie Rohrhalter, T-Stücke, L-Stücke oder Verschlussstopfen in den jeweils richtigen Rohrdurchmessern. Gerade diese Kleinteile entscheiden am Ende darüber, wie sauber und zuverlässig das gesamte System aufgebaut ist.