Rollladensteuerung Home Assistant: Smarte Automatisierungen

Werbung / Affiliate-Links: Mit * markierte Links sind Affiliate-Links. Beim Kauf über diese Links erhalten wir eine kleine Provision — für dich ändert sich am Preis nichts. Als Amazon-Partner verdienen wir an qualifizierten Verkäufen.

Rollladensteuerung mit Home Assistant: Was wirklich möglich ist

Wer sich mit Rollladensteuerung Home Assistant beschäftigt, merkt schnell: Dahinter steckt weit mehr als ein simples Timer-Programm. Ein Rollladen, der einfach morgens hoch und abends runter fährt — das ist die Einstiegsdosis. Richtig aufgesetzt reagiert die Rollladensteuerung auf den Sonnenstand, bevor sich die Wohnung aufheizt. Sie weiß, wann du aufwachst. Sie macht beim Öffnen des Fensters kurz Platz und erinnert sich danach an ihre alte Position. Sie fährt im Sturm automatisch ein, bevor du überhaupt davon weißt.

Der entscheidende Unterschied zu einfachen Timer-Steuerungen: Die intelligente Rollladensteuerung Home Assistant kombiniert mehrere Signalquellen zu kontextbewussten Entscheidungen. Die Anlage weiß, wo die Sonne gerade steht, wie hell es im Raum ist, wie warm es draußen ist, ob Sturm kommt — und wie alle diese Faktoren gerade zusammenspielen. Das Ergebnis ist eine Rollladensteuerung, die sich anfühlt als ob jemand mitdenkt, nicht als ob ein Zeitschalter läuft.

Dieser Artikel setzt voraus, dass dein Shelly bereits in Home Assistant eingebunden ist — ob über die native Shelly-Integration oder MQTT spielt für die Automatisierungen keine Rolle. Wer den Einstieg noch vor sich hat, findet alles Nötige im Artikel über Home Assistant Automationen für Anfänger.

Was du brauchst

Für die Automatisierungen brauchst du je nach Umfang folgende Komponenten:

• Cover-Entity deines Rollladenmotors (z. B. Shelly 2PM Gen3^* im Rollladen-Modus; die Vorgänger Shelly 2.5 und Plus 2PM sind abgekündigt)
• Lux-Sensor (z.B. ein Zigbee-Helligkeitssensor wie der Aqara Lichtsensor T1, Messbereich laut Hersteller bis 83.000 lx) für lichtbasierte Steuerung
• Fensterkontakt (z.B. Aqara Tür-/Fenstersensor^*) für die Fenster-Automation
• Wetter-Integration (OpenWeatherMap oder Met.no) für Temperatur, Bewölkung und Windgeschwindigkeit
• HA Companion App auf dem Smartphone für den Wecker-Trigger
• Einige Helper (input_boolean, input_number, input_datetime) — werden weiter unten angelegt

Die Automationen selbst laufen lokal in Home Assistant. Ausnahme sind die Wetterdaten: OpenWeatherMap und Met.no holen ihre Werte aus dem Internet, OpenWeatherMap braucht zudem ein kostenloses Konto mit API-Schlüssel. Fällt die Verbindung aus, fehlen Temperatur-, Bewölkungs- und Windwerte — wer das vermeiden will, nutzt eine lokale Wetterstation. Der Wecker-Trigger funktioniert auf Android direkt, iOS braucht einen kleinen Umweg.

Sicherheit: Das Shelly-Modul sitzt in der Unterputzdose und wird am 230-V-Netz angeschlossen. Einbau und Anschluss darf nur eine Elektrofachkraft übernehmen — auch den Tausch eines vorhandenen Rollladenschalters.

Ein kurzer Hinweis zur Motorkompatibilität: Nicht jeder Rollladenmotor verträgt es, über ein Shelly-Modul gesteuert zu werden. Die Elektrofachkraft prüft vor dem Einbau die Stromaufnahme des Motors (der Shelly 2PM Gen3 schaltet laut Hersteller bis 10 A je Kanal) und ob er einen mechanischen oder elektronischen Endschalter hat. Bei neueren Motoren gibt es meistens keine Probleme — bei älteren, stromhungrigen Motoren lieber vorher nachmessen lassen.

Rollladensteuerung mit Home Assistant: Die intelligente Sonnenschutz-Automation

