Raffstore-Lamellen mit Shelly und Home Assistant aufs Prozent genau kippen

Deinen Raffstore mit Shelly und Home Assistant nicht nur rauf- und runterfahren, sondern die Lamellen gezielt kippen – aufs Prozent genau. Das ging jahrelang nur mit hässlichen Workarounds. Seit Firmware 1.5.0 (Anfang 2025) können die Shellys ab Generation 2 das nativ. Ich habe die Funktion über ein Jahr lang übersehen und bin erst durch einen Bug an einer ganz anderen Stelle darauf gestoßen – heute bin ich großer Fan. Hier zeige ich dir, wie du sie einrichtest, und vor allem die beiden Automationen, die im Video nur kurz zu sehen sind, komplett zum Nachbauen.

Zum Aktivieren des Videos musst Du auf das Bild klicken. Ich möchte Dich darauf hinweisen, dass durch die Aktivierung Daten an YouTube übermittelt werden.

Position und Tilt: zwei unabhängige Werte

Eine Cover-Entity in Home Assistant hat bei aktivierter Lamellensteuerung zwei Werte:

Der Clou: Der Raffstore bleibt auf einer festen Höhe stehen, und du regelst trotzdem präzise, wie viel Licht und Sonne durchkommt – nur über den Lamellenwinkel. Im Video zeige ich das an meinem Arbeitszimmer mit einem Shelly Plus 2PM: Ich fahre nur den Tilt von 20 über 50 auf 80 %, und die Höhe bleibt die ganze Zeit gleich.

Vorgeschichte: meine hässlichen Workarounds

Nativ ging das nicht schon immer. An meinen Süd-Fenstern hingen ursprünglich vier Shelly 2.5 – Geräte der ersten Generation, die bis heute keine Tilt-Einstellung kennen. Mein Workaround damals: vier eigene Schalter in Home Assistant, die über die Shelly-REST-API einen ganz kurzen Impuls geschickt haben, 200 Millisekunden auf oder zu, um die Lamellen halbwegs gezielt zu bewegen. Ja, das war genau so von hinten durchs Knie geschossen, wie es klingt.

Später habe ich die Shellys gegen Geräte der zweiten Generation getauscht – die Neuerung Anfang 2025 aber schlicht verpasst. Auch in meiner Weckroutine steckte so ein Trick (dazu unten mehr). Inzwischen habe ich den ganzen Kram rausgeworfen.

Welche Shellys können Tilt? Alle Cover-fähigen Shellys ab Gen2 (Plus- und Pro-Serie sowie Gen3/Gen4) ab Firmware 1.5.0. Die erste Generation (z. B. Shelly 2.5) kann es nicht.

Einrichtung am Shelly: Slat Control

In der Shelly-Weboberfläche: Cover → Einstellungen → Slat Control.

• Open Time / Close Time: Wie lange eine volle Lamellendrehung dauert (ganz unten bis ganz oben). Der Shelly schlägt 1,5 s vor – bei mir sind es 1,1 s. Unbedingt an deinen Raffstore anpassen, sonst stimmen die berechneten Prozentwerte nicht.
• Nicht verwechseln mit der normalen Fahrzeit-Kalibrierung des Raffstores. Die läuft automatisch, die Lamellenzeit musst du selbst eintragen.
• Retain Slat Position: Der Lamellenwinkel bleibt erhalten, wenn der Raffstore fährt. Steht der Tilt auf 50 % und du fährst halb hoch, stellt der Shelly danach wieder 50 % her.
• Precise Slat Position: Soll laut Doku die Ansteuerung noch genauer machen. Ich habe im Alltag keinen Unterschied bemerkt – wenn du weißt, was es genau bewirkt, schreib’s mir gerne in die Kommentare.

Am Wandtaster ändert sich auch etwas: Kurz drücken bewegt nur noch die Lamellen (in 20-%-Schritten), lang drücken fährt den Raffstore wie gewohnt. Ein kurzer Druck während der Fahrt stoppt.

Wie ich das Feature gefunden habe: ein Matter-Bug

Aufgefallen ist mir Slat Control nicht bei den Raffstores, sondern völlig woanders: Ich teste gerade die neuen Shelly-Gen4-Geräte und dabei auch deren Matter-Unterstützung. Bindest du einen Shelly per Matter in Home Assistant ein und Slat Control ist nicht aktiv, legt Home Assistant gar keine Cover-Entity an.

