Blueprint: Markisenwächter (automatisches Einfahren bei Wind und noch mehr)

Hallo liebe Community,

da ich schon vieles aus Simons Videos gelernt habe und auch aus der Community das eine oder andere “abgesaugt” habe, ist es für mich an der Zeit, auch einmal etwas zu teilen.

Ich habe einen Blueprint einer Automation erstellt, welcher eine Markise vor Schäden durch Wind und Wetter schützen soll.

Kurze Beschreibung:
Automatisches ein- und ausfahren einer Markise basierend auf Wetterdaten und anderen Sensorwerten.
Die Automation fährt die Markise automatisch ein, wenn starker Wind, Regenschauer oder ein Sensor-Timeout erkannt wird.
Die Markise wird wieder automatisch ausgefahren, wenn der Wind für die konfigurierte Dauer unter den unteren Schwellenwert für die Windgeschwindigkeit fällt und die Markise nicht häufiger als x-mal innerhalb von y Stunden eingefahren wurde.
Eine Sperre verhindert das automatische Ausfahren, wenn die Markise x-mal innerhalb der definierten Zeitspanne eingefahren wurde; der Zähler wird entweder zu einem konfigurierbaren Zeitpunkt oder nach manuellem Ausfahren zurückgesetzt.
Die Automation unterscheidet zwischen automatischer und manueller Bedienung, setzt entsprechende Hilfs-Entitäten und versendet Benachrichtigungen bei allen relevanten Ereignissen, Sensor-Fehlern oder Steuerfehlern.