Die meisten einfachen Sonnenschutz-Automationen haben ein Problem: Sie reagieren auf einzelne Bedingungen. Fenster auf der Südseite wird dunkel, weil es gerade bewölkt ist — aber der Zeitplan sagt „Sonnenschutz aktiv”. Oder es ist kalt genug, dass Sonnenwärme willkommen wäre, die Automation schließt trotzdem. Das frustriert, und nach ein paar Wochen schaltet man die Automatik einfach ab.

Eine wirklich nützliche Rollladensteuerung mit Home Assistant kombiniert vier Faktoren gleichzeitig:

1. Sonnenstand (Elevation + Azimut) — ist die Sonne überhaupt auf das Fenster gerichtet?
2. Lichtintensität (Lux-Sensor) — scheint tatsächlich Sonne ins Fenster, oder ist es bewölkt?
3. Außentemperatur — ist Hitzeschutz überhaupt nötig?
4. Wetterzustand — bewölkt oder Regen? Dann kein Abdunkeln.

Nur wenn alle vier Bedingungen gleichzeitig erfüllt sind, fahren die Rollläden herunter. Das eliminiert die meisten Fehlanläufe und macht die Automation alltagstauglich.

Für den Azimut-Bereich gilt: Ein Südfenster ist bei etwa 150–240° relevant, ein Westfenster bei 220–300°. Die elevation von 25° entspricht dem Winkel, bei dem die Sonne flach genug einfällt um direkt ins Fenster zu strahlen — je nach Gebäudehöhe und Dachüberstand variiert dieser Wert. Am besten einmal im Sommer beobachten, ab wann es im Raum wirklich unangenehm warm wird.

alias: 'Sonnenschutz Wohnzimmer'
triggers:
  - trigger: numeric_state
    entity_id: sensor.lux_wohnzimmer
    above: 30000
conditions:
  - condition: numeric_state
    entity_id: sun.sun
    attribute: elevation
    above: 25
  - condition: template
    value_template: >
      {{ state_attr('sun.sun', 'azimuth') | float >= 150 and
         state_attr('sun.sun', 'azimuth') | float <= 240 }}
  - condition: numeric_state
    entity_id: sensor.aussentemperatur
    above: 22
  - condition: not
    conditions:
      - condition: state
        entity_id: weather.home
        state: 'cloudy'
      - condition: state
        entity_id: weather.home
        state: 'rainy'
  - condition: state
    entity_id: input_boolean.rollladen_override
    state: 'off'
actions:
  - action: cover.set_cover_position
    target:
      entity_id: cover.wohnzimmer_rollladen
    data:
      position: 10
mode: single

Rückstellung, wenn die Sonne das Fenster verlässt (Azimut über 240°) oder die Helligkeit dauerhaft unter den Schwellwert fällt. Ein Sonnenuntergangs-Trigger wäre hier falsch — er würde die Rollläden ausgerechnet zum Abend wieder ganz öffnen:

alias: 'Sonnenschutz Wohnzimmer zurückstellen'
triggers:
  - trigger: numeric_state
    entity_id: sensor.lux_wohnzimmer
    below: 15000
    for:
      minutes: 10
  - trigger: numeric_state
    entity_id: sun.sun
    attribute: azimuth
    above: 240
conditions:
  - condition: state
    entity_id: input_boolean.rollladen_override
    state: 'off'
actions:
  - action: cover.set_cover_position
    target:
      entity_id: cover.wohnzimmer_rollladen
    data:
      position: 100
mode: single

Der for: minutes: 10 Puffer beim Lux-Trigger ist wichtig: Kurze Wolkendurchzüge sollen nicht ständig zum Öffnen und Schließen führen. Erst wenn die Helligkeit zehn Minuten konstant unter dem Schwellwert bleibt, reagiert die Automation.

Manueller Override für die Rollladensteuerung Home Assistant

Kein System der Welt reagiert auf jeden Edge Case richtig. Der manuelle Override ist kein Fallback — er ist ein First-Class-Feature, das in jede ernstzunehmende Rollladensteuerung mit Home Assistant gehört.

Helper anlegen (Einstellungen → Geräte & Dienste → Helper):

input_boolean:
  rollladen_override:
    name: "Rollladen Override"
    icon: mdi:hand-back-right

input_datetime:
  rollladen_override_gesetzt_um:
    name: "Override gesetzt um"
    has_date: false
    has_time: true

In jeder Automatisierung kommt diese Condition rein — sie verhindert, dass die Automatik den manuell gesetzten Zustand überschreibt:

conditions:
  - condition: state
    entity_id: input_boolean.rollladen_override
    state: 'off'