Der Grund: Der Shelly meldet für den Tilt dann keinen Wert – im Programmierjargon null, nicht zu verwechseln mit der Zahl 0. Genau daran verschluckt sich die Matter-Integration von Home Assistant. Sobald Slat Control aktiv ist, kommt eine echte Zahl an und die Cover-Entity erscheint ganz normal. Bei dieser Fehlersuche bin ich zum ersten Mal über die Einstellung gestolpert.

Update: Ich habe dafür einen Bugfix für Home Assistant beigesteuert, der mit HA 2026.9.3 kommt. Mehr dazu – und zu Matter und Zigbee bei den Gen4-Geräten – gibt es in meinen nächsten Videos.

In Home Assistant: Attribut und Service

• Lesen: Attribut current_tilt_position an der Cover-Entity
• Setzen: cover.set_cover_tilt_position – analog zu cover.set_cover_position

1
2
3
4
5

action: cover.set_cover_tilt_position
target:
  entity_id: cover.arbeitszimmer_raffstore
data:
  tilt_position: 50

Wichtig: erst fahren, warten, dann kippen

Home Assistant kann Position und Tilt theoretisch in einem Aufruf kombinieren, aber nicht jedes Gerät setzt das sauber um – bei mir gab es damit Probleme. Deshalb:

1. Raffstore fahren (cover.close_cover oder cover.set_cover_position)
2. Warten, bis er angekommen ist (wait_template)
3. Erst dann cover.set_cover_tilt_position

Ohne das Warten überschreiben sich die Befehle gegenseitig, und der Raffstore landet in einem Zustand, den du so nicht wolltest.

Automation 1: Sonnenschutz nach Sonnenstand

Die Steuerung besteht bei mir aus zwei Blueprints.

Blueprint A: Scheint die Sonne aufs Fenster?

Dieser Blueprint schaltet pro Fensterfront einen input_boolean (z. B. input_boolean.sudfenster_beschienen) ein, sobald die Sonne tatsächlich auf die Scheibe fällt. Er berücksichtigt dabei die Himmelsrichtung, die Ausrichtung meines Hauses (offset: 23 Grad) und den Dachüberstand: Steht die Sonne hoch genug, schirmt der Überstand das Fenster ab – dann muss auch nichts geschlossen werden.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

blueprint:
  name: Fensterbescheinung berechnen
  description: Berechnet ob für eine bestimmte Himmelsrichtung die Sonne auf die Fenster scheint
  domain: automation
  input:
    target_azimuth:
      name: Himmelsrichtung
      description: Die zu betrachtende (ideale) Himmelsrichtung
      selector:
        select:
          options:
            - value: "0"
              label: Nord
            - value: "90"
              label: Ost
            - value: "180"
              label: Süd
            - value: "270"
              label: West
    boolean_entity:
      name: Zustandsschalter
      description: Eine Entity die auf "ein" geschaltet wird, wenn die Sonne auf die Fenster scheint
      selector:
        entity:
          domain: input_boolean
trigger:
  - platform: state
    entity_id:
      - sensor.sun_solar_elevation
condition:
  - condition: numeric_state
    entity_id: sensor.sun_solar_elevation
    above: -1
action:
  - variables:
      target_azimuth: !input target_azimuth
      offset: 23              # Abweichung der Hausausrichtung von der Himmelsrichtung
      azimuth: "{{ states('sensor.sun_solar_azimuth')|float }}"
      elevation: "{{ states('sensor.sun_solar_elevation')|float }}"
      roof_overhang: 86       # Dachüberstand in cm
      window_height: 200      # Fensterhöhe in cm
  - if:
      - condition: template
        value_template: |-
          {% set target_azimuth = target_azimuth|int + offset %}
          {% set delta = (target_azimuth - azimuth)|abs %}
          {{ delta < 90 or delta > 270 }}
      - condition: template
        value_template: >-
          {% set target_azimuth = target_azimuth|int + offset %}
          {% set degrees = 90-(azimuth-target_azimuth)|abs %}
          {% set effective_roof_overhang = roof_overhang / sin(degrees / 180 *
          3.1415) %}
          {% set max_elevation = (atan(window_height/effective_roof_overhang)) /
          3.1415 * 180 %}
          {{ 0 < elevation and elevation < max_elevation }}
    then:
      - service: input_boolean.turn_on
        data: {}
        target:
          entity_id: !input boolean_entity
    else:
      - service: input_boolean.turn_off
        data: {}
        target:
          entity_id: !input boolean_entity