Da ich als neuer Nutzer den YAML Code nicht als Datei hochladen darf, findet ihr den Code hier im Post. Einfach per File-Editor unter /homeassistant/blueprints/*/*.yaml ablegen und sich der Funktion erfreuen.

Der Code ist bestimmt noch nicht perfekt und ein Schlüsselelement das noch fehlt, ist das automatische Ausfahren der Markise bei Sonnenschein.
Primärer Fokus lag in einem ersten Schritt auf dem Einfahren der Markise.

Sprungmarke:

YAML-Code v1.0:

blueprint:
  name: "Markisenwächter"
  description: >
    Automatisches ein- und ausfahren einer Markise basierend auf Wetterdaten und anderen Sensorwerten. 
    <br><br>
    Die Automation fährt die Markise automatisch ein, wenn starker Wind, Regenschauer oder ein Sensor-Timeout erkannt wird.
    Die Markise wird wieder automatisch ausgefahren, wenn der Wind für die konfigurierte Dauer unter den unteren Schwellenwert für die Windgeschwindigkeit fällt und die Markise nicht häufiger als x-mal innerhalb von y Stunden eingefahren wurde. 
    Eine Sperre verhindert das automatische Ausfahren, wenn die Markise x-mal innerhalb der definierten Zeitspanne eingefahren wurde; der Zähler wird entweder zu einem konfigurierbaren Zeitpunkt oder nach manuellem Ausfahren zurückgesetzt.
    <br><br>
    Die Automation unterscheidet zwischen automatischer und manueller Bedienung, setzt entsprechende Hilfs-Entitäten und versendet Benachrichtigungen bei allen relevanten Ereignissen, Sensor-Fehlern oder Steuerfehlern.
  domain: automation
  input:
    wind_sensor:
      name: "Windgeschwindigkeits-Sensor"
      description: "Der Sensor für die aktuelle Windgeschwindigkeit (km/h)"
      selector:
        entity:
          domain: sensor
    wind_sensor_timeout:
      name: "Windgeschwindigkeits-Sensor - Timeout"
      description: "Dauer (in Minuten) ohne gültigen Wert des Windsensors, ab der die Markise aus Sicherheitsgründen eingefahren wird"
      default: 60
      selector:
        number:
          min: 1
          max: 240
          step: 1
          unit_of_measurement: "min"
    rain_sensor:
      name: "Regensensor (Statistik)"
      description: >
        Statistik-Sensor für Regenmenge (in mm) der letzten x Minuten.<br>
        Ein entsprechender Helfer-Sensor muss ggf. angelegt werden.
      selector:
        entity:
          domain: sensor
    rain_interval:
      name: "Regensensor (Statistik) - Intervall"
      description: >
        Zeitraum der Regenstatistik in Minuten<br>
        (ACHTUNG: Wert muss zum Statistik-Sensor passen!)
      default: 5
      selector:
        number:
          min: 1
          max: 60
          step: 1
          unit_of_measurement: "min"
    markise_status_sensor:
      name: "Markisenstatus (eingefahren/ausgefahren)"
      description: "Sensor, der den Status der Markise darstellt<br>(on = ausgefahren / off = eingefahren)"
      selector:
        entity:
          domain: binary_sensor
    switch_ausfahren:
      name: "Schalter zum Ausfahren der Markise"
      description: "Switch-Entität zum Ausfahren der Markise"
      selector:
        entity:
          domain: switch
    switch_einfahren:
      name: "Schalter zum Einfahren der Markise"
      description: "Switch-Entität zum Einfahren der Markise"
      selector:
        entity:
          domain: switch
    input_boolean_auto_eingefahren:
      name: "Hilfs-Entität: Markise wurde automatisch eingefahren"
      description: "input_boolean ('Schalter') zur Markierung, ob die Markise automatisch eingefahren wurde"
      selector:
        entity:
          domain: input_boolean
    input_boolean_auto_ausgefahren:
      name: "Hilfs-Entität: Markise wurde automatisch ausgefahren"
      description: "input_boolean ('Schalter') zur Markierung, ob die Markise automatisch ausgefahren wurde"
      selector:
        entity:
          domain: input_boolean
    counter_einfahr_count:
      name: "Hilfs-Entität: Einfahrzähler"
      description: "Zähler der automatischen Einfahrvorgänge"
      selector:
        entity:
          domain: counter
    counter_max:
      name: "Maximal erlaubte automatische Einfahrvorgänge"
      description: "Wie oft darf die Markise innerhalb des Zählerzeitraums automatisch eingefahren werden, bevor das automatische Ausfahren gesperrt wird?"
      default: 3
      selector:
        number:
          min: 1
          max: 10
          step: 1
    counter_period:
      name: "Zeitraum maximal erlaubter Einfahrvorgänge"
      description: "Wie viele Stunden werden für die Zählung der automatischen Einfahrvorgänge berücksichtigt?"
      default: 2
      selector:
        number:
          min: 1
          max: 12
          step: 1
    wind_max_threshold:
      name: "Oberer Schwellenwert Windgeschwindigkeit (Einfahren)"
      description: "Windgeschwindigkeit (km/h), ab der die Markise automatisch eingefahren wird"
      default: 27
      selector:
        number:
          min: 10
          max: 40
          step: 1
          unit_of_measurement: "km/h"
    wind_min_threshold:
      name: "Unterer Schwellenwert Windgeschwindigkeit (Ausfahren)"
      description: "Windgeschwindigkeit (km/h), unter der die Markise nach abgeflautem Wind wieder ausgefahren wird"
      default: 20
      selector:
        number:
          min: 0
          max: 30
          step: 1
          unit_of_measurement: "km/h"
    wind_min_duration:
      name: "Dauer für Wind unter Schwellenwert (Ausfahren)"
      description: "Zeitspanne (in Minuten), die der Wind unter dem unteren Schwellenwert liegen muss, damit die Markise wieder automatisch ausgefahren wird"
      default: 12
      selector:
        number:
          min: 1
          max: 120
          step: 1
          unit_of_measurement: "min"
    rain_threshold:
      name: "Schwellenwert Regenmenge in Zeitraum (Einfahren)"
      description: "Regenmenge (mm) lt. Statisik-Sensor, ab welcher die Markise eingefahren wird"
      default: 2
      selector:
        number:
          min: 0
          max: 20
          step: 0.1
          unit_of_measurement: "mm"
    reset_time:
      name: "Zeitpunkt für Zähler-Reset"
      description: "Uhrzeit (im Format HH:MM:SS), zu welcher der Einfahrzähler täglich zurückgesetzt wird"
      default: "00:00:00"
      selector:
        time:

trigger:
  - platform: numeric_state
    entity_id: !input wind_sensor
    above: !input wind_max_threshold
  - platform: state
    entity_id: !input markise_status_sensor
    from: "off"
    to: "on"
  - platform: numeric_state
    entity_id: !input wind_sensor
    below: !input wind_min_threshold
    for:
      minutes: !input wind_min_duration
    id: Wind für x min unter min_Schwelle
  - platform: time
    at: !input reset_time
    id: Reset-Zeitpunkt für Ausfahrzähler
  - platform: numeric_state
    entity_id: !input rain_sensor
    above: !input rain_threshold
  - platform: state
    entity_id: !input wind_sensor
    to:
      - unavailable
      - unknown
    for:
      minutes: !input wind_sensor_timeout
  - platform: state
    entity_id:
        - !input wind_sensor
        - !input markise_status_sensor
        - !input switch_ausfahren
        - !input switch_einfahren
    to:
      - unavailable
      - unknown
    for: "00:15:00"
  - platform: numeric_state
    entity_id: !input counter_einfahr_count
    above: !input counter_max

condition: []

action:
  - choose:
      # EINFAHREN: Starkwind, aber nur wenn Markise offen!
      - conditions:
          - condition: and
            conditions:
              - condition: state
                entity_id: !input markise_status_sensor
                state: "on"
              - condition: numeric_state
                entity_id: !input wind_sensor
                above: !input wind_max_threshold
        sequence:
          - service: switch.turn_on
            target:
              entity_id: !input switch_einfahren
          - service: input_boolean.turn_on
            target:
              entity_id: !input input_boolean_auto_eingefahren
          - service: counter.increment
            target:
              entity_id: !input counter_einfahr_count
          - service: input_boolean.turn_off
            target:
              entity_id: !input input_boolean_auto_ausgefahren
          - service: notify.notify
            data:
              message: "Markise automatisch eingefahren wegen Wind (!input wind_sensor km/h)."
      # WIND > max threshold, Markise aber geschlossen → FEHLERMELDUNG UNTERBINDEN
      - conditions:
          - condition: and
            conditions:
              - condition: state
                entity_id: !input markise_status_sensor
                state:
                  - "off"
                  - "unavailable"
                  - "unknown"
              - condition: numeric_state
                entity_id: !input wind_sensor
                above: !input wind_max_threshold
        sequence: []
      # AUSFAHREN: Nachlassender Wind & Markise vorher automatisch eingefahren & Counter < counter_max (Automatisch)
      - conditions:
          - condition: trigger
            id: Wind für x min unter min_Schwelle
          - condition: state
            entity_id: !input input_boolean_auto_eingefahren
            state: "on"
          - condition: state
            entity_id: !input markise_status_sensor
            state: "off"
          - condition: numeric_state
            entity_id: !input counter_einfahr_count
            below: !input counter_max
        sequence:
          - service: switch.turn_on
            target:
              entity_id: !input switch_ausfahren
          - service: input_boolean.turn_off
            target:
              entity_id: !input input_boolean_auto_eingefahren
          - service: input_boolean.turn_on
            target:
              entity_id: !input input_boolean_auto_ausgefahren
          - service: notify.notify
            data:
              message: "Markise automatisch ausgefahren, Wind unter !input wind_min_threshold km/h für !input wind_min_duration Minuten."
      # COUNTER-RESET: zum konfigurierten Zeitpunkt
      - conditions:
          - condition: trigger
            id: Reset-Zeitpunkt für Ausfahrzähler
        sequence:
          - service: counter.reset
            target:
              entity_id: !input counter_einfahr_count
          - service: input_boolean.turn_off
            target:
              entity_id: !input input_boolean_auto_ausgefahren
      # COUNTER-RESET: Manuelles Ausfahren
      - conditions:
          - condition: state
            entity_id: !input markise_status_sensor
            state: "on"
          - condition: state
            entity_id: !input input_boolean_auto_ausgefahren
            state:
              - "off"
              - "unavailable"
              - "unknown"
        sequence:
          - service: counter.reset
            target:
              entity_id: !input counter_einfahr_count
          - service: notify.notify
            data:
              message: "Markisen-Counter wurde durch manuelles Ausfahren zurückgesetzt."
      # EINFAHREN: Regenschauer
      - conditions:
          - condition: numeric_state
            entity_id: !input rain_sensor
            above: !input rain_threshold
        sequence:
          - service: switch.turn_on
            target:
              entity_id: !input switch_einfahren
          - service: input_boolean.turn_off
            target:
              entity_id: !input input_boolean_auto_ausgefahren
          - service: notify.notify
            data:
              message: "Markise eingefahren wegen Regenschauer (> !input rain_threshold mm/!input rain_interval min)."
      # EINFAHREN: Windsensor-Timeout
      - conditions:
          - condition: state
            entity_id: !input wind_sensor
            state:
              - "unavailable"
              - "unknown"
        sequence:
          - service: switch.turn_on
            target:
              entity_id: !input switch_einfahren
          - service: input_boolean.turn_off
            target:
              entity_id: !input input_boolean_auto_ausgefahren
          - service: notify.notify
            data:
              message: "Windsensor liefert !input wind_sensor_timeout Minuten keine Werte - Markise eingefahren!"
      # BENACHRICHTIGUNG: Sensor-Fehler
      - conditions:
          - condition: template
            value_template: >
              {{ (
                is_state('!input wind_sensor', 'unavailable') or
                is_state('!input wind_sensor', 'unknown') or
                is_state('!input markise_status_sensor', 'unavailable') or
                is_state('!input markise_status_sensor', 'unknown') or
                is_state('!input switch_ausfahren', 'unavailable') or
                is_state('!input switch_ausfahren', 'unknown') or
                is_state('!input switch_einfahren', 'unavailable') or
                is_state('!input switch_einfahren', 'unknown')
              ) }}
        sequence:
          - service: notify.notify
            data:
              message: "Ein oder mehrere Sensoren/Steuerungen sind nicht erreichbar!"
      # BENACHRICHTIGUNG: Ausfahr-Sperre nach X Einfahrvorgängen
      - conditions:
          - condition: numeric_state
            entity_id: !input counter_einfahr_count
            above: !input counter_max
        sequence:
          - service: notify.notify
            data:
              message: "Markise wurde !input counter_max x automatisch eingefahren (!input counter_period h). Automatisches Ausfahren ist gesperrt!"
    default:
      - service: notify.notify
        data:
          message: "Fehler in der Markisen-Automation aufgetreten! Prüfe bitte das Log und die Sensoren/Steuerungen."
mode: parallel

YAML-Code v1.1

(2025-07-22)

Änderungen:

  • Notification im Default geändert - es wird nicht nur auf einen möglichen Fehler hingewiesen, sondern, dass es sich auch um eine unbehandelte Situation (= Sensor-Kombination) handeln kann
  • Lässt der Wind nach (Windstärke x Minuten unter y km/h) hat bislang bei eingefahrener Markise unter bestimmten Bedingungen die Meldung aus dem Default getriggert. Wird nun abgefangen
  • Bei Starkwind und bereits eingefahrener Markise wurde unter bestimmten Bedingungen die Meldung aus dem Default getriggert. Wird nun abgefangen
  • Warnung wird ausgegeben und Schließen der Markise wird initiiert, falls Starkwind registriert wird, der Status der Markise jedoch unbekannt ist.

To-Do:

  • Messwerte werden nicht an Notifications übergeben - Code prüfen. Sollte mit entsprechender Jinja-Formatierung (zB {{ counter_max }} statt !input counter_max) der message:-Felder lösbar sein - muss ich noch testen)
blueprint:
  name: "Markisenwächter"
  description: >
    Automatisches ein- und ausfahren einer Markise basierend auf Wetterdaten und anderen Sensorwerten. 
    <br><br>
    Die Automation fährt die Markise automatisch ein, wenn starker Wind, Regenschauer oder ein Sensor-Timeout erkannt wird.
    Die Markise wird wieder automatisch ausgefahren, wenn der Wind für die konfigurierte Dauer unter den unteren Schwellenwert für die Windgeschwindigkeit fällt und die Markise nicht häufiger als x-mal innerhalb von y Stunden eingefahren wurde. 
    Eine Sperre verhindert das automatische Ausfahren, wenn die Markise x-mal innerhalb der definierten Zeitspanne eingefahren wurde; der Zähler wird entweder zu einem konfigurierbaren Zeitpunkt oder nach manuellem Ausfahren zurückgesetzt.
    <br><br>
    Die Automation unterscheidet zwischen automatischer und manueller Bedienung, setzt entsprechende Hilfs-Entitäten und versendet Benachrichtigungen bei allen relevanten Ereignissen, Sensor-Fehlern oder Steuerfehlern.
  domain: automation
  input:
    wind_sensor:
      name: "Windgeschwindigkeits-Sensor"
      description: "Der Sensor für die aktuelle Windgeschwindigkeit (km/h)"
      selector:
        entity:
          domain: sensor
    wind_sensor_timeout:
      name: "Windgeschwindigkeits-Sensor - Timeout"
      description: "Dauer (in Minuten) ohne gültigen Wert des Windsensors, ab der die Markise aus Sicherheitsgründen eingefahren wird"
      default: 60
      selector:
        number:
          min: 1
          max: 240
          step: 1
          unit_of_measurement: "min"
    rain_sensor:
      name: "Regensensor (Statistik)"
      description: >
        Statistik-Sensor für Regenmenge (in mm) der letzten x Minuten.<br>
        Ein entsprechender Helfer-Sensor muss ggf. angelegt werden.
      selector:
        entity:
          domain: sensor
    rain_interval:
      name: "Regensensor (Statistik) - Intervall"
      description: >
        Zeitraum der Regenstatistik in Minuten<br>
        (ACHTUNG: Wert muss zum Statistik-Sensor passen!)
      default: 5
      selector:
        number:
          min: 1
          max: 60
          step: 1
          unit_of_measurement: "min"
    markise_status_sensor:
      name: "Markisenstatus (eingefahren/ausgefahren)"
      description: "Sensor, der den Status der Markise darstellt<br>(on = ausgefahren / off = eingefahren)"
      selector:
        entity:
          domain: binary_sensor
    switch_ausfahren:
      name: "Schalter zum Ausfahren der Markise"
      description: "Switch-Entität zum Ausfahren der Markise"
      selector:
        entity:
          domain: switch
    switch_einfahren:
      name: "Schalter zum Einfahren der Markise"
      description: "Switch-Entität zum Einfahren der Markise"
      selector:
        entity:
          domain: switch
    input_boolean_auto_eingefahren:
      name: "Hilfs-Entität: Markise wurde automatisch eingefahren"
      description: "input_boolean ('Schalter') zur Markierung, ob die Markise automatisch eingefahren wurde"
      selector:
        entity:
          domain: input_boolean
    input_boolean_auto_ausgefahren:
      name: "Hilfs-Entität: Markise wurde automatisch ausgefahren"
      description: "input_boolean ('Schalter') zur Markierung, ob die Markise automatisch ausgefahren wurde"
      selector:
        entity:
          domain: input_boolean
    counter_einfahr_count:
      name: "Hilfs-Entität: Einfahrzähler"
      description: "Zähler der automatischen Einfahrvorgänge"
      selector:
        entity:
          domain: counter
    counter_max:
      name: "Maximal erlaubte automatische Einfahrvorgänge"
      description: "Wie oft darf die Markise innerhalb des Zählerzeitraums automatisch eingefahren werden, bevor das automatische Ausfahren gesperrt wird?"
      default: 3
      selector:
        number:
          min: 1
          max: 10
          step: 1
    counter_period:
      name: "Zeitraum maximal erlaubter Einfahrvorgänge"
      description: "Wie viele Stunden werden für die Zählung der automatischen Einfahrvorgänge berücksichtigt?"
      default: 2
      selector:
        number:
          min: 1
          max: 12
          step: 1
    wind_max_threshold:
      name: "Oberer Schwellenwert Windgeschwindigkeit (Einfahren)"
      description: "Windgeschwindigkeit (km/h), ab der die Markise automatisch eingefahren wird"
      default: 27
      selector:
        number:
          min: 10
          max: 40
          step: 1
          unit_of_measurement: "km/h"
    wind_min_threshold:
      name: "Unterer Schwellenwert Windgeschwindigkeit (Ausfahren)"
      description: "Windgeschwindigkeit (km/h), unter der die Markise nach abgeflautem Wind wieder ausgefahren wird"
      default: 20
      selector:
        number:
          min: 0
          max: 30
          step: 1
          unit_of_measurement: "km/h"
    wind_min_duration:
      name: "Dauer für Wind unter Schwellenwert (Ausfahren)"
      description: "Zeitspanne (in Minuten), die der Wind unter dem unteren Schwellenwert liegen muss, damit die Markise wieder automatisch ausgefahren wird"
      default: 12
      selector:
        number:
          min: 1
          max: 120
          step: 1
          unit_of_measurement: "min"
    rain_threshold:
      name: "Schwellenwert Regenmenge in Zeitraum (Einfahren)"
      description: "Regenmenge (mm) lt. Statisik-Sensor, ab welcher die Markise eingefahren wird"
      default: 2
      selector:
        number:
          min: 0
          max: 20
          step: 0.1
          unit_of_measurement: "mm"
    reset_time:
      name: "Zeitpunkt für Zähler-Reset"
      description: "Uhrzeit (im Format HH:MM:SS), zu welcher der Einfahrzähler täglich zurückgesetzt wird"
      default: "00:00:00"
      selector:
        time:

trigger:
  - platform: numeric_state
    entity_id: !input wind_sensor
    above: !input wind_max_threshold
  - platform: state
    entity_id: !input markise_status_sensor
    from: "off"
    to: "on"
  - platform: numeric_state
    entity_id: !input wind_sensor
    below: !input wind_min_threshold
    for:
      minutes: !input wind_min_duration
    id: Wind für x min unter min_Schwelle
  - platform: time
    at: !input reset_time
    id: Reset-Zeitpunkt für Ausfahrzähler
  - platform: numeric_state
    entity_id: !input rain_sensor
    above: !input rain_threshold
  - platform: state
    entity_id: !input wind_sensor
    to:
      - unavailable
      - unknown
    for:
      minutes: !input wind_sensor_timeout
  - platform: state
    entity_id:
        - !input wind_sensor
        - !input markise_status_sensor
        - !input switch_ausfahren
        - !input switch_einfahren
    to:
      - unavailable
      - unknown
    for: "00:15:00"
  - platform: numeric_state
    entity_id: !input counter_einfahr_count
    above: !input counter_max

condition: []

action:
  - choose:
      # EINFAHREN: Starkwind, aber nur wenn Markise offen!
      - conditions:
          - condition: and
            conditions:
              - condition: state
                entity_id: !input markise_status_sensor
                state: "on"
              - condition: numeric_state
                entity_id: !input wind_sensor
                above: !input wind_max_threshold
        sequence:
          - service: switch.turn_on
            target:
              entity_id: !input switch_einfahren
          - service: input_boolean.turn_on
            target:
              entity_id: !input input_boolean_auto_eingefahren
          - service: counter.increment
            target:
              entity_id: !input counter_einfahr_count
          - service: input_boolean.turn_off
            target:
              entity_id: !input input_boolean_auto_ausgefahren
          - service: notify.notify
            data:
              message: "Markise automatisch eingefahren wegen Wind (!input wind_sensor km/h)."
      # WIND > max threshold, Markise aber geschlossen → FEHLERMELDUNG UNTERBINDEN
      - conditions:
          - condition: and
            conditions:
              - condition: state
                entity_id: !input markise_status_sensor
                state:
                  - "off"
                  - "unavailable"
                  - "unknown"
              - condition: numeric_state
                entity_id: !input wind_sensor
                above: !input wind_max_threshold
        sequence: []
      # AUSFAHREN: Nachlassender Wind & Markise vorher automatisch eingefahren & Counter < counter_max (Automatisch)
      - conditions:
          - condition: trigger
            id: Wind für x min unter min_Schwelle
          - condition: state
            entity_id: !input input_boolean_auto_eingefahren
            state: "on"
          - condition: state
            entity_id: !input markise_status_sensor
            state: "off"
          - condition: numeric_state
            entity_id: !input counter_einfahr_count
            below: !input counter_max
        sequence:
          - service: switch.turn_on
            target:
              entity_id: !input switch_ausfahren
          - service: input_boolean.turn_off
            target:
              entity_id: !input input_boolean_auto_eingefahren
          - service: input_boolean.turn_on
            target:
              entity_id: !input input_boolean_auto_ausgefahren
          - service: notify.notify
            data:
              message: "Markise automatisch ausgefahren, Wind unter !input wind_min_threshold km/h für !input wind_min_duration Minuten."
      # COUNTER-RESET: zum konfigurierten Zeitpunkt
      - conditions:
          - condition: trigger
            id: Reset-Zeitpunkt für Ausfahrzähler
        sequence:
          - service: counter.reset
            target:
              entity_id: !input counter_einfahr_count
          - service: input_boolean.turn_off
            target:
              entity_id: !input input_boolean_auto_ausgefahren
      # COUNTER-RESET: Manuelles Ausfahren
      - conditions:
          - condition: state
            entity_id: !input markise_status_sensor
            state: "on"
          - condition: state
            entity_id: !input input_boolean_auto_ausgefahren
            state:
              - "off"
              - "unavailable"
              - "unknown"
        sequence:
          - service: counter.reset
            target:
              entity_id: !input counter_einfahr_count
          - service: notify.notify
            data:
              message: "Markisen-Counter wurde durch manuelles Ausfahren zurückgesetzt."
      # EINFAHREN: Regenschauer
      - conditions:
          - condition: numeric_state
            entity_id: !input rain_sensor
            above: !input rain_threshold
        sequence:
          - service: switch.turn_on
            target:
              entity_id: !input switch_einfahren
          - service: input_boolean.turn_off
            target:
              entity_id: !input input_boolean_auto_ausgefahren
          - service: notify.notify
            data:
              message: "Markise eingefahren wegen Regenschauer (> !input rain_threshold mm/!input rain_interval min)."
      # EINFAHREN: Windsensor-Timeout
      - conditions:
          - condition: state
            entity_id: !input wind_sensor
            state:
              - "unavailable"
              - "unknown"
        sequence:
          - service: switch.turn_on
            target:
              entity_id: !input switch_einfahren
          - service: input_boolean.turn_off
            target:
              entity_id: !input input_boolean_auto_ausgefahren
          - service: notify.notify
            data:
              message: "Windsensor liefert !input wind_sensor_timeout Minuten keine Werte - Markise eingefahren!"
      # BENACHRICHTIGUNG: Sensor-Fehler
      - conditions:
          - condition: template
            value_template: >
              {{ (
                is_state('!input wind_sensor', 'unavailable') or
                is_state('!input wind_sensor', 'unknown') or
                is_state('!input markise_status_sensor', 'unavailable') or
                is_state('!input markise_status_sensor', 'unknown') or
                is_state('!input switch_ausfahren', 'unavailable') or
                is_state('!input switch_ausfahren', 'unknown') or
                is_state('!input switch_einfahren', 'unavailable') or
                is_state('!input switch_einfahren', 'unknown')
              ) }}
        sequence:
          - service: notify.notify
            data:
              message: "Ein oder mehrere Sensoren/Steuerungen sind nicht erreichbar!"
      # BENACHRICHTIGUNG: Ausfahr-Sperre nach X Einfahrvorgängen
      - conditions:
          - condition: numeric_state
            entity_id: !input counter_einfahr_count
            above: !input counter_max
        sequence:
          - service: notify.notify
            data:
              message: "Markise wurde !input counter_max x automatisch eingefahren (!input counter_period h). Automatisches Ausfahren ist gesperrt!"
      # EINFAHREN & BENACHRICHTIGUNG: Starkwind, aber Markisenstatus unbekannt
      - conditions:
          - condition: and
            conditions:
              - condition: state
                entity_id: !input markise_status_sensor
                state: "off"
              - condition: template
                value_template: >
                  {{ (
                    is_state('!input wind_sensor', 'unavailable') or
                    is_state('!input wind_sensor', 'unknown')
                  ) }}
        sequence:
          - service: notify.notify
            data:
              message: "ACHTUNG!!! Starkwind erkannt - Markisenstatus unbekannt! Versuche Markise zu schließen!"
          - service: switch.turn_on
            target:
              entity_id: !input switch_einfahren
      # FEHLER ABFANGEN: Nachlassender Wind, Markise aber bereits geschlossen - tue nichts
      - conditions:
          - condition: trigger
            id: Wind für x min unter min_Schwelle
          - condition: state
            entity_id: !input markise_status_sensor
            state: "off"
        sequence: []
      # FEHLER ABFANGEN: Starkwind, aber Markise ist gechlossen
      - conditions:
          - condition: and
            conditions:
              - condition: state
                entity_id: !input markise_status_sensor
                state: "off"
              - condition: numeric_state
                entity_id: !input wind_sensor
                above: !input wind_max_threshold
        sequence: []

    default:
      - service: notify.notify
        data:
          message: "Fehler oder unbehandelte Situation in der Markisen-Automation aufgetreten! Prüfe bitte das Log und die Sensoren/Steuerungen."
mode: parallel

Screenshots

So sieht das ganze bei mir dann im Konfigurierten Zustand aus:


Bitte gerne Verbesserungsvorschläge posten - für konstruktive Kritik bin ich immer offen.

Beste Grüße,
Mat

6 „Gefällt mir“

Das hört sich gut an. Ich habe mir einen Wetterstation gekauft für meine Markisen. Werde es mal ausprobieren.

1 „Gefällt mir“

Ich habe festgestellt, dass die Messages (also die Benachrichtigungen über den Notify-Dienst) noch nicht ganz passen (Werte werden nicht sauber übergeben - hier muss man vmtl. auf die korrekte Jinja-Formatierung achten mit zB {{ counter_max }} statt !input counter_max. Sobald ich das geprüft habe, werde ich das im Code adaptierten.

Inzwischen habe ich aber ein paar andere Szenarien im Code abgefangen, welche früher den Default ausgelöst haben (Nachricht "Fehler in der Markisen-Automation aufgetreten! Prüfe bitte das Log und die Sensoren/Steuerungen.") - zB wenn der Wind nachlässt, die Markise aber ohnehin eingefahren ist.

Version 1.1

LG,
Mat

Hallo,
eventuell wäre es von Vorteil, wenn du noch in die Dokumentation aufnimmst welche Hilfsentitäten in welchem Format benötigt werden. Ansonsten ist es eine top Arbeit. Vielen Dank.

Danke für den Input!
Bzgl. der Hilfs-Entitäten: Die input_booleans (bzw. “Schalter”/“Switch” im UI) sollten klar sein - beim Zähler muss ich nachschärfen

Ich habe den Code weiter verfeinert bzw. korrigiert.

YAML-Code v1.2

(2025-07-23)

Änderungen:

  • Detailliertere Dokumentation der benötigten Entitäten
  • Karteileiche “Regensensor (Statistik) - Intervall” entfernt
  • Umbenennungen einiger Inputs
  • Erweiterung um zusätzliche Bedingungs-Zweige, um folgende Szenarien explizit zu behandeln und Default-Meldungen zu vermeiden:
    • Nachlassender Wind, Markise bereits ausgefahren
    • Regenschauer, Markise bereits eingefahren
    • Counter-Überlauf, Markise bereits eingefahren
    • Windsensor-Timeout, Markise bereits eingefahren
  • Das Default-Handling wird damit weiter minimiert und die Automation zuverlässiger.
# Changelog:
# v1 - initiale Release mit Basisfunktionen
#
# v1.1 (2025-07-22):
# - Finetuning der Notification im Default (statt auf einen möglichen Fehler wird auch auf eine mögliche
#   unbekannte Sensor-Kombitnation hingewiesen)
# - Bei nachlassendem Wind wurde unter bestimmten Bedingungen der Default-Teil des Ablaufes getriggert - korrigiert
# - Bei Starkwind und eingefahrener Markise wurde der Default-Teil des Ablaufes getriggert - korrigiert
# - Warnung wird ausgegeben und ein Schließen der Markise initiiert, falls Starkwind aufkommt, der Status der Markise
#   jedoch unbekannt ist
#
# v1.2 (2025-07-23):
# - Detailliertere Dokumentation der benötigten Entitäten
# - Karteileiche "Regensensor (Statistik) - Intervall" entfernt
# - Umbenennungen einiger Inputs
# - Erweiterung um zusätzliche Bedingungs-Zweige, um folgende Szenarien explizit zu behandeln und Default-Meldungen zu vermeiden:
#   - Nachlassender Wind, Markise bereits ausgefahren
#   - Regenschauer, Markise bereits eingefahren
#   - Counter-Überlauf, Markise bereits eingefahren
#   - Windsensor-Timeout, Markise bereits eingefahren
# - Das Default-Handling wird damit weiter minimiert und die Automation zuverlässiger.

blueprint:
  name: "Markisenwächter v1.2"
  description: >
    <br><h2>Beschreibung</h2>
    Automatisches ein- und ausfahren einer Markise basierend auf Wetterdaten und anderen Sensorwerten. 
    <br><br>
    Die Automation fährt die Markise automatisch ein, wenn starker Wind, Regenschauer oder ein Sensor-Timeout erkannt wird.
    Die Markise wird wieder automatisch ausgefahren, wenn der Wind für die konfigurierte Dauer unter den unteren Schwellenwert für die Windgeschwindigkeit fällt und die Markise nicht häufiger als 3-mal innerhalb von 2 Stunden eingefahren wurde. 
    Eine Sperre verhindert das automatische Ausfahren, wenn die Markise x-mal innerhalb der definierten Zeitspanne eingefahren wurde; der Zähler wird entweder zu einem konfigurierbaren Zeitpunkt oder nach manuellem Ausfahren zurückgesetzt.
    <br><br>
    Die Automation unterscheidet zwischen automatischer und manueller Bedienung, setzt entsprechende Hilfs-Entitäten und versendet Benachrichtigungen bei allen relevanten Ereignissen, Sensor-Fehlern oder Steuerfehlern.
    <br><br>
    Community-Thread zu diesem Blueprint:<br>
    [Blueprint: Markisenwächter (automatisches Einfahren bei Wind und noch mehr)](https://community.simon42.com/t/blueprint-markisenwaechter-automatisches-einfahren-bei-wind-und-noch-mehr/60493)
  domain: automation
  input:
    wind_sensor:
      name: "Windgeschwindigkeits-Sensor"
      description: >
        Der Sensor für die aktuelle Windgeschwindigkeit<br>
        Empfohlen ist ein Sensor, welcher den Maximal-Wind bzw. die Böe ausgibt.<br>
        Einheit: `km/h`
      selector:
        entity:
          domain: sensor
    wind_sensor_timeout:
      name: "Windgeschwindigkeits-Sensor - Timeout"
      description: >
        Zeit (in Minuten), nach welcher die Markise aus Sicherheitsgründen eingefahren wird, sollte der Windgeschwindigkeits-
        Sensor keinen gültigen Wert liefern.
      default: 60
      selector:
        number:
          min: 1
          max: 240
          step: 1
          unit_of_measurement: "min"
    rain_sensor:
      name: "Regensensor (Statistik)"
      description: >
        Statistik-Sensor für Regenmenge (in mm) der letzten x Minuten. Sollte den Niederschlag in einem
        möglichst kurzen Zeitraum summieren, um schnell auf Regen reagieren zu könnnen. Der Zeitraum darf
        jedoch auch **nicht zu kurz** sein, da viele Regensensoren den Niederschlag nur in 1mm-Schritten
        messen. Die korrekte Balance ist ausschlaggebend und ist individuell zu eruieren.<br><br>
        Ein entsprechender Helfer-Sensor muss ggf. angelegt werden:<br>
        `Einstellungen → Geräte & Dienste → Helfer → Helfer erstellen → Statistik`<br>
        **Entität:** dein Regensensor (=Quellsensor für die Berechnung)<br>
        **Statistikmerkmal:** Summe der Differenzen<br>
        **Stichprobengröße:** [Quellsensor-Updates / Minute] x [Maximalalter] + [kleiner Puffer]<br>
        **Maximalalter:** zB 5 Minuten<br>
        **Letzten Messwert behalten**: nein<br>
        **Genauigkeit:** 1
      selector:
        entity:
          domain: sensor
    markise_status_sensor:
      name: "Markisenstatus (eingefahren/ausgefahren)"
      description: "Sensor, der den Status der Markise darstellt<br>(`on = ausgefahren` | `off = eingefahren`)"
      selector:
        entity:
          domain: binary_sensor
    switch_ausfahren:
      name: "Schalter zum Ausfahren der Markise"
      description: "Switch-Entität zum Ausfahren der Markise"
      selector:
        entity:
          domain: switch
    switch_einfahren:
      name: "Schalter zum Einfahren der Markise"
      description: "Switch-Entität zum Einfahren der Markise"
      selector:
        entity:
          domain: switch
    input_boolean_auto_eingefahren:
      name: "Hilfs-Entität: Markise wurde automatisch eingefahren"
      description: >
        `input_boolean` ('Schalter') zur Markierung, ob die Markise automatisch eingefahren wurde.
        Wird an mehreren Stellen im Ablauf des Codes benötigt. Es wird auf eine Hilfsentität zurückgeriffen, um auch nach einem Neustart
        den korrekten Ablauf der Automation zu gewährleisten.<br>
        Über das UI ist dieser über `Einstellungen → Geräte & Dienste → Helfer → Helfer erstellen → Schalter` anzulegen.
      selector:
        entity:
          domain: input_boolean
    input_boolean_auto_ausgefahren:
      name: "Hilfs-Entität: Markise wurde automatisch ausgefahren"
      description: >
        `input_boolean` ('Schalter') zur Markierung, ob die Markise automatisch ausgefahren wurde.
        ird an mehreren Stellen im Ablauf des Codes benötigt. Es wird auf eine Hilfsentität zurückgeriffen, um auch nach einem Neustart
        den korrekten Ablauf der Automation zu gewährleisten.<br>
        Über das UI ist dieser über `Einstellungen → Geräte & Dienste → Helfer → Helfer erstellen → Schalter` anzulegen.
      selector:
        entity:
          domain: input_boolean
    counter_einfahr_count:
      name: "Hilfs-Entität: Einfahrzähler"
      description: >
        Zählt die automatischen Einfahrvorgänge. Ab dem unter `Maximal erlaubte automatische Einfahrvorgänge` eingestellten Wert
        wird die Markise bis zu einem Reset des Zählers (durch manuelles Ausfahren, oder zum `Zeitpunkt für Zähler-Reset`) nicht
        mehr automatisch ausgefahren.<br>
        Als Type wird ein `counter` erwartet. Über das UI ist dieser über `Einstellungen → Geräte & Dienste → Helfer → Helfer
        erstellen → Zähler` anzulegen.<br>
        **Einstellungen:** `Minimalwert = 0` | `Maximalwert = 10` | `Anfangswert = 0` | `Schrittweite = 1`
      selector:
        entity:
          domain: counter
    counter_max:
      name: "Maximal erlaubte automatische Einfahrvorgänge"
      description: "Wie oft darf die Markise innerhalb des Zählerzeitraums automatisch eingefahren werden, bevor das automatische Ausfahren gesperrt wird?"
      default: 3
      selector:
        number:
          min: 1
          max: 10
          step: 1
    counter_period:
      name: "Zeitraum maximal erlaubter Einfahrvorgänge"
      description: "Wie viele Stunden werden für die Zählung der automatischen Einfahrvorgänge berücksichtigt?"
      default: 2
      selector:
        number:
          min: 1
          max: 12
          step: 1
    wind_max_threshold:
      name: "Oberer Schwellenwert Windgeschwindigkeit (Einfahren)"
      description: "Windgeschwindigkeit (km/h), ab der die Markise automatisch eingefahren wird"
      default: 27
      selector:
        number:
          min: 10
          max: 40
          step: 1
          unit_of_measurement: "km/h"
    wind_min_threshold:
      name: "Unterer Schwellenwert Windgeschwindigkeit (Ausfahren)"
      description: "Windgeschwindigkeit (km/h), unter der die Markise nach abgeflautem Wind wieder ausgefahren wird"
      default: 20
      selector:
        number:
          min: 0
          max: 30
          step: 1
          unit_of_measurement: "km/h"
    wind_min_duration:
      name: "Dauer für Wind unter Schwellenwert (Ausfahren)"
      description: "Zeitspanne (in Minuten), die der Wind unter dem unteren Schwellenwert liegen muss, damit die Markise wieder automatisch ausgefahren wird"
      default: 12
      selector:
        number:
          min: 1
          max: 120
          step: 1
          unit_of_measurement: "min"
    rain_threshold:
      name: "Schwellenwert Regenmenge (Einfahren)"
      description: >
        Regenmenge (mm) lt. Statisik-Sensor, ab welcher die Markise eingefahren wird.
        Wichtig zu berücksichtigen: Der Wert sollte zum Schutz der Markise möglichst niedrig sein.
      default: 2
      selector:
        number:
          min: 0
          max: 20
          step: 0.1
          unit_of_measurement: "mm"
    reset_time:
      name: "Zeitpunkt für Zähler-Reset"
      description: "Uhrzeit (im Format HH:MM:SS), zu welcher der Einfahrzähler täglich zurückgesetzt wird"
      default: "00:00:00"
      selector:
        time:

variables:
  wind_min_threshold: !input wind_min_threshold
  wind_min_duration: !input wind_min_duration
  rain_threshold: !input rain_threshold
  wind_sensor: !input wind_sensor
  wind_sensor_timeout: !input wind_sensor_timeout
  counter_max: !input counter_max
  counter_period: !input counter_period

trigger:
  - platform: numeric_state
    entity_id: !input wind_sensor
    above: !input wind_max_threshold
  - platform: state
    entity_id: !input markise_status_sensor
    from: "off"
    to: "on"
  - platform: numeric_state
    entity_id: !input wind_sensor
    below: !input wind_min_threshold
    for:
      minutes: !input wind_min_duration
    id: Wind für x min unter min_Schwelle
  - platform: time
    at: !input reset_time
    id: Reset-Zeitpunkt für Ausfahrzähler
  - platform: numeric_state
    entity_id: !input rain_sensor
    above: !input rain_threshold
  - platform: state
    entity_id: !input wind_sensor
    to:
      - unavailable
      - unknown
    for:
      minutes: !input wind_sensor_timeout
  - platform: state
    entity_id:
        - !input wind_sensor
        - !input markise_status_sensor
        - !input switch_ausfahren
        - !input switch_einfahren
    to:
      - unavailable
      - unknown
    for: "00:15:00"
  - platform: numeric_state
    entity_id: !input counter_einfahr_count
    above: !input counter_max

condition: []

action:
  - choose:
      # EINFAHREN: Starkwind, aber nur wenn Markise offen!
      - conditions:
          - condition: and
            conditions:
              - condition: state
                entity_id: !input markise_status_sensor
                state: "on"
              - condition: numeric_state
                entity_id: !input wind_sensor
                above: !input wind_max_threshold
        sequence:
          - service: switch.turn_on
            target:
              entity_id: !input switch_einfahren
          - service: input_boolean.turn_on
            target:
              entity_id: !input input_boolean_auto_eingefahren
          - service: counter.increment
            target:
              entity_id: !input counter_einfahr_count
          - service: input_boolean.turn_off
            target:
              entity_id: !input input_boolean_auto_ausgefahren
          - service: notify.notify
            data:
              message: "Markise automatisch eingefahren wegen Wind ({{ states(wind_sensor) }} km/h)."
              
      # WIND > max threshold, Markise aber geschlossen → FEHLERMELDUNG UNTERBINDEN
      - conditions:
          - condition: and
            conditions:
              - condition: state
                entity_id: !input markise_status_sensor
                state:
                  - "off"
              - condition: numeric_state
                entity_id: !input wind_sensor
                above: !input wind_max_threshold
        sequence: []
        
      # Windsensor-Timeout, aber Markise ist schon eingefahren
      - conditions:
          - condition: state
            entity_id: !input wind_sensor
            state:
              - "unavailable"
              - "unknown"
          - condition: state
            entity_id: !input markise_status_sensor
            state: "off"
        sequence: []
        
      # AUSFAHREN: Nachlassender Wind & Markise vorher automatisch eingefahren & Counter < counter_max (Automatisch)
      - conditions:
          - condition: trigger
            id: Wind für x min unter min_Schwelle
          - condition: state
            entity_id: !input input_boolean_auto_eingefahren
            state: "on"
          - condition: state
            entity_id: !input markise_status_sensor
            state: "off"
          - condition: numeric_state
            entity_id: !input counter_einfahr_count
            below: !input counter_max
        sequence:
          - service: switch.turn_on
            target:
              entity_id: !input switch_ausfahren
          - service: input_boolean.turn_off
            target:
              entity_id: !input input_boolean_auto_eingefahren
          - service: input_boolean.turn_on
            target:
              entity_id: !input input_boolean_auto_ausgefahren
          - service: notify.notify
            data:
              message: "Markise automatisch ausgefahren, Wind ist seit {{ wind_min_duration }} Minuten unter {{ wind_min_threshold }} km/h."
              
      # COUNTER-RESET: zum konfigurierten Zeitpunkt
      - conditions:
          - condition: trigger
            id: Reset-Zeitpunkt für Ausfahrzähler
        sequence:
          - service: counter.reset
            target:
              entity_id: !input counter_einfahr_count
          - service: input_boolean.turn_off
            target:
              entity_id: !input input_boolean_auto_ausgefahren
              
      # COUNTER-RESET: Manuelles Ausfahren
      - conditions:
          - condition: state
            entity_id: !input markise_status_sensor
            state: "on"
          - condition: state
            entity_id: !input input_boolean_auto_ausgefahren
            state:
              - "off"
              - "unavailable"
              - "unknown"
        sequence:
          - service: counter.reset
            target:
              entity_id: !input counter_einfahr_count
          - service: notify.notify
            data:
              message: "Markisen-Counter wurde durch manuelles Ausfahren zurückgesetzt."
              
      # EINFAHREN: Regenschauer
      - conditions:
          - condition: numeric_state
            entity_id: !input rain_sensor
            above: !input rain_threshold
        sequence:
          - service: switch.turn_on
            target:
              entity_id: !input switch_einfahren
          - service: input_boolean.turn_off
            target:
              entity_id: !input input_boolean_auto_ausgefahren
          - service: notify.notify
            data:
              message: "Markise eingefahren wegen Regenschauer (> {{ rain_threshold }} mm)."
              
      # Regenschauer, aber Markise ist schon eingefahren
      - conditions:
          - condition: numeric_state
            entity_id: !input rain_sensor
            above: !input rain_threshold
          - condition: state
            entity_id: !input markise_status_sensor
            state: "off"
        sequence: []
        
      # EINFAHREN: Windsensor-Timeout
      - conditions:
          - condition: state
            entity_id: !input wind_sensor
            state:
              - "unavailable"
              - "unknown"
        sequence:
          - service: switch.turn_on
            target:
              entity_id: !input switch_einfahren
          - service: input_boolean.turn_off
            target:
              entity_id: !input input_boolean_auto_ausgefahren
          - service: notify.notify
            data:
              message: "Windsensor liefert seit {{ wind_sensor_timeout }} Minuten keine Werte - Markise eingefahren!"
              
      # Nachlassender Wind, aber Markise ist bereits ausgefahren
      - conditions:
          - condition: trigger
            id: Wind für x min unter min_Schwelle
          - condition: state
            entity_id: !input markise_status_sensor
            state: "on"
        sequence: []
        
      # BENACHRICHTIGUNG: Sensor-Fehler
      - conditions:
          - condition: template
            value_template: >
              {{ (
                is_state('!input wind_sensor', 'unavailable') or
                is_state('!input wind_sensor', 'unknown') or
                is_state('!input markise_status_sensor', 'unavailable') or
                is_state('!input markise_status_sensor', 'unknown') or
                is_state('!input switch_ausfahren', 'unavailable') or
                is_state('!input switch_ausfahren', 'unknown') or
                is_state('!input switch_einfahren', 'unavailable') or
                is_state('!input switch_einfahren', 'unknown')
              ) }}
        sequence:
          - service: notify.notify
            data:
              message: "Ein oder mehrere Sensoren/Steuerungen sind nicht erreichbar!"
              
      # BENACHRICHTIGUNG: Ausfahr-Sperre nach X Einfahrvorgängen
      - conditions:
          - condition: numeric_state
            entity_id: !input counter_einfahr_count
            above: !input counter_max
        sequence:
          - service: notify.notify
            data:
              message: "Markise wurde innerhalb von {{ counter_period }} Stunden {{ counter_max }}x automatisch eingefahren. Automatisches Ausfahren ist gesperrt!"
              
      # Counter-Überlauf, aber Markise ist schon eingefahren
      - conditions:
          - condition: numeric_state
            entity_id: !input counter_einfahr_count
            above: !input counter_max
          - condition: state
            entity_id: !input markise_status_sensor
            state: "off"
        sequence: []
        
    default:
      - service: notify.notify
        data:
          message: "Fehler oder unbekannte Situaiton in der Markisen-Automation aufgetreten! Prüfe bitte das Log und die Sensoren/Steuerungen."
mode: parallel
2 „Gefällt mir“

Es gibt noch ein paar Kleinigkeiten im Code, die noch nicht passen.
Durch eine etwas krude Reihenfolge der Zustandsabfragen werden teilweise Benachrichtigungen ausgelöst, die keinen Sinn ergeben.

Ich habe den Code überarbeitet (die Entscheidungspfade sind nun durch IF-Schleifen innerhalb einzelner Choose-Blöcke unterteilt, wobei jeder Choose-Block einem Trigger entspricht).
Bevor ich den neuen Code hier veröffentliche, werde ich ihn noch etwas testen - ich bitte um etwas Geduld!

1 „Gefällt mir“

YAML-Code v1.4

(2027-08-07)

Änderungen:

  • Code-Struktur vollständig überarbeitet
  • IDs in Vorbereitung auf eine Übersetzung ins Englische auf Englisch formuliert
  • Einheitliche Nutzung von choose-Blöcken mit trigger.id statt kombinierter Bedingungen
  • Bessere Trennung von Aktionen, Bedingungen und Auslösern
  • Dokumentation deutlich klarer und strukturierter formuliert
  • Blueprint-Inputs neu strukturiert und besser gruppiert
  • Automatisches Ausfahren: Nur bei gleichzeitig unterminimiertem Wind und keinem Regen
  • Reset der Helfer (input.boolean) erfolgt nun gemeinsam mit dem Zähler
  • Klare Trennung zwischen manuellem und automatischem Aus- oder Einfahren
  • Grenzwert für automatische Einfahrvorgänge frei wählbar (automatic_retract_count_threshold)
    und Hinweis per Notification bei Überschreitung
  • Sensor-Filter für Inputs aufgenommen
# Changelog:
# v1 - initiale Release mit Basisfunktionen
#
# v1.1 (2025-07-22):
# - Finetuning der Notification im Default (statt auf einen möglichen Fehler wird auch auf eine mögliche
#   unbekannte Sensor-Kombitnation hingewiesen)
# - Bei nachlassendem Wind wurde unter bestimmten Bedingungen der Default-Teil des Ablaufes getriggert - korrigiert
# - Bei Starkwind und eingefahrener Markise wurde der Default-Teil des Ablaufes getriggert - korrigiert
# - Warnung wird ausgegeben und ein Schließen der Markise initiiert, falls Starkwind aufkommt, der Status der Markise
#   jedoch unbekannt ist
#
# v1.2 (2025-07-23):
# - Detailliertere Dokumentation der benötigten Entitäten
# - Karteileiche "Regensensor (Statistik) - Intervall" entfernt
# - Umbenennungen einiger Inputs
# - Erweiterung um zusätzliche Bedingungs-Zweige, um folgende Szenarien explizit zu behandeln und Default-Meldungen zu vermeiden:
#   - Nachlassender Wind, Markise bereits ausgefahren
#   - Regenschauer, Markise bereits eingefahren
#   - Counter-Überlauf, Markise bereits eingefahren
#   - Windsensor-Timeout, Markise bereits eingefahren
# - Das Default-Handling wird damit weiter minimiert und die Automation zuverlässiger.
#
# v1.3 (2025-07-27):
# Kompletter Neuaufbau der zugrundeliegenden Automation:
#  - Code-Struktur vollständig überarbeitet
#  - IDs in Vorbereitung auf eine Übersetzung ins Englische auf Englisch formuliert
#  - Einheitliche Nutzung von choose-Blöcken mit trigger.id statt kombinierter Bedingungen
#  - Bessere Trennung von Aktionen, Bedingungen und Auslösern
#  - Dokumentation deutlich klarer und strukturierter formuliert
#  - Blueprint-Inputs neu strukturiert und besser gruppiert
#  - Automatisches Ausfahren: Nur bei gleichzeitig unterminimiertem Wind und keinem Regen
#  - Reset der Helfer (input.booleans) erfolgt nun gemeinsam mit dem Zähler 
#  - Klare Trennung zwischen manuellem und automatischem Aus- oder Einfahren
#  - Grenzwert für automatische Einfahrvorgänge frei wählbar (automatic_retract_count_threshold)
#    und Hinweis per Notification bei Überschreitung
#
# v1.4 (2025-08-07)
# - Sensor-Filter für Inputs aufgenommen


blueprint:
  name: Markisenwächter 1.4
  description: |
    Dieser Blueprint bietet eine erweiterte Automatisierung für eine Markise basierend auf verschiedenen Sensordaten wie Wind und Regen.
    ### Funktionen:
    * **Windüberwachung:** Fährt die Markise automatisch ein, wenn eine konfigurierbare Windgeschwindigkeit überschritten wird.
    * **Regenüberwachung:** Fährt die Markise automatisch ein, wenn eine konfigurierbare Regenmenge innerhalb eines Zeitraums erkannt wird.
    * **Wind-Timeout:** Fährt die Markise sicherheitshalber ein, wenn der Windsensor für eine bestimmte Zeit nicht erreichbar ist.
    * **Sensor-Überwachung:** Sendet eine Benachrichtigung, wenn wichtige Sensoren wie Wind, Markisenstatus oder die Steuerungs-Switches nicht erreichbar sind.
    * **Automatisches Ausfahren:** Fährt die Markise wieder aus, wenn der Wind unter den Grenzwert fällt und kein Regen erkannt wird.
    * **Zählerschutz:** Zählt die automatischen Einfahrvorgänge. Bei Überschreiten eines Grenzwertes wird eine Benachrichtigung gesendet und ein weiteres Ausfahren unterbunden, um ein häufiges, unnötiges Ein- und Ausfahren zu verhindern.
    * **Manuelle Steuerung:** Erkennt manuelle Eingriffe (Aus- und Einfahren) und setzt interne Zähler zurück oder passt Status-Helfer an.
    * **Täglicher Reset:** Setzt den Einfahr-Zähler und die internen Status-Helfer täglich zurück.
    ### Notwendige Konfiguration:
    Dieser Blueprint erfordert die Konfiguration der folgenden Helfer (helpers) in Home Assistant:
    1.  Ein `input_boolean` für den Status „Markise automatisch eingefahren“.
    2.  Ein `input_boolean` für den Status „Markise automatisch ausgefahren“.
    3.  Ein `counter` um die Anzahl der automatischen Einfahrvorgänge zu zählen.
    4.  Ein `sensor` (z.B. ein Statistik-Sensor) für die akkumulierte Regenmenge über einen bestimmten Zeitraum.
    
  domain: automation
  
  input:
    marquise_retract_switch:
      name: Markise Einfahr-Switch
      description: |
        Der **Switch** mit dem die Markise eingefahren wird.
        (z.B. `switch.markise_einfahren`)
      selector:
        entity:
          domain: switch
    marquise_extend_switch:
      name: Markise Ausfahr-Switch
      description: |
        Der **Switch** mit dem die Markise ausgefahren wird.
        (z.B. `switch.markise_ausfahren`)
      selector:
        entity:
          domain: switch
    wind_sensor:
      name: Windsensor-Entität
      description: |
        Der **Numerische Sensor** der die aktuelle Windgeschwindigkeit in km/h misst.
        (z.B. `sensor.ecowitt_ws90_wind_max`)
      selector:
        entity:
          domain: sensor
          multiple: false
          filter:
            - device_class: wind_speed
    rain_sensor:
      name: Regensensor-Entität
      description: |-
        Der **Numerische Sensor**, der die Regenmenge misst.
        (z.B. `sensor.rain_last_5_minutes`)
        
        Erfordert einen Statistik-Sensor; der Niederschlag sollte in einem möglichst kurzen
        Zeitraum summiert werden, um schnell auf Regen reagieren zu können. Der Zeitraum darf
        jedoch auch nicht **zu** kurz sein (viele Regensensoren lösen nur in 1mm-Schritten auf).
        
        **Anlegen des Helfers:**
        `Einstellungen → Geräte & Dienste → Helfer → Helfer erstellen → Statistik`
        * **Entität:** dein Regensensor (=Quellsensor für die Berechnung)
        * **Statistikmerkmal:** Summe der Differenzen
        * **Stichprobengröße:** [Quellsensor-Updates / Minute] x [Maximalalter] + [kleiner Puffer]
        * **Maximalalter:** z.B. 5 Minuten
        * **Letzten Messwert behalten:** nein
        * **Genauigkeit:** 1
      selector:
        entity:
          domain: sensor
          multiple: false
          filter:
            - device_class:
                - volume
                - precipitation
    marquise_status_sensor:
      name: Markisenstatus-Sensor
      description: |
        Der **Binärsensor**, der den aktuellen Status der Markise anzeigt.
        (`on` = Markise ausgefahren, `off` = Markise eingefahren)
      selector:
        entity:
          domain: binary_sensor
          multiple: false
          filter:
            - device_class:
                - window
                - opening
    wind_max_threshold:
      name: Maximale Windschwelle (km/h)
      description: |
        Der numerische Wert in km/h, ab dem die Markise automatisch eingefahren wird.
        (Standard: 27 km/h)
      default: 27
      selector:
        number:
          min: 0
          max: 100
          unit_of_measurement: km/h
          mode: box
    wind_min_threshold:
      name: Minimale Windschwelle (km/h)
      description: |
        Der numerische Wert in km/h, unter den die Windgeschwindigkeit fallen muss, damit die Markise wieder automatisch ausgefahren wird.
        (Standard: 20 km/h)
      default: 20
      selector:
        number:
          min: 0
          max: 100
          unit_of_measurement: km/h
          mode: box
    automatic_extend_timeout_minutes:
      name: Zeitspanne für automatisches Ausfahren (Minuten)
      description: |
        Die Zeit in Minuten, die vergehen muss, nachdem Wind und Regen unter den Grenzwert gefallen sind, bevor die Markise wieder ausfährt.
        (Standard: 30 Minuten)
      default: 30
      selector:
        number:
          min: 1
          max: 120
          unit_of_measurement: min
          mode: box
    rain_threshold:
      name: Regenschwelle (mm)
      description: |
        Der numerische Wert in mm/m² (aus der **Regensensor-Entität**), ab dem die Markise eingefahren wird.
        (Standard: 0.7 mm/m²)
      default: 0.7
      selector:
        number:
          min: 0
          max: 50
          unit_of_measurement: mm/m²
          mode: box
    wind_sensor_timeout_minutes:
      name: Windsensor-Timeout (Minuten)
      description: |
        Die Zeitspanne in Minuten, nach der ein fehlender Windsensor die Markise automatisch einfährt.
        (Standard: 15 Minuten)
      default: 15
      selector:
        number:
          min: 1
          max: 60
          unit_of_measurement: min
          mode: box
    sensors_timeout_minutes:
      name: Sensoren-Timeout (Minuten)
      description: |
        Die Zeitspanne in Minuten, nach der fehlende Sensoren eine Warnung auslösen und versucht wird, die Markise automatisch einzufahren.
        (Standard: 15 Minuten)
      default: 15
      selector:
        number:
          min: 1
          max: 60
          unit_of_measurement: min
          mode: box
    automatic_retract_count_threshold:
      name: Zählergrenzwert für automatisches Einfahren
      description: |
        Der numerische Wert, wie oft die Markise automatisch eingefahren werden darf, bevor eine Benachrichtigung gesendet wird.
        (Standard: 2 mal)
      default: 2
      selector:
        number:
          min: 1
          max: 10
          mode: box
    automatic_retracted_helper:
      name: Helfer für "automatisch eingefahren"
      description: |
        Ein `input_boolean`-Helfer, der den Status anzeigt, wenn die Markise automatisch eingefahren wurde.
      selector:
        entity:
          domain: input_boolean
    automatic_extended_helper:
      name: Helfer für "automatisch ausgefahren"
      description: |
        Ein `input_boolean`-Helfer, der den Status anzeigt, wenn die Markise automatisch ausgefahren wurde.
      selector:
        entity:
          domain: input_boolean
    retract_counter_helper:
      name: Helfer für Einfahrzähler
      description: |
        Ein `counter`-Helfer, der die Anzahl der automatischen Einfahrvorgänge zählt.
      selector:
        entity:
          domain: counter
    reset_time:
      name: Tägliche Reset-Uhrzeit
      description: |
        Die Uhrzeit, zu der der Zähler und die Status-Helfer täglich zurückgesetzt werden sollen.
        (Standard: 00:00:00)
      default: "00:00:00"
      selector:
        time:

trigger:
  # Auslöser: Windgeschwindigkeit über maximalem Schwellenwert
  - platform: numeric_state
    id: trigger_windsensor_max_threshold
    entity_id: !input wind_sensor
    above: !input wind_max_threshold
  # Auslöser: Regenmenge über Schwellenwert
  - platform: numeric_state
    id: trigger_rain_statistic_sensor
    entity_id: !input rain_sensor
    above: !input rain_threshold
  # Auslöser: Markise wird manuell ausgefahren
  - platform: state
    id: trigger_marquise_opened
    entity_id: !input marquise_status_sensor
    from: "off"
    to: "on"
  # Auslöser: Markise wird manuell eingefahren
  - platform: state
    id: trigger_marquise_closed
    entity_id: !input marquise_status_sensor
    from: "on"
    to: "off"
  # Auslöser: Windgeschwindigkeit unter minimalem Schwellenwert für eine bestimmte Zeit
  - platform: numeric_state
    id: trigger_windsensor_min_threshold
    entity_id: !input wind_sensor
    below: !input wind_min_threshold
    for:
      minutes: !input automatic_extend_timeout_minutes
  # Auslöser: Windsensor ist nicht verfügbar oder unbekannt für eine bestimmte Zeit
  - platform: state
    id: trigger_windsensor_unknown
    entity_id: !input wind_sensor
    to:
      - unavailable
      - unknown
    for:
      minutes: !input wind_sensor_timeout_minutes
  # Auslöser: Mehrere Sensoren (Wind, Status, Steuerung) sind nicht verfügbar oder unbekannt
  - platform: state
    id: trigger_sensors_unknown
    entity_id:
      - !input wind_sensor
      - !input marquise_status_sensor
      - !input marquise_retract_switch
      - !input marquise_extend_switch
    to:
      - unavailable
      - unknown
    for: !input sensors_timeout_minutes
  # Auslöser: Der Einfahr-Zähler überschreitet den konfigurierten Grenzwert
  - platform: numeric_state
    id: trigger_retract_counter
    entity_id: !input retract_counter_helper
    above: !input automatic_retract_count_threshold
  # Auslöser: Tägliches Reset um Mitternacht
  - platform: time
    id: trigger_reset_time
    at: !input reset_time

condition: []

action:
  - variables:
      wind_speed: !input wind_sensor
      rain_amount: !input rain_sensor
      retract_count: !input retract_counter_helper
  - choose:
      # Aktion: Starkwind erkannt
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_max_threshold
        sequence:
          # Wenn Markise bereits geschlossen ist, tue nichts
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
            alias: Wenn Markise geschlossen -> tue nichts
          # Wenn Markise geöffnet ist, fahre sie ein
          - alias: Wenn Markise geöffnet -> Einfahren
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: counter.increment
                target:
                  entity_id: !input retract_counter_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Starkwind
                service: notify.notify
                data:
                  title: "Starkwind erkannt"
                  message: "Markise wurde wegen Starkwind ({{ wind_speed }} km/h) automatisch eingefahren."
          # Wenn Markisenstatus unbekannt ist, fahre sie sicherheitshalber ein
          - alias: Wenn Markisenstatus unbekannt -> Einfahren
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unknown
                  - unavailable
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Starkwind (Status unbekannt)
                service: notify.notify
                data:
                  title: "Starkwind - Markisenstatus unbekannt"
                  message: "Markise wurde wegen Starkwind ({{ wind_speed }} km/h) automatisch eingefahren. ACHTUNG: Markisenstatus unbekannt!"
        alias: Starkwind
      # Aktion: Windsensor-Timeout
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_unknown
        sequence:
          # Wenn Markise geschlossen ist, tue nichts
          - alias: Markise geschlossen -> tue nichts
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
          # Wenn Markisenstatus unbekannt, schließe Markise sicherheitshalber
          - alias: Markisenstatus unbekannt -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unavailable
                  - unknown
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Windsensor-Timeout
                service: notify.notify
                data:
                  title: "Windsensor-Timeout"
                  message: "Markise wird eingefahren, da der Windsensor nicht erreichbar ist."
          # Wenn Markise geöffnet ist, schließe Markise
          - alias: Markise geöffnet -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Windsensor-Timeout
                service: notify.notify
                data:
                  title: "Windsensor-Timeout"
                  message: "Markise wird eingefahren, da der Windsensor nicht erreichbar ist."
        alias: Windsensor-Timeout
      # Aktion: Regen erkannt
      - conditions:
          - condition: trigger
            id:
              - trigger_rain_statistic_sensor
        sequence:
          # Wenn Markise geschlossen ist, tue nichts
          - alias: Markise geschlossen -> tue nichts
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
          # Wenn Markisenstatus unbekannt, schließe Markise sicherheitshalber
          - alias: Markisenstatus unbekannt -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unavailable
                  - unknown
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Regen (Status unbekannt)
                service: notify.notify
                data:
                  title: "Regen erkannt - Markisenstatus unbekannt"
                  message: "Markise wird wegen Regen ({{ rain_amount }} mm) eingefahren. Status unbekannt!"
          # Wenn Markise geöffnet ist, schließe Markise
          - alias: Markise geöffnet -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Regen erkannt
                service: notify.notify
                data:
                  title: "Regen erkannt"
                  message: "Markise wird wegen Regen ({{ rain_amount }} mm) eingefahren."
        alias: Regen
      # Aktion: Manuelles Ausfahren
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_opened
              - condition: state
                entity_id: !input automatic_extended_helper
                state: "off"
        sequence:
          - if:
              - condition: numeric_state
                entity_id: !input retract_counter_helper
                above: 0
            then:
              - service: counter.reset
                target:
                  entity_id: !input retract_counter_helper
              - alias: Benachrichtigung Manuell Ausgefahren
                service: notify.notify
                data:
                  title: "Markise manuell ausgefahren"
                  message: "Der Markisen-Zähler wurde durch manuelles Ausfahren zurückgesetzt."
        alias: Markise manuell ausgefahren
      # Aktion: Manuelles Einfahren
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_closed
              - condition: state
                entity_id: !input automatic_retracted_helper
                state: "off"
        sequence:
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_extended_helper
        alias: Markise manuell eingefahren
      # Aktion: Zählerschutz-Benachrichtigung
      - conditions:
          - condition: trigger
            id:
              - trigger_retract_counter
        sequence:
          - alias: Benachrichtigung Zählerschutz
            service: notify.notify
            data:
              title: "Markisen-Zählerschutz aktiv"
              message: "Markise wurde in kurzer Zeit {{ retract_count }} Mal automatisch eingefahren. Automatisches Ausfahren ist gesperrt."
        alias: Benachrichtigung Ausfahrsperre aktiv
      # Aktion: Tägliches Reset
      - conditions:
          - condition: trigger
            id:
              - trigger_reset_time
        sequence:
          - service: counter.reset
            target:
              entity_id: !input retract_counter_helper
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_extended_helper
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_retracted_helper
        alias: Zeitlicher Reset der Automation
      # Aktion: Sensor-Fehlerwarnung
      - conditions:
          - condition: trigger
            id:
              - trigger_sensors_unknown
        sequence:
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: counter.increment
                target:
                  entity_id: !input retract_counter_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Sensor-Fehler (Einfahren)
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Markise wurde eingefahren, da kritische Sensoren nicht erreichbar sind."
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - "off"
            then:
              - alias: Benachrichtigung Sensor-Fehler
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Achtung! Einer oder mehrere kritische Sensoren des Markisenwächters sind nicht verfügbar!"
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - "unavailable"
                  - "unknown"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - alias: Benachrichtigung Sensor-Fehler (Status unbekannt)
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Achtung! Einer oder mehrere kritische Sensoren des Markisenwächters sind nicht verfügbar! Markise wird sicherheitshalber eingefahren."
        alias: "Warnung: Sensor(en) nicht verfügbar"
      # Aktion: Wind lässt nach, Markise wieder ausfahren
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_min_threshold
        sequence:
          - if:
              - condition: and
                conditions:
                  - condition: state
                    entity_id: !input automatic_retracted_helper
                    state: "on"
                  - condition: numeric_state
                    entity_id: !input rain_sensor
                    below: !input rain_threshold
            then:
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_extended_helper
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_extend_switch
              - alias: Benachrichtigung Wind lässt nach
                service: notify.notify
                data:
                  title: "Wind lässt nach"
                  message: "Windstärke ({{ wind_speed }} km/h) und Regen ({{ rain_amount }} mm) sind unter den Schwellenwert gefallen. Markise wird wieder ausgefahren."
        alias: Wind lässt nach
    # Standardaktion, wenn kein Trigger zutrifft
    default:
      - alias: Benachrichtigung unbekannter Fehler
        service: notify.notify
        data:
          title: "Markisenwächter - Fehler"
          message: "Ein Fehler oder eine unbekannte Situation ist aufgetreten. Bitte überprüfe das Log und die Sensoren/Steuerungen."

mode: single

Bei mir läuft die Automation seit rund 10 Tagen fehlerfrei.
Viel Spaß damit!

Gruß,
Mat

3 „Gefällt mir“

YAML-Code v1.5

Änderung:

  • Schrittgröße für die Regenschwelle vom Default (= 1) auf 0.1 korrigiert
# Changelog:
# v1 - initiale Release mit Basisfunktionen
#
# v1.1 (2025-07-22):
# - Finetuning der Notification im Default (statt auf einen möglichen Fehler wird auch auf eine mögliche
#   unbekannte Sensor-Kombitnation hingewiesen)
# - Bei nachlassendem Wind wurde unter bestimmten Bedingungen der Default-Teil des Ablaufes getriggert - korrigiert
# - Bei Starkwind und eingefahrener Markise wurde der Default-Teil des Ablaufes getriggert - korrigiert
# - Warnung wird ausgegeben und ein Schließen der Markise initiiert, falls Starkwind aufkommt, der Status der Markise
#   jedoch unbekannt ist
#
# v1.2 (2025-07-23):
# - Detailliertere Dokumentation der benötigten Entitäten
# - Karteileiche "Regensensor (Statistik) - Intervall" entfernt
# - Umbenennungen einiger Inputs
# - Erweiterung um zusätzliche Bedingungs-Zweige, um folgende Szenarien explizit zu behandeln und Default-Meldungen zu vermeiden:
#   - Nachlassender Wind, Markise bereits ausgefahren
#   - Regenschauer, Markise bereits eingefahren
#   - Counter-Überlauf, Markise bereits eingefahren
#   - Windsensor-Timeout, Markise bereits eingefahren
# - Das Default-Handling wird damit weiter minimiert und die Automation zuverlässiger.
#
# v1.3 (2025-07-27):
# Kompletter Neuaufbau der zugrundeliegenden Automation:
#  - Code-Struktur vollständig überarbeitet
#  - IDs in Vorbereitung auf eine Übersetzung ins Englische auf Englisch formuliert
#  - Einheitliche Nutzung von choose-Blöcken mit trigger.id statt kombinierter Bedingungen
#  - Bessere Trennung von Aktionen, Bedingungen und Auslösern
#  - Dokumentation deutlich klarer und strukturierter formuliert
#  - Blueprint-Inputs neu strukturiert und besser gruppiert
#  - Automatisches Ausfahren: Nur bei gleichzeitig unterminimiertem Wind und keinem Regen
#  - Reset der Helfer (input.booleans) erfolgt nun gemeinsam mit dem Zähler 
#  - Klare Trennung zwischen manuellem und automatischem Aus- oder Einfahren
#  - Grenzwert für automatische Einfahrvorgänge frei wählbar (automatic_retract_count_threshold)
#    und Hinweis per Notification bei Überschreitung
#
# v1.4 (2025-08-07)
#  - Sensor-Filter für Inputs aufgenommen
#
# v1.5 (2025-08-10)
#  - Schrittgröße für die Regenschwelle vom Default (= 1) auf 0.1 korrigiert


blueprint:
  name: Markisenwächter v1.5
  description: |
    Dieser Blueprint bietet eine erweiterte Automatisierung für eine Markise basierend auf verschiedenen Sensordaten wie Wind und Regen.
    ### Funktionen:
    * **Windüberwachung:** Fährt die Markise automatisch ein, wenn eine konfigurierbare Windgeschwindigkeit überschritten wird.
    * **Regenüberwachung:** Fährt die Markise automatisch ein, wenn eine konfigurierbare Regenmenge innerhalb eines Zeitraums erkannt wird.
    * **Wind-Timeout:** Fährt die Markise sicherheitshalber ein, wenn der Windsensor für eine bestimmte Zeit nicht erreichbar ist.
    * **Sensor-Überwachung:** Sendet eine Benachrichtigung, wenn wichtige Sensoren wie Wind, Markisenstatus oder die Steuerungs-Switches nicht erreichbar sind.
    * **Automatisches Ausfahren:** Fährt die Markise wieder aus, wenn der Wind unter den Grenzwert fällt und kein Regen erkannt wird.
    * **Zählerschutz:** Zählt die automatischen Einfahrvorgänge. Bei Überschreiten eines Grenzwertes wird eine Benachrichtigung gesendet und ein weiteres Ausfahren unterbunden, um ein häufiges, unnötiges Ein- und Ausfahren zu verhindern.
    * **Manuelle Steuerung:** Erkennt manuelle Eingriffe (Aus- und Einfahren) und setzt interne Zähler zurück oder passt Status-Helfer an.
    * **Täglicher Reset:** Setzt den Einfahr-Zähler und die internen Status-Helfer täglich zurück.
    ### Notwendige Konfiguration:
    Dieser Blueprint erfordert die Konfiguration der folgenden Helfer (helpers) in Home Assistant:
    1.  Ein `input_boolean` für den Status „Markise automatisch eingefahren“.
    2.  Ein `input_boolean` für den Status „Markise automatisch ausgefahren“.
    3.  Ein `counter` um die Anzahl der automatischen Einfahrvorgänge zu zählen.
    4.  Ein `sensor` (z.B. ein Statistik-Sensor) für die akkumulierte Regenmenge über einen bestimmten Zeitraum.
    
  domain: automation
  
  input:
    marquise_retract_switch:
      name: Markise Einfahr-Switch
      description: |
        Der **Switch** mit dem die Markise eingefahren wird.
        (z.B. `switch.markise_einfahren`)
      selector:
        entity:
          domain: switch
    marquise_extend_switch:
      name: Markise Ausfahr-Switch
      description: |
        Der **Switch** mit dem die Markise ausgefahren wird.
        (z.B. `switch.markise_ausfahren`)
      selector:
        entity:
          domain: switch
    wind_sensor:
      name: Windsensor-Entität
      description: |
        Der **Numerische Sensor** der die aktuelle Windgeschwindigkeit in km/h misst.
        (z.B. `sensor.ecowitt_ws90_wind_max`)
      selector:
        entity:
          domain: sensor
          multiple: false
          filter:
            - device_class: wind_speed
    rain_sensor:
      name: Regensensor-Entität
      description: |-
        Der **Numerische Sensor**, der die Regenmenge misst.
        (z.B. `sensor.rain_last_5_minutes`)
        
        Erfordert einen Statistik-Sensor; der Niederschlag sollte in einem möglichst kurzen
        Zeitraum summiert werden, um schnell auf Regen reagieren zu können. Der Zeitraum darf
        jedoch auch nicht **zu** kurz sein (viele Regensensoren lösen nur in 1mm-Schritten auf).
        
        **Anlegen des Helfers:**
        `Einstellungen → Geräte & Dienste → Helfer → Helfer erstellen → Statistik`
        * **Entität:** dein Regensensor (=Quellsensor für die Berechnung)
        * **Statistikmerkmal:** Summe der Differenzen
        * **Stichprobengröße:** [Quellsensor-Updates / Minute] x [Maximalalter] + [kleiner Puffer]
        * **Maximalalter:** z.B. 5 Minuten
        * **Letzten Messwert behalten:** nein
        * **Genauigkeit:** 1
      selector:
        entity:
          domain: sensor
          multiple: false
          filter:
            - device_class:
                - volume
                - precipitation
    marquise_status_sensor:
      name: Markisenstatus-Sensor
      description: |
        Der **Binärsensor**, der den aktuellen Status der Markise anzeigt.
        (`on` = Markise ausgefahren, `off` = Markise eingefahren)
      selector:
        entity:
          domain: binary_sensor
          multiple: false
          filter:
            - device_class:
                - window
                - opening
    wind_max_threshold:
      name: Maximale Windschwelle (km/h)
      description: |
        Der numerische Wert in km/h, ab dem die Markise automatisch eingefahren wird.
        (Standard: 27 km/h)
      default: 27
      selector:
        number:
          min: 0
          max: 100
          unit_of_measurement: km/h
          mode: box
    wind_min_threshold:
      name: Minimale Windschwelle (km/h)
      description: |
        Der numerische Wert in km/h, unter den die Windgeschwindigkeit fallen muss, damit die Markise wieder automatisch ausgefahren wird.
        (Standard: 20 km/h)
      default: 20
      selector:
        number:
          min: 0
          max: 100
          unit_of_measurement: km/h
          mode: box
    automatic_extend_timeout_minutes:
      name: Zeitspanne für automatisches Ausfahren (Minuten)
      description: |
        Die Zeit in Minuten, die vergehen muss, nachdem Wind und Regen unter den Grenzwert gefallen sind, bevor die Markise wieder ausfährt.
        (Standard: 30 Minuten)
      default: 30
      selector:
        number:
          min: 1
          max: 120
          unit_of_measurement: min
          mode: box
    rain_threshold:
      name: Regenschwelle (mm)
      description: |
        Der numerische Wert in mm/m² (aus der **Regensensor-Entität**), ab dem die Markise eingefahren wird.
        (Standard: 0.7 mm/m²)
      default: 0.7
      selector:
        number:
          step: 0.1
          min: 0
          max: 10
          unit_of_measurement: mm/m²
          mode: box
    wind_sensor_timeout_minutes:
      name: Windsensor-Timeout (Minuten)
      description: |
        Die Zeitspanne in Minuten, nach der ein fehlender Windsensor die Markise automatisch einfährt.
        (Standard: 15 Minuten)
      default: 15
      selector:
        number:
          min: 1
          max: 60
          unit_of_measurement: min
          mode: box
    sensors_timeout_minutes:
      name: Sensoren-Timeout (Minuten)
      description: |
        Die Zeitspanne in Minuten, nach der fehlende Sensoren eine Warnung auslösen und versucht wird, die Markise automatisch einzufahren.
        (Standard: 15 Minuten)
      default: 15
      selector:
        number:
          min: 1
          max: 60
          unit_of_measurement: min
          mode: box
    automatic_retract_count_threshold:
      name: Zählergrenzwert für automatisches Einfahren
      description: |
        Der numerische Wert, wie oft die Markise automatisch eingefahren werden darf, bevor eine Benachrichtigung gesendet wird.
        (Standard: 2 mal)
      default: 2
      selector:
        number:
          min: 1
          max: 10
          mode: box
    automatic_retracted_helper:
      name: Helfer für "automatisch eingefahren"
      description: |
        Ein `input_boolean`-Helfer, der den Status anzeigt, wenn die Markise automatisch eingefahren wurde.
      selector:
        entity:
          domain: input_boolean
    automatic_extended_helper:
      name: Helfer für "automatisch ausgefahren"
      description: |
        Ein `input_boolean`-Helfer, der den Status anzeigt, wenn die Markise automatisch ausgefahren wurde.
      selector:
        entity:
          domain: input_boolean
    retract_counter_helper:
      name: Helfer für Einfahrzähler
      description: |
        Ein `counter`-Helfer, der die Anzahl der automatischen Einfahrvorgänge zählt.
      selector:
        entity:
          domain: counter
    reset_time:
      name: Tägliche Reset-Uhrzeit
      description: |
        Die Uhrzeit, zu der der Zähler und die Status-Helfer täglich zurückgesetzt werden sollen.
        (Standard: 00:00:00)
      default: "00:00:00"
      selector:
        time:

trigger:
  # Auslöser: Windgeschwindigkeit über maximalem Schwellenwert
  - platform: numeric_state
    id: trigger_windsensor_max_threshold
    entity_id: !input wind_sensor
    above: !input wind_max_threshold
  # Auslöser: Regenmenge über Schwellenwert
  - platform: numeric_state
    id: trigger_rain_statistic_sensor
    entity_id: !input rain_sensor
    above: !input rain_threshold
  # Auslöser: Markise wird manuell ausgefahren
  - platform: state
    id: trigger_marquise_opened
    entity_id: !input marquise_status_sensor
    from: "off"
    to: "on"
  # Auslöser: Markise wird manuell eingefahren
  - platform: state
    id: trigger_marquise_closed
    entity_id: !input marquise_status_sensor
    from: "on"
    to: "off"
  # Auslöser: Windgeschwindigkeit unter minimalem Schwellenwert für eine bestimmte Zeit
  - platform: numeric_state
    id: trigger_windsensor_min_threshold
    entity_id: !input wind_sensor
    below: !input wind_min_threshold
    for:
      minutes: !input automatic_extend_timeout_minutes
  # Auslöser: Windsensor ist nicht verfügbar oder unbekannt für eine bestimmte Zeit
  - platform: state
    id: trigger_windsensor_unknown
    entity_id: !input wind_sensor
    to:
      - unavailable
      - unknown
    for:
      minutes: !input wind_sensor_timeout_minutes
  # Auslöser: Mehrere Sensoren (Wind, Status, Steuerung) sind nicht verfügbar oder unbekannt
  - platform: state
    id: trigger_sensors_unknown
    entity_id:
      - !input wind_sensor
      - !input marquise_status_sensor
      - !input marquise_retract_switch
      - !input marquise_extend_switch
    to:
      - unavailable
      - unknown
    for: !input sensors_timeout_minutes
  # Auslöser: Der Einfahr-Zähler überschreitet den konfigurierten Grenzwert
  - platform: numeric_state
    id: trigger_retract_counter
    entity_id: !input retract_counter_helper
    above: !input automatic_retract_count_threshold
  # Auslöser: Tägliches Reset um Mitternacht
  - platform: time
    id: trigger_reset_time
    at: !input reset_time

condition: []

action:
  - variables:
      wind_speed: !input wind_sensor
      rain_amount: !input rain_sensor
      retract_count: !input retract_counter_helper
  - choose:
      # Aktion: Starkwind erkannt
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_max_threshold
        sequence:
          # Wenn Markise bereits geschlossen ist, tue nichts
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
            alias: Wenn Markise geschlossen -> tue nichts
          # Wenn Markise geöffnet ist, fahre sie ein
          - alias: Wenn Markise geöffnet -> Einfahren
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: counter.increment
                target:
                  entity_id: !input retract_counter_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Starkwind
                service: notify.notify
                data:
                  title: "Starkwind erkannt"
                  message: "Markise wurde wegen Starkwind ({{ wind_speed }} km/h) automatisch eingefahren."
          # Wenn Markisenstatus unbekannt ist, fahre sie sicherheitshalber ein
          - alias: Wenn Markisenstatus unbekannt -> Einfahren
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unknown
                  - unavailable
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Starkwind (Status unbekannt)
                service: notify.notify
                data:
                  title: "Starkwind - Markisenstatus unbekannt"
                  message: "Markise wurde wegen Starkwind ({{ wind_speed }} km/h) automatisch eingefahren. ACHTUNG: Markisenstatus unbekannt!"
        alias: Starkwind
      # Aktion: Windsensor-Timeout
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_unknown
        sequence:
          # Wenn Markise geschlossen ist, tue nichts
          - alias: Markise geschlossen -> tue nichts
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
          # Wenn Markisenstatus unbekannt, schließe Markise sicherheitshalber
          - alias: Markisenstatus unbekannt -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unavailable
                  - unknown
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Windsensor-Timeout
                service: notify.notify
                data:
                  title: "Windsensor-Timeout"
                  message: "Markise wird eingefahren, da der Windsensor nicht erreichbar ist."
          # Wenn Markise geöffnet ist, schließe Markise
          - alias: Markise geöffnet -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Windsensor-Timeout
                service: notify.notify
                data:
                  title: "Windsensor-Timeout"
                  message: "Markise wird eingefahren, da der Windsensor nicht erreichbar ist."
        alias: Windsensor-Timeout
      # Aktion: Regen erkannt
      - conditions:
          - condition: trigger
            id:
              - trigger_rain_statistic_sensor
        sequence:
          # Wenn Markise geschlossen ist, tue nichts
          - alias: Markise geschlossen -> tue nichts
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
          # Wenn Markisenstatus unbekannt, schließe Markise sicherheitshalber
          - alias: Markisenstatus unbekannt -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unavailable
                  - unknown
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Regen (Status unbekannt)
                service: notify.notify
                data:
                  title: "Regen erkannt - Markisenstatus unbekannt"
                  message: "Markise wird wegen Regen ({{ rain_amount }} mm) eingefahren. Status unbekannt!"
          # Wenn Markise geöffnet ist, schließe Markise
          - alias: Markise geöffnet -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Regen erkannt
                service: notify.notify
                data:
                  title: "Regen erkannt"
                  message: "Markise wird wegen Regen ({{ rain_amount }} mm) eingefahren."
        alias: Regen
      # Aktion: Manuelles Ausfahren
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_opened
              - condition: state
                entity_id: !input automatic_extended_helper
                state: "off"
        sequence:
          - if:
              - condition: numeric_state
                entity_id: !input retract_counter_helper
                above: 0
            then:
              - service: counter.reset
                target:
                  entity_id: !input retract_counter_helper
              - alias: Benachrichtigung Manuell Ausgefahren
                service: notify.notify
                data:
                  title: "Markise manuell ausgefahren"
                  message: "Der Markisen-Zähler wurde durch manuelles Ausfahren zurückgesetzt."
        alias: Markise manuell ausgefahren
      # Aktion: Manuelles Einfahren
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_closed
              - condition: state
                entity_id: !input automatic_retracted_helper
                state: "off"
        sequence:
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_extended_helper
        alias: Markise manuell eingefahren
      # Aktion: Zählerschutz-Benachrichtigung
      - conditions:
          - condition: trigger
            id:
              - trigger_retract_counter
        sequence:
          - alias: Benachrichtigung Zählerschutz
            service: notify.notify
            data:
              title: "Markisen-Zählerschutz aktiv"
              message: "Markise wurde in kurzer Zeit {{ retract_count }} Mal automatisch eingefahren. Automatisches Ausfahren ist gesperrt."
        alias: Benachrichtigung Ausfahrsperre aktiv
      # Aktion: Tägliches Reset
      - conditions:
          - condition: trigger
            id:
              - trigger_reset_time
        sequence:
          - service: counter.reset
            target:
              entity_id: !input retract_counter_helper
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_extended_helper
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_retracted_helper
        alias: Zeitlicher Reset der Automation
      # Aktion: Sensor-Fehlerwarnung
      - conditions:
          - condition: trigger
            id:
              - trigger_sensors_unknown
        sequence:
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: counter.increment
                target:
                  entity_id: !input retract_counter_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Sensor-Fehler (Einfahren)
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Markise wurde eingefahren, da kritische Sensoren nicht erreichbar sind."
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - "off"
            then:
              - alias: Benachrichtigung Sensor-Fehler
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Achtung! Einer oder mehrere kritische Sensoren des Markisenwächters sind nicht verfügbar!"
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - "unavailable"
                  - "unknown"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - alias: Benachrichtigung Sensor-Fehler (Status unbekannt)
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Achtung! Einer oder mehrere kritische Sensoren des Markisenwächters sind nicht verfügbar! Markise wird sicherheitshalber eingefahren."
        alias: "Warnung: Sensor(en) nicht verfügbar"
      # Aktion: Wind lässt nach, Markise wieder ausfahren
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_min_threshold
        sequence:
          - if:
              - condition: and
                conditions:
                  - condition: state
                    entity_id: !input automatic_retracted_helper
                    state: "on"
                  - condition: numeric_state
                    entity_id: !input rain_sensor
                    below: !input rain_threshold
            then:
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_extended_helper
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_extend_switch
              - alias: Benachrichtigung Wind lässt nach
                service: notify.notify
                data:
                  title: "Wind lässt nach"
                  message: "Windstärke ({{ wind_speed }} km/h) und Regen ({{ rain_amount }} mm) sind unter den Schwellenwert gefallen. Markise wird wieder ausgefahren."
        alias: Wind lässt nach
    # Standardaktion, wenn kein Trigger zutrifft
    default:
      - alias: Benachrichtigung unbekannter Fehler
        service: notify.notify
        data:
          title: "Markisenwächter - Fehler"
          message: "Ein Fehler oder eine unbekannte Situation ist aufgetreten. Bitte überprüfe das Log und die Sensoren/Steuerungen."

mode: single
3 „Gefällt mir“

YAML-Code v1.6

(2025-08-16)

Änderung:

  • Bugfix: Input Sensoren-Timeout (Minuten) wurde im Trigger als Sekunden-Wert übernommen - nun korrigiert
# Changelog:
# v1 - initiale Release mit Basisfunktionen
#
# v1.1 (2025-07-22):
# - Finetuning der Notification im Default (statt auf einen möglichen Fehler wird auch auf eine mögliche
#   unbekannte Sensor-Kombitnation hingewiesen)
# - Bei nachlassendem Wind wurde unter bestimmten Bedingungen der Default-Teil des Ablaufes getriggert - korrigiert
# - Bei Starkwind und eingefahrener Markise wurde der Default-Teil des Ablaufes getriggert - korrigiert
# - Warnung wird ausgegeben und ein Schließen der Markise initiiert, falls Starkwind aufkommt, der Status der Markise
#   jedoch unbekannt ist
#
# v1.2 (2025-07-23):
# - Detailliertere Dokumentation der benötigten Entitäten
# - Karteileiche "Regensensor (Statistik) - Intervall" entfernt
# - Umbenennungen einiger Inputs
# - Erweiterung um zusätzliche Bedingungs-Zweige, um folgende Szenarien explizit zu behandeln und Default-Meldungen zu vermeiden:
#   - Nachlassender Wind, Markise bereits ausgefahren
#   - Regenschauer, Markise bereits eingefahren
#   - Counter-Überlauf, Markise bereits eingefahren
#   - Windsensor-Timeout, Markise bereits eingefahren
# - Das Default-Handling wird damit weiter minimiert und die Automation zuverlässiger.
#
# v1.3 (2025-07-27):
# Kompletter Neuaufbau der zugrundeliegenden Automation:
#  - Code-Struktur vollständig überarbeitet
#  - IDs in Vorbereitung auf eine Übersetzung ins Englische auf Englisch formuliert
#  - Einheitliche Nutzung von choose-Blöcken mit trigger.id statt kombinierter Bedingungen
#  - Bessere Trennung von Aktionen, Bedingungen und Auslösern
#  - Dokumentation deutlich klarer und strukturierter formuliert
#  - Blueprint-Inputs neu strukturiert und besser gruppiert
#  - Automatisches Ausfahren: Nur bei gleichzeitig unterminimiertem Wind und keinem Regen
#  - Reset der Helfer (input.booleans) erfolgt nun gemeinsam mit dem Zähler 
#  - Klare Trennung zwischen manuellem und automatischem Aus- oder Einfahren
#  - Grenzwert für automatische Einfahrvorgänge frei wählbar (automatic_retract_count_threshold)
#    und Hinweis per Notification bei Überschreitung
#
# v1.4 (2025-08-07)
#  - Sensor-Filter für Inputs aufgenommen
#
# v1.5 (2025-08-10)
#  - Schrittgröße für die Regenschwelle vom Default (= 1) auf 0.1 korrigiert
#
# v1.6 (2025-08-16)
#  - Bugfix: Input `Sensoren-Timeout (Minuten)` wurde im Trigger als Sekunden-Wert übernommen


blueprint:
  name: Markisenwächter v1.6
  description: |
    Dieser Blueprint bietet eine erweiterte Automatisierung für eine Markise basierend auf verschiedenen Sensordaten wie Wind und Regen.
    ### Funktionen:
    * **Windüberwachung:** Fährt die Markise automatisch ein, wenn eine konfigurierbare Windgeschwindigkeit überschritten wird.
    * **Regenüberwachung:** Fährt die Markise automatisch ein, wenn eine konfigurierbare Regenmenge innerhalb eines Zeitraums erkannt wird.
    * **Wind-Timeout:** Fährt die Markise sicherheitshalber ein, wenn der Windsensor für eine bestimmte Zeit nicht erreichbar ist.
    * **Sensor-Überwachung:** Sendet eine Benachrichtigung, wenn wichtige Sensoren wie Wind, Markisenstatus oder die Steuerungs-Switches nicht erreichbar sind.
    * **Automatisches Ausfahren:** Fährt die Markise wieder aus, wenn der Wind unter den Grenzwert fällt und kein Regen erkannt wird.
    * **Zählerschutz:** Zählt die automatischen Einfahrvorgänge. Bei Überschreiten eines Grenzwertes wird eine Benachrichtigung gesendet und ein weiteres Ausfahren unterbunden, um ein häufiges, unnötiges Ein- und Ausfahren zu verhindern.
    * **Manuelle Steuerung:** Erkennt manuelle Eingriffe (Aus- und Einfahren) und setzt interne Zähler zurück oder passt Status-Helfer an.
    * **Täglicher Reset:** Setzt den Einfahr-Zähler und die internen Status-Helfer täglich zurück.
    ### Notwendige Konfiguration:
    Dieser Blueprint erfordert die Konfiguration der folgenden Helfer (helpers) in Home Assistant:
    1.  Ein `input_boolean` für den Status „Markise automatisch eingefahren“.
    2.  Ein `input_boolean` für den Status „Markise automatisch ausgefahren“.
    3.  Ein `counter` um die Anzahl der automatischen Einfahrvorgänge zu zählen.
    4.  Ein `sensor` (z.B. ein Statistik-Sensor) für die akkumulierte Regenmenge über einen bestimmten Zeitraum.
    
  domain: automation
  
  input:
    marquise_retract_switch:
      name: Markise Einfahr-Switch
      description: |
        Der **Switch** mit dem die Markise eingefahren wird.
        (z.B. `switch.markise_einfahren`)
      selector:
        entity:
          domain: switch
    marquise_extend_switch:
      name: Markise Ausfahr-Switch
      description: |
        Der **Switch** mit dem die Markise ausgefahren wird.
        (z.B. `switch.markise_ausfahren`)
      selector:
        entity:
          domain: switch
    wind_sensor:
      name: Windsensor-Entität
      description: |
        Der **Numerische Sensor** der die aktuelle Windgeschwindigkeit in km/h misst.
        (z.B. `sensor.ecowitt_ws90_wind_max`)
      selector:
        entity:
          domain: sensor
          multiple: false
          filter:
            - device_class: wind_speed
    rain_sensor:
      name: Regensensor-Entität
      description: |-
        Der **Numerische Sensor**, der die Regenmenge misst.
        (z.B. `sensor.rain_last_5_minutes`)
        
        Erfordert einen Statistik-Sensor; der Niederschlag sollte in einem möglichst kurzen
        Zeitraum summiert werden, um schnell auf Regen reagieren zu können. Der Zeitraum darf
        jedoch auch nicht **zu** kurz sein (viele Regensensoren lösen nur in 1mm-Schritten auf).
        
        **Anlegen des Helfers:**
        `Einstellungen → Geräte & Dienste → Helfer → Helfer erstellen → Statistik`
        * **Entität:** dein Regensensor (=Quellsensor für die Berechnung)
        * **Statistikmerkmal:** Summe der Differenzen
        * **Stichprobengröße:** [Quellsensor-Updates / Minute] x [Maximalalter] + [kleiner Puffer]
        * **Maximalalter:** z.B. 5 Minuten
        * **Letzten Messwert behalten:** nein
        * **Genauigkeit:** 1
      selector:
        entity:
          domain: sensor
          multiple: false
          filter:
            - device_class:
                - volume
                - precipitation
    marquise_status_sensor:
      name: Markisenstatus-Sensor
      description: |
        Der **Binärsensor**, der den aktuellen Status der Markise anzeigt.
        (`on` = Markise ausgefahren, `off` = Markise eingefahren)
      selector:
        entity:
          domain: binary_sensor
          multiple: false
          filter:
            - device_class:
                - window
                - opening
    wind_max_threshold:
      name: Maximale Windschwelle (km/h)
      description: |
        Der numerische Wert in km/h, ab dem die Markise automatisch eingefahren wird.
        (Standard: 27 km/h)
      default: 27
      selector:
        number:
          min: 0
          max: 100
          unit_of_measurement: km/h
          mode: box
    wind_min_threshold:
      name: Minimale Windschwelle (km/h)
      description: |
        Der numerische Wert in km/h, unter den die Windgeschwindigkeit fallen muss, damit die Markise wieder automatisch ausgefahren wird.
        (Standard: 20 km/h)
      default: 20
      selector:
        number:
          min: 0
          max: 100
          unit_of_measurement: km/h
          mode: box
    automatic_extend_timeout_minutes:
      name: Zeitspanne für automatisches Ausfahren (Minuten)
      description: |
        Die Zeit in Minuten, die vergehen muss, nachdem Wind und Regen unter den Grenzwert gefallen sind, bevor die Markise wieder ausfährt.
        (Standard: 30 Minuten)
      default: 30
      selector:
        number:
          min: 1
          max: 120
          unit_of_measurement: min
          mode: box
    rain_threshold:
      name: Regenschwelle (mm)
      description: |
        Der numerische Wert in mm/m² (aus der **Regensensor-Entität**), ab dem die Markise eingefahren wird.
        (Standard: 0.7 mm/m²)
      default: 0.7
      selector:
        number:
          step: 0.1
          min: 0
          max: 10
          unit_of_measurement: mm/m²
          mode: box
    wind_sensor_timeout_minutes:
      name: Windsensor-Timeout (Minuten)
      description: |
        Die Zeitspanne in Minuten, nach der ein fehlender Windsensor die Markise automatisch einfährt.
        (Standard: 15 Minuten)
      default: 15
      selector:
        number:
          min: 1
          max: 60
          unit_of_measurement: min
          mode: box
    sensors_timeout_minutes:
      name: Sensoren-Timeout (Minuten)
      description: |
        Die Zeitspanne in Minuten, nach der fehlende Sensoren eine Warnung auslösen und versucht wird, die Markise automatisch einzufahren.
        (Standard: 15 Minuten)
      default: 15
      selector:
        number:
          min: 1
          max: 60
          unit_of_measurement: min
          mode: box
    automatic_retract_count_threshold:
      name: Zählergrenzwert für automatisches Einfahren
      description: |
        Der numerische Wert, wie oft die Markise automatisch eingefahren werden darf, bevor eine Benachrichtigung gesendet wird.
        (Standard: 2 mal)
      default: 2
      selector:
        number:
          min: 1
          max: 10
          mode: box
    automatic_retracted_helper:
      name: Helfer für "automatisch eingefahren"
      description: |
        Ein `input_boolean`-Helfer, der den Status anzeigt, wenn die Markise automatisch eingefahren wurde.
      selector:
        entity:
          domain: input_boolean
    automatic_extended_helper:
      name: Helfer für "automatisch ausgefahren"
      description: |
        Ein `input_boolean`-Helfer, der den Status anzeigt, wenn die Markise automatisch ausgefahren wurde.
      selector:
        entity:
          domain: input_boolean
    retract_counter_helper:
      name: Helfer für Einfahrzähler
      description: |
        Ein `counter`-Helfer, der die Anzahl der automatischen Einfahrvorgänge zählt.
      selector:
        entity:
          domain: counter
    reset_time:
      name: Tägliche Reset-Uhrzeit
      description: |
        Die Uhrzeit, zu der der Zähler und die Status-Helfer täglich zurückgesetzt werden sollen.
        (Standard: 00:00:00)
      default: "00:00:00"
      selector:
        time:

trigger:
  # Auslöser: Windgeschwindigkeit über maximalem Schwellenwert
  - platform: numeric_state
    id: trigger_windsensor_max_threshold
    entity_id: !input wind_sensor
    above: !input wind_max_threshold
  # Auslöser: Regenmenge über Schwellenwert
  - platform: numeric_state
    id: trigger_rain_statistic_sensor
    entity_id: !input rain_sensor
    above: !input rain_threshold
  # Auslöser: Markise wird manuell ausgefahren
  - platform: state
    id: trigger_marquise_opened
    entity_id: !input marquise_status_sensor
    from: "off"
    to: "on"
  # Auslöser: Markise wird manuell eingefahren
  - platform: state
    id: trigger_marquise_closed
    entity_id: !input marquise_status_sensor
    from: "on"
    to: "off"
  # Auslöser: Windgeschwindigkeit unter minimalem Schwellenwert für eine bestimmte Zeit
  - platform: numeric_state
    id: trigger_windsensor_min_threshold
    entity_id: !input wind_sensor
    below: !input wind_min_threshold
    for:
      minutes: !input automatic_extend_timeout_minutes
  # Auslöser: Windsensor ist nicht verfügbar oder unbekannt für eine bestimmte Zeit
  - platform: state
    id: trigger_windsensor_unknown
    entity_id: !input wind_sensor
    to:
      - unavailable
      - unknown
    for:
      minutes: !input wind_sensor_timeout_minutes
  # Auslöser: Mehrere Sensoren (Wind, Status, Steuerung) sind nicht verfügbar oder unbekannt
  - platform: state
    id: trigger_sensors_unknown
    entity_id:
      - !input wind_sensor
      - !input marquise_status_sensor
      - !input marquise_retract_switch
      - !input marquise_extend_switch
    to:
      - unavailable
      - unknown
    for:
      minutes: !input sensors_timeout_minutes
  # Auslöser: Der Einfahr-Zähler überschreitet den konfigurierten Grenzwert
  - platform: numeric_state
    id: trigger_retract_counter
    entity_id: !input retract_counter_helper
    above: !input automatic_retract_count_threshold
  # Auslöser: Tägliches Reset um Mitternacht
  - platform: time
    id: trigger_reset_time
    at: !input reset_time

condition: []

action:
  - variables:
      wind_speed: !input wind_sensor
      rain_amount: !input rain_sensor
      retract_count: !input retract_counter_helper
  - choose:
      # Aktion: Starkwind erkannt
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_max_threshold
        sequence:
          # Wenn Markise bereits geschlossen ist, tue nichts
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
            alias: Wenn Markise geschlossen -> tue nichts
          # Wenn Markise geöffnet ist, fahre sie ein
          - alias: Wenn Markise geöffnet -> Einfahren
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: counter.increment
                target:
                  entity_id: !input retract_counter_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Starkwind
                service: notify.notify
                data:
                  title: "Starkwind erkannt"
                  message: "Markise wurde wegen Starkwind ({{ wind_speed }} km/h) automatisch eingefahren."
          # Wenn Markisenstatus unbekannt ist, fahre sie sicherheitshalber ein
          - alias: Wenn Markisenstatus unbekannt -> Einfahren
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unknown
                  - unavailable
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Starkwind (Status unbekannt)
                service: notify.notify
                data:
                  title: "Starkwind - Markisenstatus unbekannt"
                  message: "Markise wurde wegen Starkwind ({{ wind_speed }} km/h) automatisch eingefahren. ACHTUNG: Markisenstatus unbekannt!"
        alias: Starkwind
      # Aktion: Windsensor-Timeout
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_unknown
        sequence:
          # Wenn Markise geschlossen ist, tue nichts
          - alias: Markise geschlossen -> tue nichts
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
          # Wenn Markisenstatus unbekannt, schließe Markise sicherheitshalber
          - alias: Markisenstatus unbekannt -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unavailable
                  - unknown
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Windsensor-Timeout
                service: notify.notify
                data:
                  title: "Windsensor-Timeout"
                  message: "Markise wird eingefahren, da der Windsensor nicht erreichbar ist."
          # Wenn Markise geöffnet ist, schließe Markise
          - alias: Markise geöffnet -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Windsensor-Timeout
                service: notify.notify
                data:
                  title: "Windsensor-Timeout"
                  message: "Markise wird eingefahren, da der Windsensor nicht erreichbar ist."
        alias: Windsensor-Timeout
      # Aktion: Regen erkannt
      - conditions:
          - condition: trigger
            id:
              - trigger_rain_statistic_sensor
        sequence:
          # Wenn Markise geschlossen ist, tue nichts
          - alias: Markise geschlossen -> tue nichts
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
          # Wenn Markisenstatus unbekannt, schließe Markise sicherheitshalber
          - alias: Markisenstatus unbekannt -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unavailable
                  - unknown
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Regen (Status unbekannt)
                service: notify.notify
                data:
                  title: "Regen erkannt - Markisenstatus unbekannt"
                  message: "Markise wird wegen Regen ({{ rain_amount }} mm) eingefahren. Status unbekannt!"
          # Wenn Markise geöffnet ist, schließe Markise
          - alias: Markise geöffnet -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Regen erkannt
                service: notify.notify
                data:
                  title: "Regen erkannt"
                  message: "Markise wird wegen Regen ({{ rain_amount }} mm) eingefahren."
        alias: Regen
      # Aktion: Manuelles Ausfahren
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_opened
              - condition: state
                entity_id: !input automatic_extended_helper
                state: "off"
        sequence:
          - if:
              - condition: numeric_state
                entity_id: !input retract_counter_helper
                above: 0
            then:
              - service: counter.reset
                target:
                  entity_id: !input retract_counter_helper
              - alias: Benachrichtigung Manuell Ausgefahren
                service: notify.notify
                data:
                  title: "Markise manuell ausgefahren"
                  message: "Der Markisen-Zähler wurde durch manuelles Ausfahren zurückgesetzt."
        alias: Markise manuell ausgefahren
      # Aktion: Manuelles Einfahren
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_closed
              - condition: state
                entity_id: !input automatic_retracted_helper
                state: "off"
        sequence:
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_extended_helper
        alias: Markise manuell eingefahren
      # Aktion: Zählerschutz-Benachrichtigung
      - conditions:
          - condition: trigger
            id:
              - trigger_retract_counter
        sequence:
          - alias: Benachrichtigung Zählerschutz
            service: notify.notify
            data:
              title: "Markisen-Zählerschutz aktiv"
              message: "Markise wurde in kurzer Zeit {{ retract_count }} Mal automatisch eingefahren. Automatisches Ausfahren ist gesperrt."
        alias: Benachrichtigung Ausfahrsperre aktiv
      # Aktion: Tägliches Reset
      - conditions:
          - condition: trigger
            id:
              - trigger_reset_time
        sequence:
          - service: counter.reset
            target:
              entity_id: !input retract_counter_helper
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_extended_helper
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_retracted_helper
        alias: Zeitlicher Reset der Automation
      # Aktion: Sensor-Fehlerwarnung
      - conditions:
          - condition: trigger
            id:
              - trigger_sensors_unknown
        sequence:
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: counter.increment
                target:
                  entity_id: !input retract_counter_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Sensor-Fehler (Einfahren)
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Markise wurde eingefahren, da kritische Sensoren nicht erreichbar sind."
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - "off"
            then:
              - alias: Benachrichtigung Sensor-Fehler
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Achtung! Einer oder mehrere kritische Sensoren des Markisenwächters sind nicht verfügbar!"
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - "unavailable"
                  - "unknown"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - alias: Benachrichtigung Sensor-Fehler (Status unbekannt)
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Achtung! Einer oder mehrere kritische Sensoren des Markisenwächters sind nicht verfügbar! Markise wird sicherheitshalber eingefahren."
        alias: "Warnung: Sensor(en) nicht verfügbar"
      # Aktion: Wind lässt nach, Markise wieder ausfahren
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_min_threshold
        sequence:
          - if:
              - condition: and
                conditions:
                  - condition: state
                    entity_id: !input automatic_retracted_helper
                    state: "on"
                  - condition: numeric_state
                    entity_id: !input rain_sensor
                    below: !input rain_threshold
            then:
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_extended_helper
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_extend_switch
              - alias: Benachrichtigung Wind lässt nach
                service: notify.notify
                data:
                  title: "Wind lässt nach"
                  message: "Windstärke ({{ wind_speed }} km/h) und Regen ({{ rain_amount }} mm) sind unter den Schwellenwert gefallen. Markise wird wieder ausgefahren."
        alias: Wind lässt nach
    # Standardaktion, wenn kein Trigger zutrifft
    default:
      - alias: Benachrichtigung unbekannter Fehler
        service: notify.notify
        data:
          title: "Markisenwächter - Fehler"
          message: "Ein Fehler oder eine unbekannte Situation ist aufgetreten. Bitte überprüfe das Log und die Sensoren/Steuerungen."

mode: single

Screenshots:


5 „Gefällt mir“

Ich hatte nun endlich die Zeit ein paar kosmetische Fehler zu beheben. Unten findet ihr eine neue Version des Blueprints.

Ein (in meinen Augen) großes Thema:
Wird die Markise trotz anhaltendem Starkwind manuell ausgefahren, ist die Automation de facto tot, solange der Wind nicht zumindest einmal unter den eingestellten Schwellenwert nachlässt.
Der aktuelle Workaround ist, dass beim manuellen Ausfahren bei Starkwind über den notify.notify-Dienst eine Warnung ausgegeben wird.
Ich möchte mit der Automation ungerne auf jede Änderung der Windgeschwindigkeit reagieren (um nicht im 20-Sekunden-Takt zu triggern) und erst im Anschluss Geschwindigkeit mit Threshold vergleichen.

Bitte um eure Hilfe: Wenn jemand eine Idee zu einer eleganten Lösung hat, bitte melden! :wink:

YAML-Code v1.7

(2025-09-07)

Änderung:

  • Bugfix: In den Notifications wurden die Namen der Sensoren, aber nicht die States ausgegeben - ist nun korrigiert
  • Bugfix: Beim automatischen Ein- und Ausfahren wurde nach Abschluss der Aktion der Default-Block (“Fehler oder unbekannte Situation”) ausgelöst - die entsprechenden Situationen werden nun im choose-Block abgefangen
  • Warnung wird ausgelöst, wenn trotz Starkwind die Markise ausgefahren wird (Grund: der Wind-Threshold greift nur, wenn von einem niedrigeren Wert ausgehend der Schwellenwert überschritten wird)
# Changelog:
# v1 - initiale Release mit Basisfunktionen
#
# v1.1 (2025-07-22):
# - Finetuning der Notification im Default (statt auf einen möglichen Fehler wird auch auf eine mögliche
#   unbekannte Sensor-Kombitnation hingewiesen)
# - Bei nachlassendem Wind wurde unter bestimmten Bedingungen der Default-Teil des Ablaufes getriggert - korrigiert
# - Bei Starkwind und eingefahrener Markise wurde der Default-Teil des Ablaufes getriggert - korrigiert
# - Warnung wird ausgegeben und ein Schließen der Markise initiiert, falls Starkwind aufkommt, der Status der Markise
#   jedoch unbekannt ist
#
# v1.2 (2025-07-23):
# - Detailliertere Dokumentation der benötigten Entitäten
# - Karteileiche "Regensensor (Statistik) - Intervall" entfernt
# - Umbenennungen einiger Inputs
# - Erweiterung um zusätzliche Bedingungs-Zweige, um folgende Szenarien explizit zu behandeln und Default-Meldungen zu vermeiden:
#   - Nachlassender Wind, Markise bereits ausgefahren
#   - Regenschauer, Markise bereits eingefahren
#   - Counter-Überlauf, Markise bereits eingefahren
#   - Windsensor-Timeout, Markise bereits eingefahren
# - Das Default-Handling wird damit weiter minimiert und die Automation zuverlässiger.
#
# v1.3 (2025-07-27):
# Kompletter Neuaufbau der zugrundeliegenden Automation:
#  - Code-Struktur vollständig überarbeitet
#  - IDs in Vorbereitung auf eine Übersetzung ins Englische auf Englisch formuliert
#  - Einheitliche Nutzung von choose-Blöcken mit trigger.id statt kombinierter Bedingungen
#  - Bessere Trennung von Aktionen, Bedingungen und Auslösern
#  - Dokumentation deutlich klarer und strukturierter formuliert
#  - Blueprint-Inputs neu strukturiert und besser gruppiert
#  - Automatisches Ausfahren: Nur bei gleichzeitig unterminimiertem Wind und keinem Regen
#  - Reset der Helfer (input.booleans) erfolgt nun gemeinsam mit dem Zähler 
#  - Klare Trennung zwischen manuellem und automatischem Aus- oder Einfahren
#  - Grenzwert für automatische Einfahrvorgänge frei wählbar (automatic_retract_count_threshold)
#    und Hinweis per Notification bei Überschreitung
#
# v1.4 (2025-08-07)
#  - Sensor-Filter für Inputs aufgenommen
#
# v1.5 (2025-08-10)
#  - Schrittgröße für die Regenschwelle vom Default (= 1) auf 0.1 korrigiert
#
# v1.6 (2025-08-16)
#  - Bugfix: Input `Sensoren-Timeout (Minuten)` wurde im Trigger als Sekunden-Wert übernommen
#
# v1.7 (2025-09-07)
#  - Bugfix: In den Notifications wurden die Namen der Sensoren, aber nicht die States ausgegeben
#  - Bugfix: Beim automatischen Ein- und Ausfahren wurde nach Abschluss der Aktion der Default-Block ("Fehler oder unbekannte Situation") ausgelöst
#  - Warnung wird ausgelöst, wenn trotz Starkwind die Markise ausgefahren wird (Grund: der Wind-Threshold greift nur, wenn von einem niedrigeren Wert ausgehend der Schwellenwert überschritten wird)



blueprint:
  name: Markisenwächter v1.7
  description: |
    Dieser Blueprint bietet eine erweiterte Automatisierung für eine Markise basierend auf verschiedenen Sensordaten wie Wind und Regen.
    ### Funktionen:
    * **Windüberwachung:** Fährt die Markise automatisch ein, wenn eine konfigurierbare Windgeschwindigkeit überschritten wird.
    * **Regenüberwachung:** Fährt die Markise automatisch ein, wenn eine konfigurierbare Regenmenge innerhalb eines Zeitraums erkannt wird.
    * **Wind-Timeout:** Fährt die Markise sicherheitshalber ein, wenn der Windsensor für eine bestimmte Zeit nicht erreichbar ist.
    * **Sensor-Überwachung:** Sendet eine Benachrichtigung, wenn wichtige Sensoren wie Wind, Markisenstatus oder die Steuerungs-Switches nicht erreichbar sind.
    * **Automatisches Ausfahren:** Fährt die Markise wieder aus, wenn der Wind unter den Grenzwert fällt und kein Regen erkannt wird.
    * **Zählerschutz:** Zählt die automatischen Einfahrvorgänge. Bei Überschreiten eines Grenzwertes wird eine Benachrichtigung gesendet und ein weiteres Ausfahren unterbunden, um ein häufiges, unnötiges Ein- und Ausfahren zu verhindern.
    * **Manuelle Steuerung:** Erkennt manuelle Eingriffe (Aus- und Einfahren) und setzt interne Zähler zurück oder passt Status-Helfer an.
    * **Täglicher Reset:** Setzt den Einfahr-Zähler und die internen Status-Helfer täglich zurück.
    ### Notwendige Konfiguration:
    Dieser Blueprint erfordert die Konfiguration der folgenden Helfer (helpers) in Home Assistant:
    1.  Ein `input_boolean` für den Status „Markise automatisch eingefahren“.
    2.  Ein `input_boolean` für den Status „Markise automatisch ausgefahren“.
    3.  Ein `counter` um die Anzahl der automatischen Einfahrvorgänge zu zählen.
    4.  Ein `sensor` (z.B. ein Statistik-Sensor) für die akkumulierte Regenmenge über einen bestimmten Zeitraum.
    
  domain: automation
  
  input:
    marquise_retract_switch:
      name: Markise Einfahr-Switch
      description: |
        Der **Switch** mit dem die Markise eingefahren wird.
        (z.B. `switch.markise_einfahren`)
      selector:
        entity:
          domain: switch
    marquise_extend_switch:
      name: Markise Ausfahr-Switch
      description: |
        Der **Switch** mit dem die Markise ausgefahren wird.
        (z.B. `switch.markise_ausfahren`)
      selector:
        entity:
          domain: switch
    wind_sensor:
      name: Windsensor-Entität
      description: |
        Der **Numerische Sensor** der die aktuelle Windgeschwindigkeit in km/h misst.
        (z.B. `sensor.ecowitt_ws90_wind_max`)
      selector:
        entity:
          domain: sensor
          multiple: false
          filter:
            - device_class: wind_speed
    rain_sensor:
      name: Regensensor-Entität
      description: |-
        Der **Numerische Sensor**, der die Regenmenge misst.
        (z.B. `sensor.rain_last_5_minutes`)
        
        Erfordert einen Statistik-Sensor; der Niederschlag sollte in einem möglichst kurzen
        Zeitraum summiert werden, um schnell auf Regen reagieren zu können. Der Zeitraum darf
        jedoch auch nicht **zu** kurz sein (viele Regensensoren lösen nur in 1mm-Schritten auf).
        
        **Anlegen des Helfers:**
        `Einstellungen → Geräte & Dienste → Helfer → Helfer erstellen → Statistik`
        * **Entität:** dein Regensensor (=Quellsensor für die Berechnung)
        * **Statistikmerkmal:** Summe der Differenzen
        * **Stichprobengröße:** [Quellsensor-Updates / Minute] x [Maximalalter] + [kleiner Puffer]
        * **Maximalalter:** z.B. 5 Minuten
        * **Letzten Messwert behalten:** nein
        * **Genauigkeit:** 1
      selector:
        entity:
          domain: sensor
          multiple: false
          filter:
            - device_class:
                - volume
                - precipitation
    marquise_status_sensor:
      name: Markisenstatus-Sensor
      description: |
        Der **Binärsensor**, der den aktuellen Status der Markise anzeigt.
        (`on` = Markise ausgefahren, `off` = Markise eingefahren)
      selector:
        entity:
          domain: binary_sensor
          multiple: false
          filter:
            - device_class:
                - window
                - opening
    wind_max_threshold:
      name: Maximale Windschwelle (km/h)
      description: |
        Der numerische Wert in km/h, ab dem die Markise automatisch eingefahren wird.
        (Standard: 27 km/h)
      default: 27
      selector:
        number:
          min: 0
          max: 100
          unit_of_measurement: km/h
          mode: box
    wind_min_threshold:
      name: Minimale Windschwelle (km/h)
      description: |
        Der numerische Wert in km/h, unter den die Windgeschwindigkeit fallen muss, damit die Markise wieder automatisch ausgefahren wird.
        (Standard: 20 km/h)
      default: 20
      selector:
        number:
          min: 0
          max: 100
          unit_of_measurement: km/h
          mode: box
    automatic_extend_timeout_minutes:
      name: Zeitspanne für automatisches Ausfahren (Minuten)
      description: |
        Die Zeit in Minuten, die vergehen muss, nachdem Wind und Regen unter den Grenzwert gefallen sind, bevor die Markise wieder ausfährt.
        (Standard: 30 Minuten)
      default: 30
      selector:
        number:
          min: 1
          max: 120
          unit_of_measurement: min
          mode: box
    rain_threshold:
      name: Regenschwelle (mm)
      description: |
        Der numerische Wert in mm/m² (aus der **Regensensor-Entität**), ab dem die Markise eingefahren wird.
        (Standard: 0.7 mm/m²)
      default: 0.7
      selector:
        number:
          step: 0.1
          min: 0
          max: 10
          unit_of_measurement: mm/m²
          mode: box
    wind_sensor_timeout_minutes:
      name: Windsensor-Timeout (Minuten)
      description: |
        Die Zeitspanne in Minuten, nach der ein fehlender Windsensor die Markise automatisch einfährt.
        (Standard: 15 Minuten)
      default: 15
      selector:
        number:
          min: 1
          max: 60
          unit_of_measurement: min
          mode: box
    sensors_timeout_minutes:
      name: Sensoren-Timeout (Minuten)
      description: |
        Die Zeitspanne in Minuten, nach der fehlende Sensoren eine Warnung auslösen und versucht wird, die Markise automatisch einzufahren.
        (Standard: 15 Minuten)
      default: 15
      selector:
        number:
          min: 1
          max: 60
          unit_of_measurement: min
          mode: box
    automatic_retract_count_threshold:
      name: Zählergrenzwert für automatisches Einfahren
      description: |
        Der numerische Wert, wie oft die Markise automatisch eingefahren werden darf, bevor eine Benachrichtigung gesendet wird.
        (Standard: 2 mal)
      default: 2
      selector:
        number:
          min: 1
          max: 10
          mode: box
    automatic_retracted_helper:
      name: Helfer für "automatisch eingefahren"
      description: |
        Ein `input_boolean`-Helfer, der den Status anzeigt, wenn die Markise automatisch eingefahren wurde.
      selector:
        entity:
          domain: input_boolean
    automatic_extended_helper:
      name: Helfer für "automatisch ausgefahren"
      description: |
        Ein `input_boolean`-Helfer, der den Status anzeigt, wenn die Markise automatisch ausgefahren wurde.
      selector:
        entity:
          domain: input_boolean
    retract_counter_helper:
      name: Helfer für Einfahrzähler
      description: |
        Ein `counter`-Helfer, der die Anzahl der automatischen Einfahrvorgänge zählt.
      selector:
        entity:
          domain: counter
    reset_time:
      name: Tägliche Reset-Uhrzeit
      description: |
        Die Uhrzeit, zu der der Zähler und die Status-Helfer täglich zurückgesetzt werden sollen.
        (Standard: 00:00:00)
      default: "00:00:00"
      selector:
        time:

trigger:
  # Auslöser: Windgeschwindigkeit über maximalem Schwellenwert
  - platform: numeric_state
    id: trigger_windsensor_max_threshold
    entity_id: !input wind_sensor
    above: !input wind_max_threshold
  # Auslöser: Regenmenge über Schwellenwert
  - platform: numeric_state
    id: trigger_rain_statistic_sensor
    entity_id: !input rain_sensor
    above: !input rain_threshold
  # Auslöser: Markise wird manuell ausgefahren
  - platform: state
    id: trigger_marquise_opened
    entity_id: !input marquise_status_sensor
    from: "off"
    to: "on"
  # Auslöser: Markise wird manuell eingefahren
  - platform: state
    id: trigger_marquise_closed
    entity_id: !input marquise_status_sensor
    from: "on"
    to: "off"
  # Auslöser: Windgeschwindigkeit unter minimalem Schwellenwert für eine bestimmte Zeit
  - platform: numeric_state
    id: trigger_windsensor_min_threshold
    entity_id: !input wind_sensor
    below: !input wind_min_threshold
    for:
      minutes: !input automatic_extend_timeout_minutes
  # Auslöser: Windsensor ist nicht verfügbar oder unbekannt für eine bestimmte Zeit
  - platform: state
    id: trigger_windsensor_unknown
    entity_id: !input wind_sensor
    to:
      - unavailable
      - unknown
    for:
      minutes: !input wind_sensor_timeout_minutes
  # Auslöser: Mehrere Sensoren (Wind, Status, Steuerung) sind nicht verfügbar oder unbekannt
  - platform: state
    id: trigger_sensors_unknown
    entity_id:
      - !input wind_sensor
      - !input marquise_status_sensor
      - !input marquise_retract_switch
      - !input marquise_extend_switch
    to:
      - unavailable
      - unknown
    for:
      minutes: !input sensors_timeout_minutes
  # Auslöser: Der Einfahr-Zähler überschreitet den konfigurierten Grenzwert
  - platform: numeric_state
    id: trigger_retract_counter
    entity_id: !input retract_counter_helper
    above: !input automatic_retract_count_threshold
  # Auslöser: Tägliches Reset um Mitternacht
  - platform: time
    id: trigger_reset_time
    at: !input reset_time

condition: []

action:
  - variables:
      wind_speed: !input wind_sensor
      rain_amount: !input rain_sensor
      retract_count: !input retract_counter_helper
  - choose:
      # Aktion: Starkwind erkannt
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_max_threshold
        sequence:
          # Wenn Markise bereits geschlossen ist, tue nichts
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
            alias: Wenn Markise geschlossen -> tue nichts
          # Wenn Markise geöffnet ist, fahre sie ein
          - alias: Wenn Markise geöffnet -> Einfahren
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: counter.increment
                target:
                  entity_id: !input retract_counter_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Starkwind
                service: notify.notify
                data:
                  title: "Starkwind erkannt"
                  message: "Markise wurde wegen Starkwind ({{ states(wind_speed) }} km/h) automatisch eingefahren."
          # Wenn Markisenstatus unbekannt ist, fahre sie sicherheitshalber ein
          - alias: Wenn Markisenstatus unbekannt -> Einfahren
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unknown
                  - unavailable
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Starkwind (Status unbekannt)
                service: notify.notify
                data:
                  title: "Starkwind - Markisenstatus unbekannt"
                  message: "Markise wurde wegen Starkwind ({{ states(wind_speed) }} km/h) automatisch eingefahren. ACHTUNG: Markisenstatus unbekannt!"
        alias: Starkwind
      # Aktion: Windsensor-Timeout
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_unknown
        sequence:
          # Wenn Markise geschlossen ist, tue nichts
          - alias: Markise geschlossen -> tue nichts
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
          # Wenn Markisenstatus unbekannt, schließe Markise sicherheitshalber
          - alias: Markisenstatus unbekannt -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unavailable
                  - unknown
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Windsensor-Timeout
                service: notify.notify
                data:
                  title: "Windsensor-Timeout"
                  message: "Markise wird eingefahren, da der Windsensor nicht erreichbar ist."
          # Wenn Markise geöffnet ist, schließe Markise
          - alias: Markise geöffnet -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Windsensor-Timeout
                service: notify.notify
                data:
                  title: "Windsensor-Timeout"
                  message: "Markise wird eingefahren, da der Windsensor nicht erreichbar ist."
        alias: Windsensor-Timeout
      # Aktion: Regen erkannt
      - conditions:
          - condition: trigger
            id:
              - trigger_rain_statistic_sensor
        sequence:
          # Wenn Markise geschlossen ist, tue nichts
          - alias: Markise geschlossen -> tue nichts
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
          # Wenn Markisenstatus unbekannt, schließe Markise sicherheitshalber
          - alias: Markisenstatus unbekannt -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unavailable
                  - unknown
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Regen (Status unbekannt)
                service: notify.notify
                data:
                  title: "Regen erkannt - Markisenstatus unbekannt"
                  message: "Markise wird wegen Regen ({{ states(rain_amount) }} mm) eingefahren. Status unbekannt!"
          # Wenn Markise geöffnet ist, schließe Markise
          - alias: Markise geöffnet -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Regen erkannt
                service: notify.notify
                data:
                  title: "Regen erkannt"
                  message: "Markise wird wegen Regen ({{ states(rain_amount) }} mm) eingefahren."
        alias: Regen
      # Aktion: Manuelles Ausfahren
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_opened
              - condition: state
                entity_id: !input automatic_extended_helper
                state: "off"
        sequence:
          - if:
              - condition: numeric_state
                entity_id: !input wind_sensor
                above: !input wind_max_threshold
            then:
              - alias: Benachrichtigung manuell Ausgefahren trotz Starkwind
                service: notify.notify
                data:
                  title: "Markisenwächter - WARNUNG"
                  message: "Die Markise wurde trotz Starkwind manuell ausgefahren. Das automatische Einfahren ist bis zum UNTERschreiten des Schwellenwertes INAKTIV!"
          - if:
              - condition: numeric_state
                entity_id: !input retract_counter_helper
                above: 0
            then:
              - service: counter.reset
                target:
                  entity_id: !input retract_counter_helper
              - alias: Benachrichtigung Manuell Ausgefahren
                service: notify.notify
                data:
                  title: "Markise manuell ausgefahren"
                  message: "Der Markisen-Zähler wurde durch manuelles Ausfahren zurückgesetzt."
        alias: Markise manuell ausgefahren
      # Markise wurde automatisch ausgefahren - verhindert Fallback auf den Default-Block
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_opened
              - condition: state
                entity_id: !input automatic_extended_helper
                state: "on"
        sequence: [] # Tue nichts, da die Aktion bereits durch einen anderen Block ausgelöst wurde
        alias: Automatisch ausgefahren - tue nichts
      # Aktion: Manuelles Einfahren
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_closed
              - condition: state
                entity_id: !input automatic_retracted_helper
                state: "off"
        sequence:
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_extended_helper
        alias: Markise manuell eingefahren
      # Markise wurde automatisch eingefahren - verhindert Fallback auf den Default-Block
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_closed
              - condition: state
                entity_id: !input automatic_retracted_helper
                state: "on"
        sequence: [] # Tue nichts, da die Aktion bereits durch einen anderen Block ausgelöst wurde
        alias: Automatisch eingefahren - tue nichts
      # Aktion: Zählerschutz-Benachrichtigung
      - conditions:
          - condition: trigger
            id:
              - trigger_retract_counter
        sequence:
          - alias: Benachrichtigung Zählerschutz
            service: notify.notify
            data:
              title: "Markisen-Zählerschutz aktiv"
              message: "Markise wurde in kurzer Zeit {{ states(retract_count) }} Mal automatisch eingefahren. Automatisches Ausfahren ist gesperrt."
        alias: Benachrichtigung Ausfahrsperre aktiv
      # Aktion: Tägliches Reset
      - conditions:
          - condition: trigger
            id:
              - trigger_reset_time
        sequence:
          - service: counter.reset
            target:
              entity_id: !input retract_counter_helper
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_extended_helper
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_retracted_helper
        alias: Zeitlicher Reset der Automation
      # Aktion: Sensor-Fehlerwarnung
      - conditions:
          - condition: trigger
            id:
              - trigger_sensors_unknown
        sequence:
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: counter.increment
                target:
                  entity_id: !input retract_counter_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Sensor-Fehler (Einfahren)
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Markise wurde eingefahren, da kritische Sensoren nicht erreichbar sind."
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - "off"
            then:
              - alias: Benachrichtigung Sensor-Fehler
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Achtung! Einer oder mehrere kritische Sensoren des Markisenwächters sind nicht verfügbar!"
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - "unavailable"
                  - "unknown"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - alias: Benachrichtigung Sensor-Fehler (Status unbekannt)
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Achtung! Einer oder mehrere kritische Sensoren des Markisenwächters sind nicht verfügbar! Markise wird sicherheitshalber eingefahren."
        alias: "Warnung: Sensor(en) nicht verfügbar"
      # Aktion: Wind lässt nach, Markise wieder ausfahren
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_min_threshold
        sequence:
          - if:
              - condition: and
                conditions:
                  - condition: state
                    entity_id: !input automatic_retracted_helper
                    state: "on"
                  - condition: numeric_state
                    entity_id: !input rain_sensor
                    below: !input rain_threshold
            then:
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_extended_helper
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_extend_switch
              - alias: Benachrichtigung Wind lässt nach
                service: notify.notify
                data:
                  title: "Wind lässt nach"
                  message: "Windstärke ({{ states(wind_speed) }} km/h) und Regen ({{ states(rain_amount) }} mm) sind unter den Schwellenwert gefallen. Markise wird wieder ausgefahren."
        alias: Wind lässt nach
    # Standardaktion, wenn kein Trigger zutrifft
    default:
      - alias: Benachrichtigung unbekannter Fehler
        service: notify.notify
        data:
          title: "Markisenwächter - Fehler"
          message: "Ein Fehler oder eine unbekannte Situation ist aufgetreten. Bitte überprüfe das Log und die Sensoren/Steuerungen."

mode: single
1 „Gefällt mir“

YAML-Code v1.8

(2025-11-22)

Änderung:
Die Blueprint-Inputs für den “Switch” mit dem die Markise ein- oder ausgefahren wird, wurde nun von der Domain switch um die Domain button erweitert.

# Changelog:
# v1 - initiale Release mit Basisfunktionen
#
# v1.1 (2025-07-22):
# - Finetuning der Notification im Default (statt auf einen möglichen Fehler wird auch auf eine mögliche
#   unbekannte Sensor-Kombitnation hingewiesen)
# - Bei nachlassendem Wind wurde unter bestimmten Bedingungen der Default-Teil des Ablaufes getriggert - korrigiert
# - Bei Starkwind und eingefahrener Markise wurde der Default-Teil des Ablaufes getriggert - korrigiert
# - Warnung wird ausgegeben und ein Schließen der Markise initiiert, falls Starkwind aufkommt, der Status der Markise
#   jedoch unbekannt ist
#
# v1.2 (2025-07-23):
# - Detailliertere Dokumentation der benötigten Entitäten
# - Karteileiche "Regensensor (Statistik) - Intervall" entfernt
# - Umbenennungen einiger Inputs
# - Erweiterung um zusätzliche Bedingungs-Zweige, um folgende Szenarien explizit zu behandeln und Default-Meldungen zu vermeiden:
#   - Nachlassender Wind, Markise bereits ausgefahren
#   - Regenschauer, Markise bereits eingefahren
#   - Counter-Überlauf, Markise bereits eingefahren
#   - Windsensor-Timeout, Markise bereits eingefahren
# - Das Default-Handling wird damit weiter minimiert und die Automation zuverlässiger.
#
# v1.3 (2025-07-27):
# Kompletter Neuaufbau der zugrundeliegenden Automation:
#  - Code-Struktur vollständig überarbeitet
#  - IDs in Vorbereitung auf eine Übersetzung ins Englische auf Englisch formuliert
#  - Einheitliche Nutzung von choose-Blöcken mit trigger.id statt kombinierter Bedingungen
#  - Bessere Trennung von Aktionen, Bedingungen und Auslösern
#  - Dokumentation deutlich klarer und strukturierter formuliert
#  - Blueprint-Inputs neu strukturiert und besser gruppiert
#  - Automatisches Ausfahren: Nur bei gleichzeitig unterminimiertem Wind und keinem Regen
#  - Reset der Helfer (input.booleans) erfolgt nun gemeinsam mit dem Zähler 
#  - Klare Trennung zwischen manuellem und automatischem Aus- oder Einfahren
#  - Grenzwert für automatische Einfahrvorgänge frei wählbar (automatic_retract_count_threshold)
#    und Hinweis per Notification bei Überschreitung
#
# v1.4 (2025-08-07)
#  - Sensor-Filter für Inputs aufgenommen
#
# v1.5 (2025-08-10)
#  - Schrittgröße für die Regenschwelle vom Default (= 1) auf 0.1 korrigiert
#
# v1.6 (2025-08-16)
#  - Bugfix: Input `Sensoren-Timeout (Minuten)` wurde im Trigger als Sekunden-Wert übernommen
#
# v1.7 (2025-09-07)
#  - Bugfix: In den Notifications wurden die Namen der Sensoren, aber nicht die States ausgegeben
#  - Bugfix: Beim automatischen Ein- und Ausfahren wurde nach Abschluss der Aktion der Default-Block ("Fehler oder unbekannte Situation") ausgelöst
#  - Warnung wird ausgelöst, wenn trotz Starkwind die Markise ausgefahren wird (Grund: der Wind-Threshold greift nur, wenn von einem niedrigeren Wert ausgehend der Schwellenwert überschritten wird)
#
# v1.8 (2025-11-22)
#  - "button" als mögliche input domain für das ein- und ausfahren der Markise hinzugefügt


blueprint:
  name: Markisenwächter v1.8
  description: |
    Dieser Blueprint bietet eine erweiterte Automatisierung für eine Markise basierend auf verschiedenen Sensordaten wie Wind und Regen.
    ### Funktionen:
    * **Windüberwachung:** Fährt die Markise automatisch ein, wenn eine konfigurierbare Windgeschwindigkeit überschritten wird.
    * **Regenüberwachung:** Fährt die Markise automatisch ein, wenn eine konfigurierbare Regenmenge innerhalb eines Zeitraums erkannt wird.
    * **Wind-Timeout:** Fährt die Markise sicherheitshalber ein, wenn der Windsensor für eine bestimmte Zeit nicht erreichbar ist.
    * **Sensor-Überwachung:** Sendet eine Benachrichtigung, wenn wichtige Sensoren wie Wind, Markisenstatus oder die Steuerungs-Switches nicht erreichbar sind.
    * **Automatisches Ausfahren:** Fährt die Markise wieder aus, wenn der Wind unter den Grenzwert fällt und kein Regen erkannt wird.
    * **Zählerschutz:** Zählt die automatischen Einfahrvorgänge. Bei Überschreiten eines Grenzwertes wird eine Benachrichtigung gesendet und ein weiteres Ausfahren unterbunden, um ein häufiges, unnötiges Ein- und Ausfahren zu verhindern.
    * **Manuelle Steuerung:** Erkennt manuelle Eingriffe (Aus- und Einfahren) und setzt interne Zähler zurück oder passt Status-Helfer an.
    * **Täglicher Reset:** Setzt den Einfahr-Zähler und die internen Status-Helfer täglich zurück.
    ### Notwendige Konfiguration:
    Dieser Blueprint erfordert die Konfiguration der folgenden Helfer (helpers) in Home Assistant:
    1.  Ein `input_boolean` für den Status „Markise automatisch eingefahren“.
    2.  Ein `input_boolean` für den Status „Markise automatisch ausgefahren“.
    3.  Ein `counter` um die Anzahl der automatischen Einfahrvorgänge zu zählen.
    4.  Ein `sensor` (z.B. ein Statistik-Sensor) für die akkumulierte Regenmenge über einen bestimmten Zeitraum.
    
  domain: automation
  
  input:
    marquise_retract_switch:
      name: Markise Einfahr-Switch
      description: |
        Der **Switch** mit dem die Markise eingefahren wird.
        (z.B. `switch.markise_einfahren`)
      selector:
        entity:
          domain:
            - switch
            - button
    marquise_extend_switch:
      name: Markise Ausfahr-Switch
      description: |
        Der **Switch** mit dem die Markise ausgefahren wird.
        (z.B. `switch.markise_ausfahren`)
      selector:
        entity:
          domain:
            - switch
            - button
    wind_sensor:
      name: Windsensor-Entität
      description: |
        Der **Numerische Sensor** der die aktuelle Windgeschwindigkeit in km/h misst.
        (z.B. `sensor.ecowitt_ws90_wind_max`)
      selector:
        entity:
          domain: sensor
          multiple: false
          filter:
            - device_class: wind_speed
    rain_sensor:
      name: Regensensor-Entität
      description: |-
        Der **Numerische Sensor**, der die Regenmenge misst.
        (z.B. `sensor.rain_last_5_minutes`)
        
        Erfordert einen Statistik-Sensor; der Niederschlag sollte in einem möglichst kurzen
        Zeitraum summiert werden, um schnell auf Regen reagieren zu können. Der Zeitraum darf
        jedoch auch nicht **zu** kurz sein (viele Regensensoren lösen nur in 1mm-Schritten auf).
        
        **Anlegen des Helfers:**
        `Einstellungen → Geräte & Dienste → Helfer → Helfer erstellen → Statistik`
        * **Entität:** dein Regensensor (=Quellsensor für die Berechnung)
        * **Statistikmerkmal:** Summe der Differenzen
        * **Stichprobengröße:** [Quellsensor-Updates / Minute] x [Maximalalter] + [kleiner Puffer]
        * **Maximalalter:** z.B. 5 Minuten
        * **Letzten Messwert behalten:** nein
        * **Genauigkeit:** 1
      selector:
        entity:
          domain: sensor
          multiple: false
          filter:
            - device_class:
                - volume
                - precipitation
    marquise_status_sensor:
      name: Markisenstatus-Sensor
      description: |
        Der **Binärsensor**, der den aktuellen Status der Markise anzeigt.
        (`on` = Markise ausgefahren, `off` = Markise eingefahren)
      selector:
        entity:
          domain: binary_sensor
          multiple: false
          filter:
            - device_class:
                - window
                - opening
    wind_max_threshold:
      name: Maximale Windschwelle (km/h)
      description: |
        Der numerische Wert in km/h, ab dem die Markise automatisch eingefahren wird.
        (Standard: 27 km/h)
      default: 27
      selector:
        number:
          min: 0
          max: 100
          unit_of_measurement: km/h
          mode: box
    wind_min_threshold:
      name: Minimale Windschwelle (km/h)
      description: |
        Der numerische Wert in km/h, unter den die Windgeschwindigkeit fallen muss, damit die Markise wieder automatisch ausgefahren wird.
        (Standard: 20 km/h)
      default: 20
      selector:
        number:
          min: 0
          max: 100
          unit_of_measurement: km/h
          mode: box
    automatic_extend_timeout_minutes:
      name: Zeitspanne für automatisches Ausfahren (Minuten)
      description: |
        Die Zeit in Minuten, die vergehen muss, nachdem Wind und Regen unter den Grenzwert gefallen sind, bevor die Markise wieder ausfährt.
        (Standard: 30 Minuten)
      default: 30
      selector:
        number:
          min: 1
          max: 120
          unit_of_measurement: min
          mode: box
    rain_threshold:
      name: Regenschwelle (mm)
      description: |
        Der numerische Wert in mm/m² (aus der **Regensensor-Entität**), ab dem die Markise eingefahren wird.
        (Standard: 0.7 mm/m²)
      default: 0.7
      selector:
        number:
          step: 0.1
          min: 0
          max: 10
          unit_of_measurement: mm/m²
          mode: box
    wind_sensor_timeout_minutes:
      name: Windsensor-Timeout (Minuten)
      description: |
        Die Zeitspanne in Minuten, nach der ein fehlender Windsensor die Markise automatisch einfährt.
        (Standard: 15 Minuten)
      default: 15
      selector:
        number:
          min: 1
          max: 60
          unit_of_measurement: min
          mode: box
    sensors_timeout_minutes:
      name: Sensoren-Timeout (Minuten)
      description: |
        Die Zeitspanne in Minuten, nach der fehlende Sensoren eine Warnung auslösen und versucht wird, die Markise automatisch einzufahren.
        (Standard: 15 Minuten)
      default: 15
      selector:
        number:
          min: 1
          max: 60
          unit_of_measurement: min
          mode: box
    automatic_retract_count_threshold:
      name: Zählergrenzwert für automatisches Einfahren
      description: |
        Der numerische Wert, wie oft die Markise automatisch eingefahren werden darf, bevor eine Benachrichtigung gesendet wird.
        (Standard: 2 mal)
      default: 2
      selector:
        number:
          min: 1
          max: 10
          mode: box
    automatic_retracted_helper:
      name: Helfer für "automatisch eingefahren"
      description: |
        Ein `input_boolean`-Helfer, der den Status anzeigt, wenn die Markise automatisch eingefahren wurde.
      selector:
        entity:
          domain: input_boolean
    automatic_extended_helper:
      name: Helfer für "automatisch ausgefahren"
      description: |
        Ein `input_boolean`-Helfer, der den Status anzeigt, wenn die Markise automatisch ausgefahren wurde.
      selector:
        entity:
          domain: input_boolean
    retract_counter_helper:
      name: Helfer für Einfahrzähler
      description: |
        Ein `counter`-Helfer, der die Anzahl der automatischen Einfahrvorgänge zählt.
      selector:
        entity:
          domain: counter
    reset_time:
      name: Tägliche Reset-Uhrzeit
      description: |
        Die Uhrzeit, zu der der Zähler und die Status-Helfer täglich zurückgesetzt werden sollen.
        (Standard: 00:00:00)
      default: "00:00:00"
      selector:
        time:

trigger:
  # Auslöser: Windgeschwindigkeit über maximalem Schwellenwert
  - platform: numeric_state
    id: trigger_windsensor_max_threshold
    entity_id: !input wind_sensor
    above: !input wind_max_threshold
  # Auslöser: Regenmenge über Schwellenwert
  - platform: numeric_state
    id: trigger_rain_statistic_sensor
    entity_id: !input rain_sensor
    above: !input rain_threshold
  # Auslöser: Markise wird manuell ausgefahren
  - platform: state
    id: trigger_marquise_opened
    entity_id: !input marquise_status_sensor
    from: "off"
    to: "on"
  # Auslöser: Markise wird manuell eingefahren
  - platform: state
    id: trigger_marquise_closed
    entity_id: !input marquise_status_sensor
    from: "on"
    to: "off"
  # Auslöser: Windgeschwindigkeit unter minimalem Schwellenwert für eine bestimmte Zeit
  - platform: numeric_state
    id: trigger_windsensor_min_threshold
    entity_id: !input wind_sensor
    below: !input wind_min_threshold
    for:
      minutes: !input automatic_extend_timeout_minutes
  # Auslöser: Windsensor ist nicht verfügbar oder unbekannt für eine bestimmte Zeit
  - platform: state
    id: trigger_windsensor_unknown
    entity_id: !input wind_sensor
    to:
      - unavailable
      - unknown
    for:
      minutes: !input wind_sensor_timeout_minutes
  # Auslöser: Mehrere Sensoren (Wind, Status, Steuerung) sind nicht verfügbar oder unbekannt
  - platform: state
    id: trigger_sensors_unknown
    entity_id:
      - !input wind_sensor
      - !input marquise_status_sensor
      - !input marquise_retract_switch
      - !input marquise_extend_switch
    to:
      - unavailable
      - unknown
    for:
      minutes: !input sensors_timeout_minutes
  # Auslöser: Der Einfahr-Zähler überschreitet den konfigurierten Grenzwert
  - platform: numeric_state
    id: trigger_retract_counter
    entity_id: !input retract_counter_helper
    above: !input automatic_retract_count_threshold
  # Auslöser: Tägliches Reset um Mitternacht
  - platform: time
    id: trigger_reset_time
    at: !input reset_time

condition: []

action:
  - variables:
      wind_speed: !input wind_sensor
      rain_amount: !input rain_sensor
      retract_count: !input retract_counter_helper
  - choose:
      # Aktion: Starkwind erkannt
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_max_threshold
        sequence:
          # Wenn Markise bereits geschlossen ist, tue nichts
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
            alias: Wenn Markise geschlossen -> tue nichts
          # Wenn Markise geöffnet ist, fahre sie ein
          - alias: Wenn Markise geöffnet -> Einfahren
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: counter.increment
                target:
                  entity_id: !input retract_counter_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Starkwind
                service: notify.notify
                data:
                  title: "Starkwind erkannt"
                  message: "Markise wurde wegen Starkwind ({{ states(wind_speed) }} km/h) automatisch eingefahren."
          # Wenn Markisenstatus unbekannt ist, fahre sie sicherheitshalber ein
          - alias: Wenn Markisenstatus unbekannt -> Einfahren
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unknown
                  - unavailable
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Starkwind (Status unbekannt)
                service: notify.notify
                data:
                  title: "Starkwind - Markisenstatus unbekannt"
                  message: "Markise wurde wegen Starkwind ({{ states(wind_speed) }} km/h) automatisch eingefahren. ACHTUNG: Markisenstatus unbekannt!"
        alias: Starkwind
      # Aktion: Windsensor-Timeout
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_unknown
        sequence:
          # Wenn Markise geschlossen ist, tue nichts
          - alias: Markise geschlossen -> tue nichts
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
          # Wenn Markisenstatus unbekannt, schließe Markise sicherheitshalber
          - alias: Markisenstatus unbekannt -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unavailable
                  - unknown
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Windsensor-Timeout
                service: notify.notify
                data:
                  title: "Windsensor-Timeout"
                  message: "Markise wird eingefahren, da der Windsensor nicht erreichbar ist."
          # Wenn Markise geöffnet ist, schließe Markise
          - alias: Markise geöffnet -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Windsensor-Timeout
                service: notify.notify
                data:
                  title: "Windsensor-Timeout"
                  message: "Markise wird eingefahren, da der Windsensor nicht erreichbar ist."
        alias: Windsensor-Timeout
      # Aktion: Regen erkannt
      - conditions:
          - condition: trigger
            id:
              - trigger_rain_statistic_sensor
        sequence:
          # Wenn Markise geschlossen ist, tue nichts
          - alias: Markise geschlossen -> tue nichts
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
          # Wenn Markisenstatus unbekannt, schließe Markise sicherheitshalber
          - alias: Markisenstatus unbekannt -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unavailable
                  - unknown
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Regen (Status unbekannt)
                service: notify.notify
                data:
                  title: "Regen erkannt - Markisenstatus unbekannt"
                  message: "Markise wird wegen Regen ({{ states(rain_amount) }} mm) eingefahren. Status unbekannt!"
          # Wenn Markise geöffnet ist, schließe Markise
          - alias: Markise geöffnet -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Regen erkannt
                service: notify.notify
                data:
                  title: "Regen erkannt"
                  message: "Markise wird wegen Regen ({{ states(rain_amount) }} mm) eingefahren."
        alias: Regen
      # Aktion: Manuelles Ausfahren
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_opened
              - condition: state
                entity_id: !input automatic_extended_helper
                state: "off"
        sequence:
          - if:
              - condition: numeric_state
                entity_id: !input wind_sensor
                above: !input wind_max_threshold
            then:
              - alias: Benachrichtigung manuell Ausgefahren trotz Starkwind
                service: notify.notify
                data:
                  title: "Markisenwächter - WARNUNG"
                  message: "Die Markise wurde trotz Starkwind manuell ausgefahren. Das automatische Einfahren ist bis zum UNTERschreiten des Schwellenwertes INAKTIV!"
          - if:
              - condition: numeric_state
                entity_id: !input retract_counter_helper
                above: 0
            then:
              - service: counter.reset
                target:
                  entity_id: !input retract_counter_helper
              - alias: Benachrichtigung Manuell Ausgefahren
                service: notify.notify
                data:
                  title: "Markise manuell ausgefahren"
                  message: "Der Markisen-Zähler wurde durch manuelles Ausfahren zurückgesetzt."
        alias: Markise manuell ausgefahren
      # Markise wurde automatisch ausgefahren - verhindert Fallback auf den Default-Block
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_opened
              - condition: state
                entity_id: !input automatic_extended_helper
                state: "on"
        sequence: [] # Tue nichts, da die Aktion bereits durch einen anderen Block ausgelöst wurde
        alias: Automatisch ausgefahren - tue nichts
      # Aktion: Manuelles Einfahren
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_closed
              - condition: state
                entity_id: !input automatic_retracted_helper
                state: "off"
        sequence:
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_extended_helper
        alias: Markise manuell eingefahren
      # Markise wurde automatisch eingefahren - verhindert Fallback auf den Default-Block
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_closed
              - condition: state
                entity_id: !input automatic_retracted_helper
                state: "on"
        sequence: [] # Tue nichts, da die Aktion bereits durch einen anderen Block ausgelöst wurde
        alias: Automatisch eingefahren - tue nichts
      # Aktion: Zählerschutz-Benachrichtigung
      - conditions:
          - condition: trigger
            id:
              - trigger_retract_counter
        sequence:
          - alias: Benachrichtigung Zählerschutz
            service: notify.notify
            data:
              title: "Markisen-Zählerschutz aktiv"
              message: "Markise wurde in kurzer Zeit {{ states(retract_count) }} Mal automatisch eingefahren. Automatisches Ausfahren ist gesperrt."
        alias: Benachrichtigung Ausfahrsperre aktiv
      # Aktion: Tägliches Reset
      - conditions:
          - condition: trigger
            id:
              - trigger_reset_time
        sequence:
          - service: counter.reset
            target:
              entity_id: !input retract_counter_helper
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_extended_helper
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_retracted_helper
        alias: Zeitlicher Reset der Automation
      # Aktion: Sensor-Fehlerwarnung
      - conditions:
          - condition: trigger
            id:
              - trigger_sensors_unknown
        sequence:
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - service: counter.increment
                target:
                  entity_id: !input retract_counter_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Sensor-Fehler (Einfahren)
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Markise wurde eingefahren, da kritische Sensoren nicht erreichbar sind."
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - "off"
            then:
              - alias: Benachrichtigung Sensor-Fehler
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Achtung! Einer oder mehrere kritische Sensoren des Markisenwächters sind nicht verfügbar!"
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - "unavailable"
                  - "unknown"
            then:
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_retract_switch
              - alias: Benachrichtigung Sensor-Fehler (Status unbekannt)
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Achtung! Einer oder mehrere kritische Sensoren des Markisenwächters sind nicht verfügbar! Markise wird sicherheitshalber eingefahren."
        alias: "Warnung: Sensor(en) nicht verfügbar"
      # Aktion: Wind lässt nach, Markise wieder ausfahren
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_min_threshold
        sequence:
          - if:
              - condition: and
                conditions:
                  - condition: state
                    entity_id: !input automatic_retracted_helper
                    state: "on"
                  - condition: numeric_state
                    entity_id: !input rain_sensor
                    below: !input rain_threshold
            then:
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_extended_helper
              - service: homeassistant.turn_on
                target:
                  entity_id: !input marquise_extend_switch
              - alias: Benachrichtigung Wind lässt nach
                service: notify.notify
                data:
                  title: "Wind lässt nach"
                  message: "Windstärke ({{ states(wind_speed) }} km/h) und Regen ({{ states(rain_amount) }} mm) sind unter den Schwellenwert gefallen. Markise wird wieder ausgefahren."
        alias: Wind lässt nach
    # Standardaktion, wenn kein Trigger zutrifft
    default:
      - alias: Benachrichtigung unbekannter Fehler
        service: notify.notify
        data:
          title: "Markisenwächter - Fehler"
          message: "Ein Fehler oder eine unbekannte Situation ist aufgetreten. Bitte überprüfe das Log und die Sensoren/Steuerungen."

mode: single
1 „Gefällt mir“

Moin

TOP Sache und besten Dank

Meine Fragen:

  1. Wie ausgereift/ einsatzfähig ist es bis dato?
  2. Was benötige ich?
  3. Wie geh ich vor, wenn ich 2 Markisen habe in unterschiedlichen Windrichtungen und ggf. mit/ohne natürlichem Windschutz davor (Haus vs. offenes Feld)?

Besten Dank

VG

sasa

Hallo @sasa

die Automation funktioniert - zumindest konnte ich keine Fehler mehr feststellen.
„Ausgereift“ ist dabei ein dehnbarer Begriff, da ich noch die eine oder andere Funktion im Hinderkopf habe. More to come… :wink:

Was du benötigst, sind Sensoren wie in den Screenshots (Blueprint: Markisenwächter (automatisches Einfahren bei Wind und noch mehr) - #22 von madmat17) abgebildet.

Mehrere Markisen:
Du legst die Automation je Markise an (du kannst einen Blueprint beliebig oft anwenden).
Entweder hast du für jede Markise einen Windsensor (dann kannst sehr exakt basieren auf deren Exposition steuern), oder du setzt die Schwellenwerte entsprechen. Die stellst du die für jede Automation/Markise einzeln ein.

LG
Mat

Danke Mat

Ich habe keinen extra WÄCHTER.

Ich hatte gehofft, dass alles via Wetterstationdaten machen zu können.

Geht das auch?..klar, ist natürlich nicht so genau..

Man könnte zB noch den Taupunkt nehmen, um die Markise autom. Abends rein zufahren, damit das Tuch nicht so feucht ist/Wird

VG

sasa

Du benötigst keinen extra Wächer. Die aus dem Blueprint resultierende Automation ist der Wächter. :wink:
Du brauchst die Sensoren (bzw. Switches/Buttons), die du in den Screenshots siehst - bzw. dann in der Automation nach der Installation des Blueprints.

  • Einen Schalter zum Einfahren der Markise
  • Einen Schalter zum Ausfahren der Markise
  • Einen Windsensor (Wind muss in km/h ausgegeben werden - ggf. musst du einen Hilfssensor zur Umrechnung erstellen, falls dein Windsensor m/s ausgibt)
  • Einen Regensensor
  • Einen Markisenstatus-Sensor (der Anzeigt, ob die Markise offen oder geschlossen ist) - ich verwende hier einen Fenstersensor von Shelly)

Zudem musst du in HA folgende Helfer-Sensoren anlegen:

  1. Ein input_boolean für den Status „Markise automatisch eingefahren“.
  2. Ein input_boolean für den Status „Markise automatisch ausgefahren“.
  3. Ein counter um die Anzahl der automatischen Einfahrvorgänge zu zählen.
  4. Ein sensor (z.B. ein Statistik-Sensor) für die akkumulierte Regenmenge über einen bestimmten Zeitraum.

Beste Grüße und schöne Feiertage
Mat

1 „Gefällt mir“

Besten Dank!!

Hatte den “Wächter“ tatsächlich für einen “separaten“ gehalten, da in anderen theards auch immer die Rede davon war.

Vielen Dank für Deine ausführliche Erklärung, wird bestimmt noch Weiteren helfen.

Da werde ich mich dann mal über die Feiertage mit beschäftigen.

Frohes Fest Dir und allen

PS: Ist die Ausfallwahrscheinlichkeit der Station so gering (kam bei Dir bis dato nicht vor?) oder warum ist keine 2. hinterlegt?

Ich habe nur eine Wetterstation und habe deshalb den Blueprint auch nur für eine vorgesehen.
Aber es wird eine Warnung getriggert (wenn du die HA-App auf dem Telefon hast, siehst du diese dann auch dort), falls einer der relevanten Sensoren ausfällt.

@sasa, ein Nachsatz: Wenn du mehrere Automationen basierend auf dem Blueprint anlegst, musst du natürlich auch für jede Markise/Automation separate Helfer-Sensoren anlegen.

:crayon:by HarryP: Zusammenführung Doppelpost (bei Änderungen oder hinzufügen von Inhalten bitte die „Bearbeitungsfunktion“ anstatt „Antworten“ zu nutzen)

1 „Gefällt mir“

Hi All,

ACHTUNG: Die Version 1.8 des Markisenwächters funktioniert nicht länger in aktuelleren HA-Umgebungen!

Es gab offenbar eine Änderung in Home Assistant seit November 2025, welche die Aktion homeassistant.turn_on auf button-Entitäten unterbindet.

Ich habe als Emergency-Update den Blueprint dahingehend geändert, dass beim Einsatz einer button-Entität die Aktion button.press ausgeführt wird, bei cover-Entitäten wird die Aktion cover.close_cover bzw. cover.open_cover ausgerufen und in allen anderen fällen homeassistant.turn_on.

Die Version ist noch nicht ausgiebig getestet - bitte lasst mich wissen, sollten euch Fehler auffallen.

Der neue YAML-Code - v1.9:

# Changelog:
# v1 - initiale Release mit Basisfunktionen
#
# v1.1 (2025-07-22):
# - Finetuning der Notification im Default (statt auf einen möglichen Fehler wird auch auf eine mögliche
#   unbekannte Sensor-Kombitnation hingewiesen)
# - Bei nachlassendem Wind wurde unter bestimmten Bedingungen der Default-Teil des Ablaufes getriggert - korrigiert
# - Bei Starkwind und eingefahrener Markise wurde der Default-Teil des Ablaufes getriggert - korrigiert
# - Warnung wird ausgegeben und ein Schließen der Markise initiiert, falls Starkwind aufkommt, der Status der Markise
#   jedoch unbekannt ist
#
# v1.2 (2025-07-23):
# - Detailliertere Dokumentation der benötigten Entitäten
# - Karteileiche "Regensensor (Statistik) - Intervall" entfernt
# - Umbenennungen einiger Inputs
# - Erweiterung um zusätzliche Bedingungs-Zweige, um folgende Szenarien explizit zu behandeln und Default-Meldungen zu vermeiden:
#   - Nachlassender Wind, Markise bereits ausgefahren
#   - Regenschauer, Markise bereits eingefahren
#   - Counter-Überlauf, Markise bereits eingefahren
#   - Windsensor-Timeout, Markise bereits eingefahren
# - Das Default-Handling wird damit weiter minimiert und die Automation zuverlässiger.
#
# v1.3 (2025-07-27):
# Kompletter Neuaufbau der zugrundeliegenden Automation:
#  - Code-Struktur vollständig überarbeitet
#  - IDs in Vorbereitung auf eine Übersetzung ins Englische auf Englisch formuliert
#  - Einheitliche Nutzung von choose-Blöcken mit trigger.id statt kombinierter Bedingungen
#  - Bessere Trennung von Aktionen, Bedingungen und Auslösern
#  - Dokumentation deutlich klarer und strukturierter formuliert
#  - Blueprint-Inputs neu strukturiert und besser gruppiert
#  - Automatisches Ausfahren: Nur bei gleichzeitig unterminimiertem Wind und keinem Regen
#  - Reset der Helfer (input.booleans) erfolgt nun gemeinsam mit dem Zähler 
#  - Klare Trennung zwischen manuellem und automatischem Aus- oder Einfahren
#  - Grenzwert für automatische Einfahrvorgänge frei wählbar (automatic_retract_count_threshold)
#    und Hinweis per Notification bei Überschreitung
#
# v1.4 (2025-08-07)
#  - Sensor-Filter für Inputs aufgenommen
#
# v1.5 (2025-08-10)
#  - Schrittgröße für die Regenschwelle vom Default (= 1) auf 0.1 korrigiert
#
# v1.6 (2025-08-16)
#  - Bugfix: Input `Sensoren-Timeout (Minuten)` wurde im Trigger als Sekunden-Wert übernommen
#
# v1.7 (2025-09-07)
#  - Bugfix: In den Notifications wurden die Namen der Sensoren, aber nicht die States ausgegeben
#  - Bugfix: Beim automatischen Ein- und Ausfahren wurde nach Abschluss der Aktion der Default-Block ("Fehler oder unbekannte Situation") ausgelöst
#  - Warnung wird ausgelöst, wenn trotz Starkwind die Markise ausgefahren wird (Grund: der Wind-Threshold greift nur, wenn von einem niedrigeren Wert ausgehend der Schwellenwert überschritten wird)
#
# v1.8 (2025-11-22)
#  - "button" als mögliche input domain für das Ein- und Ausfahren der Markise hinzugefügt
#
# v1.9 (2026-05-05)
#  - "cover" als mögliche input domain für das Ein- und Ausfahren der Markise hinzugefügt
#  - Service-Call zum Ein- und Ausfahren der Markise an den Entitätstyp angepasst


blueprint:
  name: Markisenwächter v1.9
  description: |
    Dieser Blueprint bietet eine erweiterte Automatisierung für eine Markise basierend auf verschiedenen Sensordaten wie Wind und Regen.
    ### Funktionen:
    * **Windüberwachung:** Fährt die Markise automatisch ein, wenn eine konfigurierbare Windgeschwindigkeit überschritten wird.
    * **Regenüberwachung:** Fährt die Markise automatisch ein, wenn eine konfigurierbare Regenmenge innerhalb eines Zeitraums erkannt wird.
    * **Wind-Timeout:** Fährt die Markise sicherheitshalber ein, wenn der Windsensor für eine bestimmte Zeit nicht erreichbar ist.
    * **Sensor-Überwachung:** Sendet eine Benachrichtigung, wenn wichtige Sensoren wie Wind, Markisenstatus oder die Steuerungs-Switches nicht erreichbar sind.
    * **Automatisches Ausfahren:** Fährt die Markise wieder aus, wenn der Wind unter den Grenzwert fällt und kein Regen erkannt wird.
    * **Zählerschutz:** Zählt die automatischen Einfahrvorgänge. Bei Überschreiten eines Grenzwertes wird eine Benachrichtigung gesendet und ein weiteres Ausfahren unterbunden, um ein häufiges, unnötiges Ein- und Ausfahren zu verhindern.
    * **Manuelle Steuerung:** Erkennt manuelle Eingriffe (Aus- und Einfahren) und setzt interne Zähler zurück oder passt Status-Helfer an.
    * **Täglicher Reset:** Setzt den Einfahr-Zähler und die internen Status-Helfer täglich zurück.
    ### Notwendige Konfiguration:
    Dieser Blueprint erfordert die Konfiguration der folgenden Helfer (helpers) in Home Assistant:
    1.  Ein `input_boolean` für den Status „Markise automatisch eingefahren“.
    2.  Ein `input_boolean` für den Status „Markise automatisch ausgefahren“.
    3.  Ein `counter` um die Anzahl der automatischen Einfahrvorgänge zu zählen.
    4.  Ein `sensor` (z.B. ein Statistik-Sensor) für die akkumulierte Regenmenge über einen bestimmten Zeitraum.
    
  domain: automation
  
  input:
    marquise_retract_switch:
      name: Markise Einfahr-Switch
      description: |
        Der **Switch** mit dem die Markise eingefahren wird.
        (z.B. `switch.markise_einfahren`)
      selector:
        entity:
          domain:
            - switch
            - button
            - cover
    marquise_extend_switch:
      name: Markise Ausfahr-Switch
      description: |
        Der **Switch** mit dem die Markise ausgefahren wird.
        (z.B. `switch.markise_ausfahren`)
      selector:
        entity:
          domain:
            - switch
            - button
            - cover
    wind_sensor:
      name: Windsensor-Entität
      description: |
        Der **Numerische Sensor** der die aktuelle Windgeschwindigkeit in km/h misst.
        (z.B. `sensor.ecowitt_ws90_wind_max`)
      selector:
        entity:
          domain: sensor
          multiple: false
          filter:
            - device_class: wind_speed
    rain_sensor:
      name: Regensensor-Entität
      description: |-
        Der **Numerische Sensor**, der die Regenmenge misst.
        (z.B. `sensor.rain_last_5_minutes`)
        
        Erfordert einen Statistik-Sensor; der Niederschlag sollte in einem möglichst kurzen
        Zeitraum summiert werden, um schnell auf Regen reagieren zu können. Der Zeitraum darf
        jedoch auch nicht **zu** kurz sein (viele Regensensoren lösen nur in 1mm-Schritten auf).
        
        **Anlegen des Helfers:**
        `Einstellungen → Geräte & Dienste → Helfer → Helfer erstellen → Statistik`
        * **Entität:** dein Regensensor (=Quellsensor für die Berechnung)
        * **Statistikmerkmal:** Summe der Differenzen
        * **Stichprobengröße:** [Quellsensor-Updates / Minute] x [Maximalalter] + [kleiner Puffer]
        * **Maximalalter:** z.B. 5 Minuten
        * **Letzten Messwert behalten:** nein
        * **Genauigkeit:** 1
      selector:
        entity:
          domain: sensor
          multiple: false
          filter:
            - device_class:
                - volume
                - precipitation
    marquise_status_sensor:
      name: Markisenstatus-Sensor
      description: |
        Der **Binärsensor**, der den aktuellen Status der Markise anzeigt.
        (`on` = Markise ausgefahren, `off` = Markise eingefahren)
      selector:
        entity:
          domain: binary_sensor
          multiple: false
          filter:
            - device_class:
                - window
                - opening
    wind_max_threshold:
      name: Maximale Windschwelle (km/h)
      description: |
        Der numerische Wert in km/h, ab dem die Markise automatisch eingefahren wird.
        (Standard: 27 km/h)
      default: 27
      selector:
        number:
          min: 0
          max: 100
          unit_of_measurement: km/h
          mode: box
    wind_min_threshold:
      name: Minimale Windschwelle (km/h)
      description: |
        Der numerische Wert in km/h, unter den die Windgeschwindigkeit fallen muss, damit die Markise wieder automatisch ausgefahren wird.
        (Standard: 20 km/h)
      default: 20
      selector:
        number:
          min: 0
          max: 100
          unit_of_measurement: km/h
          mode: box
    automatic_extend_timeout_minutes:
      name: Zeitspanne für automatisches Ausfahren (Minuten)
      description: |
        Die Zeit in Minuten, die vergehen muss, nachdem Wind und Regen unter den Grenzwert gefallen sind, bevor die Markise wieder ausfährt.
        (Standard: 30 Minuten)
      default: 30
      selector:
        number:
          min: 1
          max: 120
          unit_of_measurement: min
          mode: box
    rain_threshold:
      name: Regenschwelle (mm)
      description: |
        Der numerische Wert in mm/m² (aus der **Regensensor-Entität**), ab dem die Markise eingefahren wird.
        (Standard: 0.7 mm/m²)
      default: 0.7
      selector:
        number:
          step: 0.1
          min: 0
          max: 10
          unit_of_measurement: mm/m²
          mode: box
    wind_sensor_timeout_minutes:
      name: Windsensor-Timeout (Minuten)
      description: |
        Die Zeitspanne in Minuten, nach der ein fehlender Windsensor die Markise automatisch einfährt.
        (Standard: 15 Minuten)
      default: 15
      selector:
        number:
          min: 1
          max: 60
          unit_of_measurement: min
          mode: box
    sensors_timeout_minutes:
      name: Sensoren-Timeout (Minuten)
      description: |
        Die Zeitspanne in Minuten, nach der fehlende Sensoren eine Warnung auslösen und versucht wird, die Markise automatisch einzufahren.
        (Standard: 15 Minuten)
      default: 15
      selector:
        number:
          min: 1
          max: 60
          unit_of_measurement: min
          mode: box
    automatic_retract_count_threshold:
      name: Zählergrenzwert für automatisches Einfahren
      description: |
        Der numerische Wert, wie oft die Markise automatisch eingefahren werden darf, bevor eine Benachrichtigung gesendet wird.
        (Standard: 2 mal)
      default: 2
      selector:
        number:
          min: 1
          max: 10
          mode: box
    automatic_retracted_helper:
      name: Helfer für "automatisch eingefahren"
      description: |
        Ein `input_boolean`-Helfer, der den Status anzeigt, wenn die Markise automatisch eingefahren wurde.
      selector:
        entity:
          domain: input_boolean
    automatic_extended_helper:
      name: Helfer für "automatisch ausgefahren"
      description: |
        Ein `input_boolean`-Helfer, der den Status anzeigt, wenn die Markise automatisch ausgefahren wurde.
      selector:
        entity:
          domain: input_boolean
    retract_counter_helper:
      name: Helfer für Einfahrzähler
      description: |
        Ein `counter`-Helfer, der die Anzahl der automatischen Einfahrvorgänge zählt.
      selector:
        entity:
          domain: counter
    reset_time:
      name: Tägliche Reset-Uhrzeit
      description: |
        Die Uhrzeit, zu der der Zähler und die Status-Helfer täglich zurückgesetzt werden sollen.
        (Standard: 00:00:00)
      default: "00:00:00"
      selector:
        time:

trigger:
  # Auslöser: Windgeschwindigkeit über maximalem Schwellenwert
  - platform: numeric_state
    id: trigger_windsensor_max_threshold
    entity_id: !input wind_sensor
    above: !input wind_max_threshold
  # Auslöser: Regenmenge über Schwellenwert
  - platform: numeric_state
    id: trigger_rain_statistic_sensor
    entity_id: !input rain_sensor
    above: !input rain_threshold
  # Auslöser: Markise wird manuell ausgefahren
  - platform: state
    id: trigger_marquise_opened
    entity_id: !input marquise_status_sensor
    from: "off"
    to: "on"
  # Auslöser: Markise wird manuell eingefahren
  - platform: state
    id: trigger_marquise_closed
    entity_id: !input marquise_status_sensor
    from: "on"
    to: "off"
  # Auslöser: Windgeschwindigkeit unter minimalem Schwellenwert für eine bestimmte Zeit
  - platform: numeric_state
    id: trigger_windsensor_min_threshold
    entity_id: !input wind_sensor
    below: !input wind_min_threshold
    for:
      minutes: !input automatic_extend_timeout_minutes
  # Auslöser: Windsensor ist nicht verfügbar oder unbekannt für eine bestimmte Zeit
  - platform: state
    id: trigger_windsensor_unknown
    entity_id: !input wind_sensor
    to:
      - unavailable
      - unknown
    for:
      minutes: !input wind_sensor_timeout_minutes
  # Auslöser: Mehrere Sensoren (Wind, Status, Steuerung) sind nicht verfügbar oder unbekannt
  - platform: state
    id: trigger_sensors_unknown
    entity_id:
      - !input wind_sensor
      - !input marquise_status_sensor
      - !input marquise_retract_switch
      - !input marquise_extend_switch
    to:
      - unavailable
      - unknown
    for:
      minutes: !input sensors_timeout_minutes
  # Auslöser: Der Einfahr-Zähler überschreitet den konfigurierten Grenzwert
  - platform: numeric_state
    id: trigger_retract_counter
    entity_id: !input retract_counter_helper
    above: !input automatic_retract_count_threshold
  # Auslöser: Tägliches Reset um Mitternacht
  - platform: time
    id: trigger_reset_time
    at: !input reset_time

condition: []

action:
  - variables:
      wind_speed: !input wind_sensor
      rain_amount: !input rain_sensor
      retract_count: !input retract_counter_helper
      retract_entity: !input marquise_retract_switch
      extend_entity: !input marquise_extend_switch
      retract_service: >
        {% if retract_entity.startswith('button.') %} button.press
        {% elif retract_entity.startswith('cover.') %} cover.close_cover
        {% else %} homeassistant.turn_on {% endif %}
      extend_service: >
        {% if extend_entity.startswith('button.') %} button.press
        {% elif extend_entity.startswith('cover.') %} cover.open_cover
        {% else %} homeassistant.turn_on {% endif %}
  - choose:
      # Aktion: Starkwind erkannt
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_max_threshold
        sequence:
          # Wenn Markise bereits geschlossen ist, tue nichts
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
            alias: Wenn Markise geschlossen -> tue nichts
          # Wenn Markise geöffnet ist, fahre sie ein
          - alias: Wenn Markise geöffnet -> Einfahren
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: "{{ retract_service }}"
                target:
                  entity_id: "{{ retract_entity }}"
              - service: counter.increment
                target:
                  entity_id: !input retract_counter_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Starkwind
                service: notify.notify
                data:
                  title: "Starkwind erkannt"
                  message: "Markise wurde wegen Starkwind ({{ states(wind_speed) }} km/h) automatisch eingefahren."
          # Wenn Markisenstatus unbekannt ist, fahre sie sicherheitshalber ein
          - alias: Wenn Markisenstatus unbekannt -> Einfahren
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unknown
                  - unavailable
            then:
              - service: "{{ retract_service }}"
                target:
                  entity_id: "{{ retract_entity }}"
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Starkwind (Status unbekannt)
                service: notify.notify
                data:
                  title: "Starkwind - Markisenstatus unbekannt"
                  message: "Markise wurde wegen Starkwind ({{ states(wind_speed) }} km/h) automatisch eingefahren. ACHTUNG: Markisenstatus unbekannt!"
        alias: Starkwind
      # Aktion: Windsensor-Timeout
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_unknown
        sequence:
          # Wenn Markise geschlossen ist, tue nichts
          - alias: Markise geschlossen -> tue nichts
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
          # Wenn Markisenstatus unbekannt, schließe Markise sicherheitshalber
          - alias: Markisenstatus unbekannt -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unavailable
                  - unknown
            then:
              - service: "{{ retract_service }}"
                target:
                  entity_id: "{{ retract_entity }}"
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Windsensor-Timeout
                service: notify.notify
                data:
                  title: "Windsensor-Timeout"
                  message: "Markise wird eingefahren, da der Windsensor nicht erreichbar ist."
          # Wenn Markise geöffnet ist, schließe Markise
          - alias: Markise geöffnet -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: "{{ retract_service }}"
                target:
                  entity_id: "{{ retract_entity }}"
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Windsensor-Timeout
                service: notify.notify
                data:
                  title: "Windsensor-Timeout"
                  message: "Markise wird eingefahren, da der Windsensor nicht erreichbar ist."
        alias: Windsensor-Timeout
      # Aktion: Regen erkannt
      - conditions:
          - condition: trigger
            id:
              - trigger_rain_statistic_sensor
        sequence:
          # Wenn Markise geschlossen ist, tue nichts
          - alias: Markise geschlossen -> tue nichts
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "off"
            then: []
          # Wenn Markisenstatus unbekannt, schließe Markise sicherheitshalber
          - alias: Markisenstatus unbekannt -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - unavailable
                  - unknown
            then:
              - service: "{{ retract_service }}"
                target:
                  entity_id: "{{ retract_entity }}"
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Regen (Status unbekannt)
                service: notify.notify
                data:
                  title: "Regen erkannt - Markisenstatus unbekannt"
                  message: "Markise wird wegen Regen ({{ states(rain_amount) }} mm) eingefahren. Status unbekannt!"
          # Wenn Markise geöffnet ist, schließe Markise
          - alias: Markise geöffnet -> schließe Markise
            if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: "{{ retract_service }}"
                target:
                  entity_id: "{{ retract_entity }}"
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Regen erkannt
                service: notify.notify
                data:
                  title: "Regen erkannt"
                  message: "Markise wird wegen Regen ({{ states(rain_amount) }} mm) eingefahren."
        alias: Regen
      # Aktion: Manuelles Ausfahren
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_opened
              - condition: state
                entity_id: !input automatic_extended_helper
                state: "off"
        sequence:
          - if:
              - condition: numeric_state
                entity_id: !input wind_sensor
                above: !input wind_max_threshold
            then:
              - alias: Benachrichtigung manuell Ausgefahren trotz Starkwind
                service: notify.notify
                data:
                  title: "Markisenwächter - WARNUNG"
                  message: "Die Markise wurde trotz Starkwind manuell ausgefahren. Das automatische Einfahren ist bis zum UNTERschreiten des Schwellenwertes INAKTIV!"
          - if:
              - condition: numeric_state
                entity_id: !input retract_counter_helper
                above: 0
            then:
              - service: counter.reset
                target:
                  entity_id: !input retract_counter_helper
              - alias: Benachrichtigung Manuell Ausgefahren
                service: notify.notify
                data:
                  title: "Markise manuell ausgefahren"
                  message: "Der Markisen-Zähler wurde durch manuelles Ausfahren zurückgesetzt."
        alias: Markise manuell ausgefahren
      # Markise wurde automatisch ausgefahren - verhindert Fallback auf den Default-Block
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_opened
              - condition: state
                entity_id: !input automatic_extended_helper
                state: "on"
        sequence: [] # Tue nichts, da die Aktion bereits durch einen anderen Block ausgelöst wurde
        alias: Automatisch ausgefahren - tue nichts
      # Aktion: Manuelles Einfahren
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_closed
              - condition: state
                entity_id: !input automatic_retracted_helper
                state: "off"
        sequence:
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_extended_helper
        alias: Markise manuell eingefahren
      # Markise wurde automatisch eingefahren - verhindert Fallback auf den Default-Block
      - conditions:
          - condition: and
            conditions:
              - condition: trigger
                id:
                  - trigger_marquise_closed
              - condition: state
                entity_id: !input automatic_retracted_helper
                state: "on"
        sequence: [] # Tue nichts, da die Aktion bereits durch einen anderen Block ausgelöst wurde
        alias: Automatisch eingefahren - tue nichts
      # Aktion: Zählerschutz-Benachrichtigung
      - conditions:
          - condition: trigger
            id:
              - trigger_retract_counter
        sequence:
          - alias: Benachrichtigung Zählerschutz
            service: notify.notify
            data:
              title: "Markisen-Zählerschutz aktiv"
              message: "Markise wurde in kurzer Zeit {{ states(retract_count) }} Mal automatisch eingefahren. Automatisches Ausfahren ist gesperrt."
        alias: Benachrichtigung Ausfahrsperre aktiv
      # Aktion: Tägliches Reset
      - conditions:
          - condition: trigger
            id:
              - trigger_reset_time
        sequence:
          - service: counter.reset
            target:
              entity_id: !input retract_counter_helper
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_extended_helper
          - service: input_boolean.turn_off
            target:
              entity_id: !input automatic_retracted_helper
        alias: Zeitlicher Reset der Automation
      # Aktion: Sensor-Fehlerwarnung
      - conditions:
          - condition: trigger
            id:
              - trigger_sensors_unknown
        sequence:
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state: "on"
            then:
              - service: "{{ retract_service }}"
                target:
                  entity_id: "{{ retract_entity }}"
              - service: counter.increment
                target:
                  entity_id: !input retract_counter_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_extended_helper
              - alias: Benachrichtigung Sensor-Fehler (Einfahren)
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Markise wurde eingefahren, da kritische Sensoren nicht erreichbar sind."
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - "off"
            then:
              - alias: Benachrichtigung Sensor-Fehler
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Achtung! Einer oder mehrere kritische Sensoren des Markisenwächters sind nicht verfügbar!"
          - if:
              - condition: state
                entity_id: !input marquise_status_sensor
                state:
                  - "unavailable"
                  - "unknown"
            then:
              - service: "{{ retract_service }}"
                target:
                  entity_id: "{{ retract_entity }}"
              - alias: Benachrichtigung Sensor-Fehler (Status unbekannt)
                service: notify.notify
                data:
                  title: "Markisenwächter - Sensor-Fehler"
                  message: "Achtung! Einer oder mehrere kritische Sensoren des Markisenwächters sind nicht verfügbar! Markise wird sicherheitshalber eingefahren."
        alias: "Warnung: Sensor(en) nicht verfügbar"
      # Aktion: Wind lässt nach, Markise wieder ausfahren
      - conditions:
          - condition: trigger
            id:
              - trigger_windsensor_min_threshold
        sequence:
          - if:
              - condition: and
                conditions:
                  - condition: state
                    entity_id: !input automatic_retracted_helper
                    state: "on"
                  - condition: numeric_state
                    entity_id: !input rain_sensor
                    below: !input rain_threshold
            then:
              - service: input_boolean.turn_off
                target:
                  entity_id: !input automatic_retracted_helper
              - service: input_boolean.turn_on
                target:
                  entity_id: !input automatic_extended_helper
              - service: "{{ extend_service }}"
                target:
                  entity_id: "{{ extend_entity }}"
              - alias: Benachrichtigung Wind lässt nach
                service: notify.notify
                data:
                  title: "Wind lässt nach"
                  message: "Windstärke ({{ states(wind_speed) }} km/h) und Regen ({{ states(rain_amount) }} mm) sind unter den Schwellenwert gefallen. Markise wird wieder ausgefahren."
        alias: Wind lässt nach
    # Standardaktion, wenn kein Trigger zutrifft
    default:
      - alias: Benachrichtigung unbekannter Fehler
        service: notify.notify
        data:
          title: "Markisenwächter - Fehler"
          message: "Ein Fehler oder eine unbekannte Situation ist aufgetreten. Bitte überprüfe das Log und die Sensoren/Steuerungen."

mode: single
1 „Gefällt mir“

Hallo, ersteinmal herzlichen Dank für Deine Arbeit. Ich scheitere schon ein bisschen bei der Einrichtung. Meine Markisen werden über den SONOFF Rolladen Aktor angebunden. Damit habe ich keinen Schalter für das einfachen bzw. ausfahren. Sondern nur eine Cover Entität. Wird dies von Deinem Blueprint nicht unterstützt?

Gruß

Stefan