Auto-Reset nach 4 Stunden, damit der Override nicht dauerhaft aktiv bleibt wenn man es vergisst:

alias: 'Override Auto-Reset nach 4 Stunden'
triggers:
  - trigger: state
    entity_id: input_boolean.rollladen_override
    to: 'on'
actions:
  - action: input_datetime.set_datetime
    target:
      entity_id: input_datetime.rollladen_override_gesetzt_um
    data:
      time: "{{ now().strftime('%H:%M:%S') }}"
  - delay: "04:00:00"
  - condition: state
    entity_id: input_boolean.rollladen_override
    state: 'on'
  - action: input_boolean.turn_off
    target:
      entity_id: input_boolean.rollladen_override
mode: restart

Die Condition direkt vor dem turn_off prüft, ob der Override noch aktiv ist. Hat ihn jemand in der Zwischenzeit schon manuell ausgeschaltet, endet die Automation dort ohne weitere Aktion. mode: restart sorgt dafür, dass die vier Stunden neu beginnen, wenn der Override zwischendurch aus- und wieder eingeschaltet wird — mit mode: single würde der alte Durchlauf weiterlaufen und den neuen Override zu früh zurücksetzen.

Fenster-Automation mit Position-Memory

Das ist eine der nützlichsten Automatisierungen für die tägliche Rollladensteuerung mit Home Assistant — und eine, die kaum jemand kennt. Das Szenario: Der Rollladen steht auf 15%, schön dunkel und kühl. Du öffnest das Fenster zum Lüften. Normalerweise müsstest du den Rollladen manuell hochschieben, nach dem Lüften wieder runter, und die Sonnenschutz-Position manuell neu einstellen.

Mit Position-Memory erledigt Home Assistant das: Rollladen auf Lüftungsposition, alte Position merken, nach dem Schließen zurückstellen — aber nur wenn du das Fenster schnell wieder schließt. Lässt du es länger offen, hat die Automation keinen Anlass zur Rückstellung, weil du offensichtlich bewusst lüften willst.

Helper anlegen:

input_number:
  rollladen_position_vor_fenster:
    name: "Rollladen Position vor Fensteröffnung"
    min: 0
    max: 100
    step: 1
    icon: mdi:content-save

Automation 1 — Fenster wird geöffnet:

Die Condition prüft, ob der Rollladen weiter als 40% geschlossen ist. Steht er bereits offen, ist kein Eingriff nötig.

alias: 'Rollladen auf Lüftungsposition wenn Fenster auf'
triggers:
  - trigger: state
    entity_id: binary_sensor.fensterkontakt_wohnzimmer
    to: 'on'
conditions:
  - condition: template
    value_template: >
      {{ state_attr('cover.wohnzimmer_rollladen', 'current_position') | int < 60 }}
actions:
  - action: input_number.set_value
    target:
      entity_id: input_number.rollladen_position_vor_fenster
    data:
      value: "{{ state_attr('cover.wohnzimmer_rollladen', 'current_position') | int }}"
  - action: cover.set_cover_position
    target:
      entity_id: cover.wohnzimmer_rollladen
    data:
      position: 60
mode: single

Automation 2 — Fenster wird innerhalb von 30 Minuten wieder geschlossen:

alias: 'Rollladen zurückstellen nach Fenster zu'
triggers:
  - trigger: state
    entity_id: binary_sensor.fensterkontakt_wohnzimmer
    to: 'off'
conditions:
  - condition: template
    value_template: >
      {{ (now() - trigger.from_state.last_changed).total_seconds() < 1800 }}
  - condition: template
    value_template: >
      {{ states('input_number.rollladen_position_vor_fenster') | int > 0 }}
actions:
  - action: cover.set_cover_position
    target:
      entity_id: cover.wohnzimmer_rollladen
    data:
      position: "{{ states('input_number.rollladen_position_vor_fenster') | int }}"
  - action: input_number.set_value
    target:
      entity_id: input_number.rollladen_position_vor_fenster
    data:
      value: 0
mode: single

Die erste Condition nutzt trigger.from_state.last_changed — also den Zeitpunkt, zu dem das Fenster geöffnet wurde. Der aktuelle last_changed-Wert des Sensors hilft hier nicht, weil er beim Schließen gerade erst neu gesetzt wurde. Die zweite Condition (input_number > 0) sorgt dafür, dass die Rückstell-Automation nur greift wenn tatsächlich ein gespeicherter Wert existiert — also wenn die Öffnungs-Automation vorher gelaufen ist. Das verhindert ungewollte Eingriffe wenn der Rollladen beim Öffnen des Fensters bereits auf 100% stand.