mode: single

sensor.sun_solar_azimuth und sensor.sun_solar_elevation liefert die eingebaute Sonnen-Integration (ggf. in den Entitäten aktivieren). offset, roof_overhang und window_height musst du an dein Haus anpassen.

Blueprint B: Raffstore schließen und Lamellen kippen

Dieser Blueprint reagiert auf den input_boolean aus Blueprint A: Scheint die Sonne aufs Fenster, fährt der Raffstore zu, wartet bis er wirklich geschlossen ist und kippt dann die Lamellen auf den eingestellten Wert. Geht die Sonne vom Fenster weg, öffnet er wieder – aber nur, wenn die Automation den Raffstore auch selbst geschlossen hat.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

blueprint:
  name: Rollos nach Sonnenstand schliessen und öffnen
  description: Schliesst und öffnet Rollos abhängig von einer Boolean Entity und optional Fensterkontakten
  domain: automation
  input:
    sun_hits_window_entity:
      name: Sonnenstandsindikator
      selector:
        entity:
          domain: input_boolean
    window_open_entity:
      name: Fensterkontakt
      default: []
      selector:
        entity:
          domain: binary_sensor
    cover:
      name: Rolladen
      selector:
        entity:
          domain: cover
    add_conditions:
      name: Weitere Bedingungen
      default: []
      selector:
        condition:
    tilt_after_close:
      name: Tilt nach dem Schliessen
      description: >-
        Optional: Lamellen-Position (%), auf die nach dem Schliessen
        gekippt wird. Leer lassen, um den Tilt unangetastet zu lassen.
      default: -1
      selector:
        number:
          min: -1
          max: 100
          step: 1
          mode: slider
trigger:
  - platform: state
    entity_id:
      - !input sun_hits_window_entity
    from: "off"
    to: "on"
    id: sun_true
  - platform: state
    entity_id:
      - !input sun_hits_window_entity
    from: "on"
    to: "off"
    id: sun_false
  - platform: state
    entity_id: !input window_open_entity
    from: "on"
    to: "off"
    id: closed
  - platform: state
    entity_id:
      - binary_sensor.sonne_scheint
    from: "off"
    to: "on"
    id: brightness_level
condition: !input add_conditions
action:
  - choose:
      - conditions:
          - condition: trigger
            id:
              - sun_true
              - closed
              - brightness_level
          - condition: state
            entity_id: !input sun_hits_window_entity
            state: "on"
          - condition: state
            entity_id: !input cover
            state: open
          - condition: template
            value_template: >-
              {{ cover not in
              states.sensor.automation_cover_state.state }}
            alias: Cover wurde heute noch nicht automatisiert geschlossen
          - condition: state
            entity_id: !input window_open_entity
            state: "off"
          - condition: state
            entity_id: binary_sensor.sonne_scheint
            state: "on"
        sequence:
          - service: cover.close_cover
            data: {}
            target:
              entity_id: !input cover
          - if:
              - condition: template
                value_template: "{{ tilt_after_close|int(-1) >= 0 }}"
            then:
              - wait_template: "{{ is_state(cover, 'closed') }}"
                timeout:
                  seconds: 60
                continue_on_timeout: true
              - service: cover.set_cover_tilt_position
                data:
                  tilt_position: "{{ tilt_after_close|int(-1) }}"
                target:
                  entity_id: !input cover
      - conditions:
          - condition: trigger
            id:
              - sun_false
          - condition: template
            value_template: >-
              {{ cover in
              states.sensor.automation_cover_state.state }}
            alias: Cover wurde heute automatisiert geschlossen
        sequence:
          - service: cover.open_cover
            data: {}
            target:
              entity_id: !input cover
variables:
  cover: !input cover
  tilt_after_close: !input tilt_after_close
mode: restart

Zwei Entitäten sind bei mir hausspezifisch und musst du ersetzen oder entfernen:

