Affiliate-Hinweis: Einige Links in diesem Artikel sind Affiliate-Links. Beim Kauf über diese Links erhalten wir eine kleine Provision — für dich ändert sich am Preis nichts.

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 (Shelly 2.5 oder Shelly Plus 2PM)
• Lux-Sensor (z.B. Aqara Helligkeitssensor) 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

Alle Automationen laufen vollständig lokal. Kein Cloud-Dienst, kein externer Server, kein Konto erforderlich. Das gilt auch für den Wecker-Trigger — zumindest auf Android, iOS braucht einen kleinen Umweg.

Ein kurzer Hinweis zur Motorkompatibilität: Nicht jeder Rollladenmotor verträgt es, über ein Shelly-Modul gesteuert zu werden. Prüfe vor dem Einbau die maximale Stromaufnahme des Motors und ob er einen mechanischen oder elektronischen Endschalter hat. Bei neueren Motoren mit Soft-Start gibt es meistens keine Probleme — bei älteren, stromhungrigen Motoren lieber vorher nachmessen.

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'
trigger:
  - platform: numeric_state
    entity_id: sensor.lux_wohnzimmer
    above: 30000
condition:
  - 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'
action:
  - service: cover.set_cover_position
    target:
      entity_id: cover.wohnzimmer_rolladen
    data:
      position: 10
mode: single

Rückstellung wenn die Sonne nicht mehr direkt einfällt oder die Helligkeit dauerhaft unter den Schwellwert fällt:

alias: 'Sonnenschutz Wohnzimmer zurückstellen'
trigger:
  - platform: numeric_state
    entity_id: sensor.lux_wohnzimmer
    below: 15000
    for:
      minutes: 10
  - platform: sun
    event: sunset
condition:
  - condition: state
    entity_id: input_boolean.rollladen_override
    state: 'off'
action:
  - service: cover.set_cover_position
    target:
      entity_id: cover.wohnzimmer_rolladen
    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: "Rolladen 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:

condition:
  - 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'
trigger:
  - platform: state
    entity_id: input_boolean.rollladen_override
    to: 'on'
action:
  - service: 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'
  - service: input_boolean.turn_off
    target:
      entity_id: input_boolean.rollladen_override
mode: single

Die Condition direkt vor dem turn_off ist wichtig: Wenn jemand den Override in der Zwischenzeit manuell deaktiviert hat, greift die Automation nicht nochmal ein und aktiviert ihn versehentlich wieder.

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'
trigger:
  - platform: state
    entity_id: binary_sensor.fensterkontakt_wohnzimmer
    to: 'on'
condition:
  - condition: template
    value_template: >
      {{ state_attr('cover.wohnzimmer_rolladen', 'current_position') | int < 60 }}
action:
  - service: input_number.set_value
    target:
      entity_id: input_number.rollladen_position_vor_fenster
    data:
      value: "{{ state_attr('cover.wohnzimmer_rolladen', 'current_position') | int }}"
  - service: cover.set_cover_position
    target:
      entity_id: cover.wohnzimmer_rolladen
    data:
      position: 60
mode: single

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

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

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: 'Rolladen öffnen vor Wecker (Android)'
trigger:
  - platform: 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')) }}
action:
  - service: cover.set_cover_position
    target:
      entity_id: cover.schlafzimmer_rolladen
    data:
      position: 25
  - delay: "00:10:00"
  - service: cover.open_cover
    target:
      entity_id: cover.schlafzimmer_rolladen
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 Rolladen-Automation reagiert auf denselben Trigger.

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

alias: 'Rolladen öffnen vor Wecker (iPhone / HA-Wecker)'
trigger:
  - platform: template
    value_template: >
      {{ now().strftime('%H:%M') ==
         (as_datetime(today_at(states('input_datetime.wecker_morgen'))) -
          timedelta(minutes=10)).strftime('%H:%M') }}
action:
  - service: cover.set_cover_position
    target:
      entity_id: cover.schlafzimmer_rolladen
    data:
      position: 25
  - delay: "00:10:00"
  - service: cover.open_cover
    target:
      entity_id: cover.schlafzimmer_rolladen
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'
trigger:
  - platform: state
    entity_id: person.philipp
    to: 'not_home'
    for:
      minutes: 15
action:
  - service: cover.set_cover_position
    target:
      entity_id:
        - cover.wohnzimmer_rolladen
        - cover.schlafzimmer_rolladen
        - cover.kueche_rolladen
    data:
      position: 20
mode: single

alias: 'Rollläden bei Heimkehr öffnen'
trigger:
  - platform: state
    entity_id: person.philipp
    to: 'home'
action:
  - service: cover.open_cover
    target:
      entity_id:
        - cover.wohnzimmer_rolladen
        - cover.schlafzimmer_rolladen
        - cover.kueche_rolladen
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, lässt sich das automatisch absichern:

alias: 'Sturmschutz — alle Rollläden einfahren'
trigger:
  - platform: numeric_state
    entity_id: sensor.wind_speed
    above: 50
condition: []
action:
  - service: cover.close_cover
    target:
      entity_id:
        - cover.wohnzimmer_rolladen
        - cover.schlafzimmer_rolladen
        - cover.kueche_rolladen
  - service: 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)'
trigger:
  - platform: sun
    event: sunrise
    offset: "-00:45:00"
condition:
  - condition: numeric_state
    entity_id: sensor.aussentemperatur
    below: 20
  - condition: template
    value_template: "{{ now().month in [5, 6, 7, 8, 9] }}"
action:
  - service: cover.set_cover_position
    target:
      entity_id: cover.schlafzimmer_rolladen
    data:
      position: 15
  - delay: "00:30:00"
  - service: cover.close_cover
    target:
      entity_id: cover.schlafzimmer_rolladen
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.

PJ

Philipp Just

Gründer & Autor

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