Wecker-Trigger: Rollläden als sanfter Aufwachhelfer

Der schönste Aufwachmechanismus, den Home Assistant bieten kann: Rollläden öffnen sich schrittweise bevor der Wecker klingelt — nicht danach. Statt Klingeln und Dunkelheit gibt es eine Art künstlichen Sonnenaufgang, besonders wertvoll im Winter wenn es draußen noch Stunden bis zum echten Sonnenaufgang dauert.

Android: next_alarm Sensor

Die HA Companion App für Android überträgt automatisch den nächsten gesetzten Wecker als Sensor sensor.GERÄTENAME_next_alarm. Das funktioniert mit der eingebauten Uhr-App und den meisten Drittanbieter-Apps. Der Sensor liefert den Zeitstempel in Millisekunden als Attribut.

Damit der Sensor zuverlässig nur auf den Wecker-Klingelalarm reagiert und nicht auf Kalenderbenachrichtigungen, solltest du in der Companion App unter „Manage Sensors → Next Alarm” eine Allowlist mit deiner Wecker-App eintragen.

alias: 'Rollladen öffnen vor Wecker (Android)'
triggers:
  - trigger: template
    value_template: >
      {{ now().strftime('%a %h %d %H:%M %Z %Y') ==
         (((state_attr('sensor.pixel_next_alarm', 'Time in Milliseconds') | int / 1000 | int - 600))
         | timestamp_custom('%a %h %d %H:%M %Z %Y')) }}
actions:
  - action: cover.set_cover_position
    target:
      entity_id: cover.schlafzimmer_rollladen
    data:
      position: 25
  - delay: "00:10:00"
  - action: cover.open_cover
    target:
      entity_id: cover.schlafzimmer_rollladen
mode: single

Den Entity-Namen sensor.pixel_next_alarm ersetzt du durch deinen tatsächlichen Sensor — zu finden unter Einstellungen → Geräte → dein Telefon → Sensoren → „Nächster Alarm”. Der Offset von 600 Sekunden (10 Minuten) sorgt dafür, dass der Rollladen zuerst auf 25% geht, 10 Minuten vor dem Klingeln. Wenn der Wecker dann wirklich klingelt, ist der Raum bereits aufgehellt.

iPhone: HA-Wecker als Single Source of Truth

iOS stellt keinen Alarm-Sensor für externe Apps bereit. Der praktischste Weg ohne Umwege über Shortcuts: Den HA-eigenen input_datetime-Helper als Wecker nutzen. Du stellst den Wecker direkt in Home Assistant, dein iPhone klingelt über die Companion App, und die Rollladen-Automation reagiert auf denselben Trigger.

input_datetime:
  wecker_morgen:
    name: "Wecker Morgen"
    has_date: false
    has_time: true

alias: 'Rollladen öffnen vor Wecker (iPhone / HA-Wecker)'
triggers:
  - trigger: template
    value_template: >
      {{ now().strftime('%H:%M') ==
         (as_datetime(today_at(states('input_datetime.wecker_morgen'))) -
          timedelta(minutes=10)).strftime('%H:%M') }}
actions:
  - action: cover.set_cover_position
    target:
      entity_id: cover.schlafzimmer_rollladen
    data:
      position: 25
  - delay: "00:10:00"
  - action: cover.open_cover
    target:
      entity_id: cover.schlafzimmer_rollladen
mode: single

Du kannst den input_datetime-Wecker über einen Sprachbefehl setzen wenn du HA Assist eingerichtet hast, oder direkt über ein Dashboard-Element.

Einbruchschutz, Sturmschutz und Nachtlüftung

Rollläden als passive Sicherheitsfunktion

Wenn niemand zuhause ist, sollen Rollläden nicht auf 100% geschlossen sein — das signalisiert eindeutig „leer”. Die smarte Lösung: 20% Öffnung. Von außen sieht es bewohnt aus, Einblick ist trotzdem kaum möglich.

alias: 'Rollläden Abwesenheitsmodus'
triggers:
  - trigger: state
    entity_id: person.philipp
    to: 'not_home'
    for:
      minutes: 15
actions:
  - action: cover.set_cover_position
    target:
      entity_id:
        - cover.wohnzimmer_rollladen
        - cover.schlafzimmer_rollladen
        - cover.kueche_rollladen
    data:
      position: 20
mode: single

