Schlagwort: Tutorial

  • Strompreis und Hausakku auf der AWTRIX-Uhr – mit Home Assistant und einem Klick

    Strompreis und Hausakku auf der AWTRIX-Uhr – mit Home Assistant und einem Klick

    Dieser Beitrag enthält Affiliate-Links (mit * gekennzeichnet).

    Im November habe ich gezeigt, wie man die AWTRIX-Pixeluhr komplett über Home Assistant steuert – mit einer ordentlichen Portion YAML. Das geht jetzt einfacher: Drei meiner liebsten Anzeigen gibt es als Blueprint. Ein Klick zum Importieren, Geräte auswählen, fertig. Kein Code.

    AWTRIX-Uhr bei uns: Uhrzeit, Temperatur, Luftfeuchte, Strompreis; rechts PV-Überschuss, Akku-Ampel und Müll-Ampel
    So sieht es bei uns aus: Uhrzeit, Temperatur, Luftfeuchte – dann der Strompreis in Rot. Rechts die drei Ecken: oben PV-Überschuss (rot = gerade keiner), in der Mitte die Akku-Ampel, unten die Müll-Ampel – hier grün für „morgen Bio“.

    Was die Uhr dann zeigt

    • Den aktuellen Strompreis als eigene App, zum Beispiel 24,1 – grün, wenn es günstig ist, gelb in der Mitte, rot, wenn man lieber wartet. Die Grenzen stellst du selbst ein.
    • Den Ladestand des Hausakkus als farbige Ecke: leer rot, halb gelb, voll grün, stufenlos dazwischen. Ein Blick genügt.
    • Die Mülltonne für morgen als zweite Ecke – ab dem Vorabend in der Farbe der Tonne, am Abholtag morgens blinkend. Gelesen wird jeder Abfallkalender, auch der ICS-Link deiner Stadt.

    Bei uns hängt auf jeder Etage eine Uhr – so sehen wir die wichtigsten Informationen auf einen Blick.

    Was du brauchst

    • Die Ulanzi TC001 Pixel-Uhr* mit der kostenlosen Firmware AWTRIX 3
    • Home Assistant mit dem Add-on Mosquitto (MQTT)
    • Einen Strompreis-Sensor – etwa aus der Tibber-Integration. Noch kein dynamischer Tarif? Über meinen Tibber-Einladungslink* bekommen wir beide 50 € für den Tibber Store oder 6 Monate ohne Tibber-Gebühr.
    • Für die Ecke: einen Akku-Sensor in Prozent (Hausakku, E-Auto …)

    In drei Schritten

    1. Uhr einmal einrichten: AWTRIX 3 aufspielen und mit MQTT verbinden. Das dauert zehn Minuten – die genaue Anleitung mit allen Feldern steht auf GitHub.
    2. Blueprint importieren: auf den blauen Knopf tippen.
      Strompreis: In Home Assistant importieren
      Akku-Ampel: In Home Assistant importieren
      Müll-Ampel: In Home Assistant importieren
    3. Automation anlegen: In Home Assistant unter Einstellungen → Automationen & Szenen → Blueprints den Blueprint öffnen, Sensor und Uhr auswählen, speichern.

    Hat’s geklappt? Wenn dir der Blueprint Zeit spart, freue ich mich über einen Kaffee ☕.

    Neue Blueprints zuerst bekommen? Zweimal pro Woche, sonntags und mittwochs, kommt ein neuer Baustein aus unserem Haus – kostenlos per Mail, abbestellen mit einem Klick.

    Ein paar Kleinigkeiten, die mir wichtig waren: Es spielt keine Rolle, ob dein Sensor in Euro oder Cent misst. Mehrere Uhren gehen auf einmal. Und kommt eine halbe Stunde kein neuer Preis, verschwindet die Anzeige, statt einen alten Wert stehen zu lassen.

    Hakt es?

    Die häufigsten Stolpersteine stehen in der Anleitung. Ansonsten gerne einen Kommentar hier oder ein Issue auf GitHub.

    Passend dazu: Energie-Cockpit: PV, Akku und Strompreis · Müll-Karte und Erinnerung

    Gefällt dir das?

    Die Blueprints sind kostenlos. Wenn sie dir Zeit sparen, freue ich mich über einen Kaffee:

    Unterstütze mich auf Ko-fi

    * Affiliate-Links: Kaufst oder wechselst du darüber, bekomme ich eine kleine Provision bzw. Prämie – für dich ändert sich am Preis nichts. Als Amazon-Partner verdiene ich an qualifizierten Verkäufen.

  • Mehr als Spielerei: So steuerst du deine AWTRIX Pixel-Uhr komplett über Home Assistant (Inkl. YAML-Code)

    Mehr als Spielerei: So steuerst du deine AWTRIX Pixel-Uhr komplett über Home Assistant (Inkl. YAML-Code)

    Dieser Beitrag enthält Affiliate-Links (mit * gekennzeichnet).

    Update Oktober 2026: Strompreis, Akku-Ampel und Müll-Ampel gibt es jetzt als Blueprint – ohne YAML, mit einem Klick: Strompreis und Hausakku auf der AWTRIX-Uhr – jetzt mit einem Klick. Wer verstehen oder selbst bauen will, findet unten weiterhin den kompletten Code.


    Hand aufs Herz: Wie oft schaut ihr am Handy nach, welche Mülltonne morgen raus muss? Oder checkt die App, wie voll der Hausakku gerade ist?

    In einem wirklich smarten Zuhause sollten Informationen dort sein, wo man sie braucht – und zwar ohne, dass man aktiv danach suchen muss.

    Deshalb haben wir in unserer Küche die AWTRIX (basierend auf der Ulanzi TC001* mit der genialen AWTRIX-Firmware, inzwischen AWTRIX 3) installiert.

    In diesem Beitrag zeige ich euch nicht nur das Konzept, sondern gebe euch meinen kompletten YAML-Code. Wir bauen drei Dinge:

    1. Basis-Skripte: Damit wir die Uhr einfach ansteuern können.
    2. Die Müll-Ampel: Farbige Punkte für Restmüll, Papier & Co.
    3. Der Akku-Monitor: Ein dynamischer Farbverlauf (Rot -> Gelb -> Grün) für den Speicher-Füllstand.

    AWTRIX-Uhr mit Apps und Eck-Anzeigen
    So sieht das bei uns aus: Uhrzeit, Temperatur, Luftfeuchte, Strompreis – rechts die drei Ecken: oben PV-Überschuss, Mitte Akku, unten die Müll-Ampel (grün = morgen Bio).

    Teil 1: Die Werkzeuge (Scripts.yaml)

    Anstatt in jeder Automation mühsam MQTT-Befehle zu tippen, nutzen wir wiederverwendbare Skripte. Das hält den Code sauber.

    Fügt diese Blöcke in eure scripts.yaml ein (oder erstellt neue Skripte in der UI im YAML-Modus).

    WICHTIG: Ersetzt awtrix_küche durch den MQTT-Namen eurer Uhr!

    1. Indikator setzen (Die farbigen Ecken)

    Dieses Skript steuert die kleinen Dreiecke in den Ecken der Uhr (wir nutzen Indikator 3 für Müll).

    awtrix_indicator:
      alias: "AWTRIX - Indikator setzen"
      description: "Setzt die Farbe eines Indikators auf der Uhr"
      fields:
        indicator_id:
          description: "Welcher Indikator? (1, 2 oder 3)"
          example: 3
        color:
          description: "RGB Farbe als Liste [R, G, B]"
          example: [255, 0, 0]
      sequence:
        - service: mqtt.publish
          data:
            topic: "awtrix_küche/indicator{{ indicator_id }}"
            payload: >-
              {"color": {{ color | to_json }}}
    
    

    2. Neue App anzeigen (Text/Icon)

    Dieses Skript sendet eine Nachricht (z.B. Temperatur) an die Uhr, die dann durchscrollt.

    awtrix_new_app:
      alias: "AWTRIX - App senden"
      fields:
        app_name:
          description: "Name der App (ID)"
          example: "temp_kueche"
        text:
          description: "Der Text der angezeigt werden soll"
        icon:
          description: "Icon Name (ohne .gif)"
        color:
          description: "Textfarbe [R, G, B]"
      sequence:
        - service: mqtt.publish
          data:
            topic: "awtrix_küche/custom/{{ app_name }}"
            payload: >-
              {
                "text": "{{ text }}",
                "icon": "{{ icon }}",
                "color": {{ color | default([255,255,255]) | to_json }},
                "pushIcon": 2,
                "repeat": 2
              }
    
    

    Teil 2: Die Müll-Ampel (Automation)

    Einfacher: Die Müll-Ampel gibt es als Blueprint. Sie liest jeden Abfallkalender (z. B. den ICS-Link deiner Stadt), leuchtet ab dem Vorabend und blinkt am Abholtag: In Home Assistant importieren

    Morgens um 04:00 Uhr prüft das System unseren Abfallkalender. Je nach Müllsorte leuchtet Indikator 3 (oben rechts) in der passenden Farbe.

    Voraussetzung: Ihr habt einen Sensor (z.B. sensor.mullabholung), der den Typ der nächsten Tonne liefert.

    alias: "AWTRIX - Müllanzeige (Indikator)"
    description: "Setzt den Indikator basierend auf dem Abfallkalender."
    trigger:
      - platform: time
        at: "04:00:00"
    action:
      - choose:
          # Fall 1: Restmüll (Grau)
          - conditions:
              - condition: state
                entity_id: sensor.mullabholung
                state: "Restmüll"
            sequence:
              - service: script.awtrix_indicator
                data:
                  indicator_id: 3
                  color: [128, 128, 128]
    
          # Fall 2: Papier (Blau)
          - conditions:
              - condition: state
                entity_id: sensor.mullabholung
                state: "Papier"
            sequence:
              - service: script.awtrix_indicator
                data:
                  indicator_id: 3
                  color: [0, 0, 255]
    
          # Fall 3: Bio (Grün)
          - conditions:
              - condition: state
                entity_id: sensor.mullabholung
                state: "Bio"
            sequence:
              - service: script.awtrix_indicator
                data:
                  indicator_id: 3
                  color: [0, 255, 0]
    
          # Fall 4: Kein Müll -> Indikator aus (Schwarz)
          - conditions:
              - condition: state
                entity_id: sensor.mullabholung
                state: "Keine"
            sequence:
              - service: script.awtrix_indicator
                data:
                  indicator_id: 3
                  color: [0, 0, 0]
    mode: single
    
    

    Hat’s geklappt? Wenn dir der Blueprint Zeit spart, freue ich mich über einen Kaffee ☕.

    Neue Blueprints zuerst bekommen? Zweimal pro Woche, sonntags und mittwochs, kommt ein neuer Baustein aus unserem Haus – kostenlos per Mail, abbestellen mit einem Klick.

    Teil 3: Der dynamische Akku-Balken (Profi-Level)

    Einfacher: Den Akku-Balken gibt es als Blueprint „Akku-Ampel“: In Home Assistant importieren

    Das ist mein optisches Highlight. Wir visualisieren den Ladestand unseres BYD-Speichers (sensor.sn_3012376597_battery_soc_total) als Indikator 2 (unten rechts).

    Der Clou: Die Farbe ändert sich fließend!

    • 0% = Rot
    • 50% = Gelb
    • 100% = Grün

    Dafür nutzen wir ein Jinja2-Template, das die RGB-Werte berechnet.

    alias: "AWTRIX - Hausakku Farbverlauf"
    description: "Ändert die Farbe des Indikators je nach Ladestand (Rot->Gelb->Grün)"
    trigger:
      - platform: state
        entity_id: sensor.sn_3012376597_battery_soc_total
    action:
      - service: mqtt.publish
        data:
          topic: "awtrix_küche/indicator2"
          payload: >-
            {% set soc = states('sensor.sn_3012376597_battery_soc_total') | float(0) %}
            {% if soc <= 50 %}
              {# Von Rot (0%) zu Gelb (50%) #}
              {# Rot bleibt 255, Grün steigt von 0 auf 255 #}
              {% set r = 255 %}
              {% set g = (255 * (soc / 50)) | int %}
              {% set b = 0 %}
            {% else %}
              {# Von Gelb (50%) zu Grün (100%) #}
              {# Rot sinkt von 255 auf 0, Grün bleibt 255 #}
              {% set r = (255 * (1 - (soc - 50) / 50)) | int %}
              {% set g = 255 %}
              {% set b = 0 %}
            {% endif %}
            {"color": [{{ r }}, {{ g }}, {{ b }}]}
    mode: restart
    
    

    Fazit

    Mit diesen drei Bausteinen wird die AWTRIX von einer Spielerei zu einem echten Info-Dashboard. Besonders der Akku-Balken ist ein Hingucker, der Besuchern sofort auffällt („Oh, ihr habt gerade viel Strom!“).

    Habt ihr Fragen zum Code oder eigene Ideen für die Anzeige? Postet sie gerne in die Kommentare!


    Passend dazu: Müll-Karte und Erinnerung · Energie-Cockpit: PV, Akku und Strompreis

    Gefällt dir das?

    Alle Blueprints und Anleitungen liegen kostenlos auf GitHub. Wenn sie dir Zeit sparen, freue ich mich über einen Kaffee:

    Unterstütze mich auf Ko-fi

    * Affiliate-Links: Kaufst du darüber, bekomme ich eine kleine Provision – für dich ändert sich am Preis nichts. Als Amazon-Partner verdiene ich an qualifizierten Verkäufen.

  • Kostengünstig Elektro Auto fahren? Unser Setup mit Home Assistant, EVCC und dynamischen Strompreisen

    Kostengünstig Elektro Auto fahren? Unser Setup mit Home Assistant, EVCC und dynamischen Strompreisen

    Dieser Beitrag enthält einen Empfehlungslink (mit * gekennzeichnet).

    Update Oktober 2026 – evcc hat die Lademodi umgebaut (ab Version 0.316):

    • Smart ersetzt „Nur PV“: geladen wird mit Sonnenüberschuss.
    • „Min + PV“ heißt jetzt Smart mit „Immer laden“.
    • Sofort und Aus bleiben, wie sie waren.
    • Das geplante Laden ist die Ladeplanung mit Abfahrtszeit: Ziel und Uhrzeit am Fahrzeug einstellen, evcc sucht die günstigsten Viertelstunden. Genau so laden wir heute.

    Wer in Home Assistant noch pv oder minpv setzt, bekommt von evcc inzwischen einen Fehler.


    Hast du dich auch schon mal geärgert, wenn du dein E-Auto angesteckt hast, und zwei Stunden später kam die Sonne raus – aber der Akku war schon voll, geladen mit teurem Netzstrom?

    Oder nutzt du vielleicht schon einen dynamischen Stromtarif (wie Tibber), verpasst aber regelmäßig die günstigsten Stunden in der Nacht, weil du schläfst?

    Genau das war unser Problem. Wir haben eine PV-Anlage (SMA), einen Hausspeicher (BYD) und zwei E-Autos (Kia EV6 & Niro). Das Ziel war klar: Wir wollen so günstig wie möglich fahren.

    Die Lösung ist EVCC in Kombination mit Home Assistant. In diesem Beitrag zeige ich euch, wie wir unser „Energie-Gehirn“ gebaut haben, das automatisch entscheidet, ob wir mit Sonnenstrom oder Billig-Strom aus dem Netz laden.

    Das Hardware-Setup

    Bevor wir zur Software kommen, hier kurz unser Maschinenraum (Stand 2025):

    • PV & Speicher: SMA Smart Energy Hybrid-Wechselrichter + BYD Batterie (12.8 kWh).
    • Wallbox: SMA EV Charger (3-phasig).
    • Autos: Kia EV6 und Kia Niro.
    • Tarif: Tibber* (dynamischer Tarif, inzwischen viertelstündlich).

    Warum SMA allein nicht reicht (Der „Game Changer“: EVCC)

    Der SMA Home Manager kann zwar „Überschussladen“ (Sonne da -> Auto laden). Aber er ist oft träge und kann eines nicht gut: Dynamische Stromtarife integrieren.

    Deshalb nutzen wir EVCC (Electric Vehicle Communication Controller). Das ist eine geniale Open-Source-Software, die als Add-on in Home Assistant läuft. Sie ist der Dirigent, der zwischen Auto, Solaranlage und Strombörse vermittelt.

    Die Strategie: So lädt das Haus

    Wir haben in Home Assistant (bzw. EVCC) verschiedene Lademodi definiert, die wir per Dashboard umschalten können:

    1. Nur PV (Der Sparfuchs): Das Auto lädt ausschließlich, wenn Überschuss vom Dach kommt. Zieht eine Wolke durch, pausiert die Ladung. Kosten: 0 Cent (bzw. entgangene Einspeisevergütung).
    2. Min + PV (Der Standard): Das Auto lädt immer mit einer Mindestleistung (damit es voll wird), nimmt aber jeden Sonnenstrahl als Boost mit.
    3. Schnell (Der Notfall): Maximale Power aus dem Netz, egal was es kostet.
    4. Geplantes Laden (Der Tibber-Trick): Wir sagen dem System: „Morgen früh um 07:00 Uhr muss das Auto 80% haben.“
      • EVCC prüft den Tibber-Preis für die Nacht.
      • Es sucht sich automatisch die billigsten Stunden raus (z.B. 02:00 bis 04:00 Uhr, wenn der Strom vielleicht nur 15 Cent kostet).
      • Es lädt das Auto punktgenau voll.

    Die Integration in Home Assistant

    Dashboard-Seite Autos
    Unsere Autos-Seite: Ladestand und Reichweite je Auto, die Ladestatistik mit Kosten und Sonnenanteil – und die Wallbox mit den evcc-Modi Aus, Smart, Min+Smart und Sofort.
    EV6-Karussell auf der Autos-Seite
    Je Auto zum Wischen: Ladestand, die Woche, die letzten Ladungen und was es gegenüber Benzin spart. Diese Karte hättest du gern zum Nachbauen? Schreib es in die Kommentare – was gefragt ist, stelle ich als Nächstes bereit.

    EVCC läuft bei uns als Add-on. Das Geniale ist aber die Visualisierung im Dashboard. Wir nutzen dafür die Power Flow Card Plus. Sie zeigt auf einen Blick, wohin die Energie fließt.

    So sieht das bei uns im Dashboard aus (Auszug aus der Konfiguration):

    Schritt 1: EVCC Integrieren

    Installiert das „EVCC“ Add-on über den Supervisor und anschließend die „EVCC“ Integration aus dem Marketplace (früher HACS) oder die offizielle Integration, um die Sensoren (Ladeleistung, SoC, Status) in Home Assistant zu bekommen.

    Schritt 2: Die Visualisierung (Power Flow Card Plus)

    Hier ist der YAML-Code für unsere Energie-Karte im Dashboard. Sie kombiniert SMA-Daten, Batterie-Status und die EVCC-Daten.

    (Hinweis: Passt die Entitäten an eure Namen an!)

    type: custom:power-flow-card-plus
    entities:
      battery:
        entity: sensor.batterie_status_ladung_entladung
        state_of_charge: sensor.batterie_ladezustand
        name: BYD Speicher
      grid:
        entity: sensor.netzbezug_einspeisung_kombiniert
        name: Netz (Tibber)
      solar:
        entity: sensor.pv_erzeugung_aktuell
        display_zero_state: true
        name: SMA Solar
      home:
        entity: sensor.hausverbrauch_aktuell
      # Hier kommt das E-Auto ins Spiel (Daten aus EVCC)
      fossil_fuel_percentage:
        entity: sensor.evcc_vehicle_soc
        icon: mdi:car-electric
        name: Kia EV6
        color_icon: true
        display_zero: true
        unit_of_measurement: "%"
    dashboard_link: /energy
    w_decimals: 0
    kw_decimals: 1
    min_flow_rate: 3
    max_flow_rate: 6
    watt_threshold: 10000
    clickable_entities: true
    
    

    Der SOC-Trick (State of Charge)

    Damit das funktioniert, muss das Haus wissen, wie voll der Auto-Akku ist. Da unsere Wallbox (SMA) das nicht aus dem Kabel auslesen kann (das können die wenigsten AC-Lader), greifen wir auf die Cloud der Autos zu.

    Wir nutzen die Kia Uvo / Bluelink Integration (aus dem Marketplace, früher HACS) in Home Assistant.

    • Das Auto funkt seinen Akkustand an die Kia-Cloud.
    • Home Assistant holt ihn ab.
    • EVCC nutzt diesen Wert, um zu wissen: „Akku ist bei 79%, ich brauche nur noch 1% laden.“

    Pro-Tipp für die Konfiguration:

    Früher musste man alles mühsam in der evcc.yaml Datei schreiben. In den neueren Versionen (die wir nutzen), läuft fast alles über die Benutzeroberfläche des Add-ons. Die Konfiguration wird in einer Datenbank (evcc.db) gespeichert. Das macht den Einstieg viel leichter!

    Fazit: Lohnt sich der Aufwand?

    Definitiv. Durch die Kombination aus PV-Überschuss im Sommer und Tibber-Tiefpreisen im Winter fahren wir unsere beiden E-Autos zu einem Bruchteil der Benzinkosten. Und das Beste: Es passiert vollautomatisch. Ich stecke das Auto an, und das Haus entscheidet, wann der Strom fließt.

    Nutzt ihr auch schon dynamische Tarife oder ladet ihr noch „dumm“? Schreibt es mir in die Kommentare!


    Passend dazu: Energie-Cockpit: PV, Akku und Strompreis · Strompreis und Akku auf der AWTRIX-Uhr

    Neue Beiträge zuerst bekommen? Zweimal pro Woche, sonntags und mittwochs, kommt ein neuer Baustein aus unserem Haus – kostenlos per Mail, abbestellen mit einem Klick.

    Gefällt dir das?

    Alle Anleitungen hier sind kostenlos. Wenn sie dir beim Laden ein paar Euro sparen, freue ich mich über einen Kaffee:

    Unterstütze mich auf Ko-fi

    * Empfehlungslink: Wechselst du über den Link zu Tibber, bekommen wir beide eine Prämie – für dich ändert sich am Preis nichts.

  • Schluss mit Sauna-Feeling: Wie Home Assistant deine Beschattung im Sommer komplett autonom regelt

    Schluss mit Sauna-Feeling: Wie Home Assistant deine Beschattung im Sommer komplett autonom regelt

    Dieser Beitrag enthält Affiliate-Links (mit * gekennzeichnet).

    Update Oktober 2026: Die komplette Logik gibt es jetzt als Blueprint – ohne YAML, ohne Entitäten umbenennen, für jede Hausseite in zwei Minuten eingerichtet. Direkt zu Schritt 3 ↓

    Hand aufs Herz: Wer von euch rennt im Sommer auch ständig durchs Haus, um Rollos runterzulassen, wenn die Sonne knallt? Und wer zieht sie genervt wieder hoch, sobald sich eine Wolke davorschiebt, nur um sie 10 Minuten später wieder runterzulassen?

    Dieses „Rollladen-Jo-Jo“ nervt nicht nur, es verschleißt auch die Motoren.

    In unserer Smart-Home-Dokumentation ist die automatische Beschattung eines der absoluten Highlights. Sie sorgt dafür, dass die Hitze gar nicht erst ins Haus kommt – und zwar vollautomatisch, vorausschauend und ohne nervöses Auf und Ab.

    Heute zeige ich euch Schritt für Schritt, wie wir das gelöst haben und wie ihr die Logik für eure Südseite (oder jede andere Seite) in einer einzigen, sauberen Automation nachbaut.

    Die Rollos steuern bei uns Shelly Plus 2PM* – sie fahren jede Position in Prozent an, und Home Assistant findet sie im Netzwerk von selbst.

    Das Problem: Warum Helligkeitssensoren allein nicht reichen

    Die meisten einfachen Smart-Home-Lösungen nutzen einen simplen Helligkeitssensor:

    • Sonne hell -> Rollo runter.
    • Wolke kommt -> Rollo hoch.

    Das Ergebnis ist Unruhe. Ein echtes Smart Home muss schlauer sein. Unsere Lösung basiert daher auf vier Faktoren, die alle gleichzeitig zutreffen müssen:

    1. Sonnenstand (Azimut & Elevation): Steht die Sonne überhaupt so, dass sie ins Fenster scheinen kann?
    2. Temperatur: Ist es im Raum (oder draußen) überhaupt warm genug, dass wir Schatten brauchen? (Bei uns messen Aqara-Temperatursensoren* die Räume.) Im Winter wollen wir die Sonne ja zum Heizen nutzen.
    3. Bewölkung: Ist der Himmel klar genug, dass die Sonne Kraft hat?
    4. Der „Input Boolean“ (Der Clou!): Das System bekommt ein Gedächtnis. Es merkt sich: „Ich habe heute schon beschattet.“ Wenn das Rollo einmal unten ist, bleibt es unten – auch bei vorübergehenden Wolken. Erst wenn die Sonne weg ist, fährt es hoch.

    Kleines Lexikon der Fachbegriffe

    Bevor wir in den Code springen, kurz die wichtigsten Begriffe, damit wir vom Gleichen sprechen:

    • Azimut (Azimuth): Die Himmelsrichtung der Sonne in Grad.
      • 0° = Norden | 90° = Osten | 180° = Süden | 270° = Westen.
    • Elevation: Der Höhenwinkel der Sonne über dem Horizont.
      • Wir nutzen das, damit die Rollos nicht schon bei Sonnenaufgang (0°) runterfahren, sondern erst, wenn die Sonne Kraft hat (z.B. > 20°).
    • Input Boolean (Helfer): Ein virtueller Schalter in Home Assistant. Wir nutzen ihn als Merker („Gedächtnis“), um den Status der Automatik zu speichern.

    Schritt 1: Daten sammeln

    Woher wisst ihr, welche Winkel für EUER Fenster gelten?

    Ich empfehle das Tool Sonnenverlauf.de.

    1. Sucht eure Adresse.
    2. Platziert den Pin genau vor das Fenster.
    3. Schaut, in welchem Winkelbereich (Azimut) die Sonne auf die Fassade trifft.

    Beispielwerte für eine klassische Südseite:

    • Start (Azimut): 130° (Süd-Ost, Sonne kommt rum)
    • Ende (Azimut): 250° (Süd-West, Sonne ist weg)
    • Höhe (Elevation): > 20° (Sonne steht hoch genug)

    Schritt 2: Den „Helfer“ anlegen

    Wir brauchen einen Schalter, der sich merkt, ob die Automatik heute schon aktiv war.

    Geht in Home Assistant zu:

    Einstellungen -> Geräte & Dienste -> Tab Helfer -> Helfer erstellen -> Schalter (Input Boolean).

    • Name: Sonnenschutz Süd Gedächtnis
    • Entitäts-ID: input_boolean.sonnenschutz_sud_gedachtnis

    Schritt 3: Die Automation – jetzt mit einem Klick

    Am einfachsten mit dem Blueprint:

    1. Importieren:
      In Home Assistant importieren
    2. Unter Einstellungen → Automationen & Szenen → Blueprints Sonnenschutz je Fassade öffnen.
    3. Rollos der Hausseite, die Winkel aus Schritt 1 und den Helfer aus Schritt 2 eintragen. Temperatur und Bewölkung sind optional. Speichern.

    Hat’s geklappt? Wenn dir der Blueprint Zeit spart, freue ich mich über einen Kaffee ☕.

    Neue Blueprints zuerst bekommen? Zweimal pro Woche, sonntags und mittwochs, kommt ein neuer Baustein aus unserem Haus – kostenlos per Mail, abbestellen mit einem Klick.

    Zwei Dinge macht der Blueprint noch besser als mein YAML unten: Rollos, die ihr selbst ganz geschlossen habt, bleiben zu – und abends fährt er nur die Rollos hoch, die noch auf der Beschattungs-Position stehen. Alle Felder erklärt die Anleitung auf GitHub.

    Lieber selbst bauen?

    Früher hatte ich dafür drei Automationen (Runter, Hoch, Reset). Dank moderner Home Assistant Features (Trigger-IDs) packen wir heute alles in eine einzige, saubere Datei. Das hält das System übersichtlich.

    Hier ist der komplette YAML-Code. Ihr könnt ihn kopieren, eine neue Automation erstellen, oben rechts auf die drei Punkte klicken, „Als YAML bearbeiten“ wählen und einfügen.

    WICHTIG: Passt die Entitäten (Sensoren, Rollos) an eure Namen an!

    alias: "Sonnenschutz - Südseite (Komplettsteuerung)"
    description: "Regelt Beschattung, Wiedereröffnung und Reset intelligent in einer Automation."
    mode: single
    
    # --- DIE AUSLÖSER (TRIGGERS) ---
    trigger:
      # 1. Check zum Runterfahren (Wir prüfen alle 15 Min)
      # Warum alle 15 Min? Damit das Rollo nicht sofort zuckt, wenn ein Wert kurz schwankt.
      - platform: time_pattern
        minutes: "/15"
        id: "check_shading"
    
      # 2. Check zum Hochfahren (Sonne ist weg)
      # Wenn der Azimut größer als 250° ist, ist die Sonne an der Südseite vorbei.
      - platform: numeric_state
        entity_id: sun.sun
        attribute: azimuth
        above: 250
        id: "sun_gone"
    
      # 3. Reset für den nächsten Tag (Mitternacht)
      - platform: time
        at: "00:00:00"
        id: "daily_reset"
    
    # --- DIE MACHE (ACTIONS) ---
    action:
      - choose:
          # --- OPTION A: Runterfahren ---
          # Logik: Ist es Zeit zu prüfen? UND war das Rollo noch nicht unten? UND passen die Wetterdaten?
          - conditions:
              - condition: trigger
                id: "check_shading"
              # Gedächtnis prüfen: Nur fahren, wenn heute noch NICHT beschattet wurde
              - condition: state
                entity_id: input_boolean.sonnenschutz_sud_gedachtnis
                state: "off"
              # Sonnen-Winkel prüfen (Südseite)
              - condition: numeric_state
                entity_id: sun.sun
                attribute: azimuth
                above: 130
                below: 250
              # Sonnen-Höhe prüfen
              - condition: numeric_state
                entity_id: sun.sun
                attribute: elevation
                above: 20
              # Temperatur prüfen (z.B. Innentemperatur > 23 Grad)
              - condition: numeric_state
                entity_id: sensor.wohnzimmer_temperatur
                above: 23
              # Bewölkung prüfen (z.B. weniger als 30% Wolken laut Wetterbericht)
              - condition: numeric_state
                entity_id: weather.home
                attribute: cloud_coverage
                below: 30
            sequence:
              # Rollo auf 30% fahren (Beschattung)
              - service: cover.set_cover_position
                target:
                  entity_id: cover.wohnzimmer_rollo_sued
                data:
                  position: 30
              # WICHTIG: Das Gedächtnis einschalten!
              - service: input_boolean.turn_on
                target:
                  entity_id: input_boolean.sonnenschutz_sud_gedachtnis
    
          # --- OPTION B: Hochfahren ---
          # Logik: Sonne ist weg? UND waren wir automatisch unten? Dann hoch!
          - conditions:
              - condition: trigger
                id: "sun_gone"
              # Sicherheits-Check: Nur hochfahren, wenn die Automatik auch aktiv war.
              # Das verhindert, dass das Rollo hochfährt, wenn ihr es manuell bedient habt.
              - condition: state
                entity_id: input_boolean.sonnenschutz_sud_gedachtnis
                state: "on"
            sequence:
              - service: cover.open_cover
                target:
                  entity_id: cover.wohnzimmer_rollo_sued
    
          # --- OPTION C: Reset ---
          # Logik: Neuer Tag, neues Glück. Gedächtnis löschen.
          - conditions:
              - condition: trigger
                id: "daily_reset"
            sequence:
              - service: input_boolean.turn_off
                target:
                  entity_id: input_boolean.sonnenschutz_sud_gedachtnis
    
    

    Dashboard-Pop-up Rollladensteuerung
    Unsere Rollo-Steuerung im Dashboard: jedes Zimmer und jede Hausseite auf einen Blick – Nord, Süd und West werden jeweils als Gruppe beschattet. Die Rollo-Karte hättest du gern zum Nachbauen? Schreib es in die Kommentare – was gefragt ist, stelle ich als Nächstes bereit.

    Warum diese Methode besser ist

    1. Kein Jo-Jo-Effekt: Durch den input_boolean (Gedächtnis) fährt das Rollo maximal einmal pro Tag automatisch herunter. Wenn danach Wolken kommen, bleibt es sicher unten und kühlt weiter.
    2. Manuelle Kontrolle behalten: Wenn ihr das Rollo manuell wieder hochfahrt, bleibt der Helfer trotzdem auf „On“. Die Automatik weiß also: „Ich habe meinen Job heute erledigt“ und funkt euch nicht mehr dazwischen.
    3. Energieeffizienz: Im Winter könnt ihr einfach die Bedingung für die Innentemperatur anpassen (oder die Automation deaktivieren), um die Sonne zum kostenlosen Heizen zu nutzen.

    Habt ihr Fragen zur Einrichtung oder nutzt ihr eine andere Logik? Schreibt es mir in die Kommentare!


    Viel Spaß beim Nachbauen und kühlen Kopf bewahren!

    Passend dazu: Energie-Cockpit: PV, Akku und Strompreis · Tour durch unser Dashboard

    Gefällt dir das?

    Der Blueprint ist kostenlos. Wenn er dir im Sommer ein paar Grad spart, freue ich mich über einen Kaffee:

    Unterstütze mich auf Ko-fi

    * Affiliate-Links: Kaufst du darüber, bekomme ich eine kleine Provision – für dich ändert sich am Preis nichts. Als Amazon-Partner verdiene ich an qualifizierten Verkäufen.