• binary_sensor.sonne_scheint – ein Helligkeitssensor, damit bei bewölktem Himmel nichts schließt.
• sensor.automation_cover_state – merkt sich, welche Rollläden heute schon automatisch geschlossen wurden. So öffnet die Automation nichts, was du selbst zugemacht hast, und schließt nichts ein zweites Mal, das du manuell wieder geöffnet hast.

Die Nutzung sieht dann so aus:

1
2
3
4
5
6
7
8

- alias: "Rollläden: Wohnzimmer Süd – nach Sonnenstand schließen/öffnen"
  use_blueprint:
    path: homeassistant/sun_close_blinds.yaml
    input:
      sun_hits_window_entity: input_boolean.sudfenster_beschienen
      window_open_entity: binary_sensor.fensterkontakt_wohnzimmer_sued
      cover: cover.rollo_wohnzimmer_sued
      tilt_after_close: 50

tilt_after_close: 50 stellt die Lamellen waagerecht. Je nach Fenster und Lichteinfall kann ein anderer Wert besser passen.

Automation 2: Weckroutine mit Tageslicht

Meine Weckroutine fährt morgens Licht und Radio sanft hoch. Früher gab es als letzten Schritt einen hässlichen Hack: War der Raffstore komplett zu, wurde er auf Position 1 % gefahren, damit durch die Lamellenschlitze etwas Licht fällt. Das hat irgendwie funktioniert, war aber kein echter Tilt.

Heute bleibt der Raffstore geschlossen, und nur die Lamellen werden gekippt:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

- alias: Lamellen auf 50% kippen (wenn komplett geschlossen)
  if:
    - condition: state
      entity_id: cover.schlafzimmer_raffstore
      attribute: current_position
      state: 0
  then:
    - alias: Setze Tilt auf 50%
      action: cover.set_cover_tilt_position
      target:
        entity_id: cover.schlafzimmer_raffstore
      data:
        tilt_position: 50
      continue_on_error: true

Die Bedingung auf current_position: 0 sorgt dafür, dass ein bereits geöffneter Raffstore nicht angefasst wird. continue_on_error verhindert, dass die ganze Weckroutine abbricht, falls der Shelly gerade nicht erreichbar ist.

Die restlichen Schritte der Routine (in Kurzform):

1. 10 Minuten nach dem Auslöser: Schlafzimmerlampen über 20 Minuten hochdimmen (transition: 1200)
2. Sonos auf Lautstärke 0, Lieblingssender starten – mit bis zu 3 Versuchen, bis der Player wirklich playing meldet
3. Lautstärke in 8 Schritten à 2 Minuten erhöhen
4. Lamellen kippen (siehe oben)

Mein Fazit

Das Feature steckt seit Anfang 2025 in der Firmware – und es lohnt sich, ab und zu in den Einstellungen deiner Shellys zu stöbern, auch wenn du glaubst, dein Gerät längst zu kennen.

Zwei Fragen an dich: Weißt du, was Precise Slat Position im Detail bewirkt? Und hast du selbst Raffstores, die eigentlich Tilt könnten, aber du nutzt es noch nicht? Schreib’s mir in die Kommentare!

Falls du deine Jalousien noch gar nicht mit Shelly automatisiert hast: Die Grundlagen findest du in meinem Artikel Jalousien mit Shelly smart machen.

Werbung: Wenn du dir einen Shelly zulegen willst: Mit dem Code SMARTHOMEABERSICHER-10OFF bekommst du 10 % Rabatt über diesen Link (bezahlter Link).

Die im Video kurz gezeigten Shelly-Gen4-Geräte hat mir Shelly kostenlos zur Verfügung gestellt. Shelly hatte keinen Einfluss auf den Inhalt dieses Artikels.

Hinweis: Die mit bezahlter Link markierten Links sind Affiliate-Links. Als Partner verschiedener Händler und Hersteller (z. B. Amazon, OBI über das Awin-Netzwerk, Shelly) verdiene ich an qualifizierten Verkäufen. Das bedeutet, dass ich eine kleine Provision erhalte, wenn ihr über diese Links einkauft. Für euch entstehen dabei keine zusätzlichen Kosten. Die Einnahmen helfen mir, diesen Blog und meinen YouTube-Kanal zu betreiben und auch in Zukunft Inhalte für euch zu erstellen. Vielen Dank für eure Unterstützung!

― Joachim