alias: 'Rollläden bei Heimkehr öffnen'
triggers:
  - trigger: state
    entity_id: person.philipp
    to: 'home'
actions:
  - action: cover.open_cover
    target:
      entity_id:
        - cover.wohnzimmer_rollladen
        - cover.schlafzimmer_rollladen
        - cover.kueche_rollladen
mode: single

Sturmschutz mit Benachrichtigung

Rollläden in voll ausgefahrenem Zustand können bei starkem Wind beschädigt werden. Mit einer Wetter-Integration, die Windgeschwindigkeit liefert, fährst du sie automatisch ein — also nach oben (cover.open_cover). Prüfe die Windgrenze in der Anleitung deines Rollladens; bei Außenjalousien und Markisen gilt das Gleiche:

alias: 'Sturmschutz — alle Rollläden einfahren'
triggers:
  - trigger: numeric_state
    entity_id: sensor.wind_speed
    above: 50
conditions: []
actions:
  - action: cover.open_cover
    target:
      entity_id:
        - cover.wohnzimmer_rollladen
        - cover.schlafzimmer_rollladen
        - cover.kueche_rollladen
  - action: notify.mobile_app_pixel
    data:
      title: "⚠️ Sturmschutz aktiv"
      message: "Windgeschwindigkeit über 50 km/h — alle Rollläden eingefahren."
mode: single

Wie du Benachrichtigungen über verschiedene Kanäle einrichtest, zeigt der Artikel über Home Assistant Benachrichtigungen mit Telegram und Pushover.

Hitzeschutz durch Nachtlüftung

Im Hochsommer kühlt es nachts deutlich ab. 45 Minuten vor Sonnenaufgang den Rollladen auf 15% öffnen lässt kühlere Luft rein — bevor die Sonne wieder zu heizen beginnt. Die Automation schließt automatisch nach 30 Minuten, bevor der erste direkte Sonneneinfall kommt.

alias: 'Nachtlüftung vor Sonnenaufgang (Sommermonate)'
triggers:
  - trigger: sun
    event: sunrise
    offset: "-00:45:00"
conditions:
  - condition: numeric_state
    entity_id: sensor.aussentemperatur
    below: 20
  - condition: template
    value_template: "{{ now().month in [5, 6, 7, 8, 9] }}"
actions:
  - action: cover.set_cover_position
    target:
      entity_id: cover.schlafzimmer_rollladen
    data:
      position: 15
  - delay: "00:30:00"
  - action: cover.close_cover
    target:
      entity_id: cover.schlafzimmer_rollladen
mode: single

Die Außentemperatur-Condition stellt sicher, dass die Automation nur läuft wenn draußen wirklich kühle Luft wartet. Ist es nachts wärmer als 20°C, bringt das Lüften in dieser Konfiguration nichts.

Fazit: Rollladensteuerung Home Assistant kann mehr als du denkst

Die hier gezeigten Automatisierungen sind keine Spielereien — sie lösen echte Alltagsprobleme. Die Sonnenschutz-Automation hält die Wohnung kühl ohne sie bei Bewölkung zu verdunkeln. Das Position-Memory macht Lüften unkompliziert, ohne den Sonnenschutz zu zerstören. Der Wecker-Trigger macht morgendliches Licht zur selbstverständlichen Routine. Und Sturmschutz plus Abwesenheitsmodus laufen still im Hintergrund.

Das Schöne an der Rollladensteuerung mit Home Assistant: Die Automatisierungen greifen ineinander. Der Override stoppt alles. Sturmschutz überschreibt Sonnenschutz. Fensterkontakt hat Vorrang vor Position-Memory. Mit klaren Prioritäten und dem Override als Sicherheitsnetz passiert selten etwas wirklich Unerwartetes — und wenn, lässt es sich mit einem Klick korrigieren.

Wer komplexere Logiken mit mehreren Häusern oder Stockwerken aufbauen will, findet in Node-RED vs. Home Assistant Automationen einen guten Überblick über alternative Ansätze. Und wer neben den Rollläden auch die Heizung intelligent steuern will, findet einen vollständigen Einstieg bei der smarten Heizungssteuerung mit Home Assistant.

Autor

Philipp

Themen

Home Assistant, ESP32, Zigbee

Schreibt über Home Assistant, ESP32 und alles, was das Smart Home smarter macht.

Dieser Artikel wurde mit KI-Unterstützung erstellt; Angaben werden gegen offizielle Dokumentation und Herstellerangaben geprüft. Wie die Artikel entstehen