Urlaubssimulation mit Home Assistant

Anwesenheit realistisch simulieren statt nur Lampen zufällig schalten!

Wer in den Urlaub fährt, kennt den Tipp: „Lass abends mal ein Licht an.“ Eine Zeitschaltuhr macht das, aber sie macht es jeden Abend gleich. Wer von der Straße aus ein paar Tage zuschaut, erkennt das Muster sofort. Bei mir lief dafür lange ein Haufen Zufalls-Automationen: Lampe an, Lampe aus, irgendwann dazwischen. Das war besser als nichts, aber es sah nicht aus wie ein Haushalt.

In diesem Beitrag zeige ich dir meinen Weg zu einer Anwesenheitssimulation, die wie ein Abend im Haus aussieht: von den alten Zufallsregeln über ein Script mit gewichteter Raumwahl bis zur jetzigen Lösung, bei der Home Assistant jeden Abend einen kompletten Fahrplan berechnet und abarbeitet. Dazwischen steht die Auswertung eines echten Testlaufs, der gezeigt hat, was bei mir noch falsch lief. Das komplette Package und das Dashboard findest du im Beitrag.

⚠️ Wichtiger Hinweis: Eine Anwesenheitssimulation ist ein Baustein, kein Einbruchschutz. Sie ersetzt weder Alarmanlage noch aufmerksame Nachbarn oder Schlösser. Sie macht ein leeres Haus nur etwas weniger auffällig.


Urlaubssimulation

📷 Dashboard-Karte Urlaubssimulation


🔧 Ausgangslage

Mein Haus hat mehrere Ebenen, und nicht jedes Licht ist von der Straße aus zu sehen. Das ist wichtig, denn eine Simulation hat nur dann Wirkung, wenn man sie von draußen auch bemerkt. Dazu kommt: Wir sind zu zweit. Ein glaubwürdiger Abend heißt also, dass zwei Personen unabhängig voneinander durchs Haus gehen. Das sind die Lampen, die ich einbezogen habe:

BereichLampenVon der Straße sichtbar?
Wohnzimmer (1. OG)Stehlampe, LED-Streifen an Schränken, LED-Streifen am Fernseher✅ ja
Schlafzimmer (1. OG)Nachttischlampe Person 1, Nachttischlampe Person 2✅ ja
Flur (1. OG)Flurlicht✅ ja
Büro 1 (Spitzboden)Leuchtkugel, Decke✅ ja
Büro 2 (Spitzboden)Schreibtischlampe, Decke✅ ja
AußenTreppenhaus, Haustür, Garten vorne (Freisitz), Garten hinten, Lichterkette Freisitzje nach Standort

Geschaltet wird mit Shelly-Schaltern und WLAN-Steckdosen. Eine Besonderheit sind die beiden Deckenlichter im Spitzboden: Die Shellys geben dort nur einen Impuls auf den Taster. Home Assistant weiß also nicht, ob das Licht gerade an oder aus ist. Dazu später mehr.

🎯 Die Ziele

  • ✅ Jeder Abend sieht anders aus, folgt aber einem glaubwürdigen Muster
  • ✅ Von Sonnenuntergang bis zum Abendende ist immer mindestens ein Licht im Haus an
  • ✅ Im Dashboard einstellbar: Welche Lampen machen mit, wie aktiv ist der Abend, wann ist Schluss
  • ✅ Nach dem Abend gibt es ein Protokoll per E-Mail, damit ich prüfen kann, was wirklich passiert ist
  • ❌ Keine Lampe, die nach dem Ende noch brennt

🧠 Die Entwicklung: Drei Anläufe

Anlauf 1: Acht Zufalls-Automationen

Am Anfang stand für fast jede Lampe eine eigene Automation mit zufälliger Wartezeit. Das Problem: Jede Lampe weiß nichts von den anderen. Mal ist alles gleichzeitig an, mal ist das ganze Haus dunkel. Es gibt keinen „Jemand geht von Raum zu Raum“-Effekt. Acht Regeln, die sich gegenseitig nicht kennen, sind außerdem schwer zu pflegen.

Anlauf 2: Ein Script, gewichtete Räume, zwei Personen

Der nächste Schritt war ein zentrales Script, das ein Haushalt nachahmt: Es wählt Räume mit unterschiedlicher Wahrscheinlichkeit (das Wohnzimmer deutlich häufiger als der Flur), lässt die Person eine Weile dort „sitzen“ und wechselt dann. Später kamen zwei Personen dazu, die parallel laufen, eine unten und eine im Spitzboden. Das war schon ein großer Fortschritt, und ich hatte ein Dashboard mit Schaltern pro Raum, einer Simulationsstärke und einer einstellbaren Endzeit.

Der Testlauf: Was die E-Mail verraten hat

Ich habe die Simulation einen Abend lang laufen lassen (Start 17:53 Uhr, Ende auf 21:00 Uhr eingestellt). Die Protokoll-Mail zeigt jeden einzelnen Schaltvorgang mit Uhrzeit: 124 Schaltvorgänge, am Ende war alles aus. Technisch lief also alles sauber. Beim Nachrechnen der Brenndauer sah das Bild aber ganz anders aus, als ich mir einen echten Abend vorstelle:

LichtGesamt anAuffälligkeit
Wohnzimmer (Stehlampe)2 h 45passt, aber mit 23 Minuten Lücke
Büro 2ca. 2 hdrei Blöcke, zu viel
Büro 1ca. 64 minok
Schlafzimmer13 minnur im Finale nach dem Abendende
Flur9 minvier Mal, längste Phase 3 min 24 s
Treppenhaus20 min15 Mal, teils im Minutenabstand
Hauseingang6 min 45 s11 Mal
Lichterkette4,5 minsechs Mal unter einer Minute

Was daran nicht stimmt, sieht man erst, wenn man sich vorstellt, was jemand von der Straße aus sieht:

  • 🪔 Die Lichterkette im Garten brennt in Summe nur viereinhalb Minuten. Wer eine Lichterkette hat, schaltet sie an und lässt sie eine Stunde laufen.
  • 🚪 Der Flur wird nur kurz „durchlaufen“, während man ihn real oft lange an lässt.
  • 🛏️ Das Schlafzimmer kam erst am Ende und nur für 13 Minuten. Im echten Leben geht man über den Abend immer mal hinein.
  • 🔦 Das Außenlicht flackert im Minutentakt. Zwischen 19:51 und 20:00 Uhr gab es neun Schaltungen. So sieht kein Bewegungsmelder aus, so sieht ein Defekt aus.
  • ⚡ Um 20:38 Uhr war der Hauseingang vier Sekunden an, kurz danach null Sekunden. Ursache: Zwei getrennte Abläufe (ein Gang nach draußen und ein Zufallsimpuls) schalten dieselbe Lampe und schalten sich gegenseitig aus.
  • ⏱️ Beide Personen starteten in derselben Sekunde (17:53:10). Das passiert im echten Leben nie.

Zufall ist nicht dasselbe wie Realismus. Wenn mehrere unabhängige Abläufe zufällig schalten, entstehen genau die Muster, die kein Mensch erzeugen würde.

Anlauf 3: Der Fahrplan

Aus dem Testlauf habe ich ein anderes Konzept abgeleitet. Statt dass viele Abläufe parallel würfeln, berechnet Home Assistant beim Start einmal den ganzen Abend: eine Liste mit Schaltzeitpunkten, bei der alle Zeiten und Dauern zufällig sind, die aber einem festen Muster folgt. Danach arbeitet ein einziges Script die Liste nacheinander ab. Weil es nur noch einen Ablauf gibt, können sich Lampen nicht mehr gegenseitig ausschalten, und ich kann vorher festlegen, dass zum Beispiel immer ein Licht brennt.

Der Entscheidungsverlauf auf einen Blick

AnlaufIdeeErgebnis
1Pro Lampe eine Zufalls-Automation❌ Lampen kennen sich nicht, kein „durchs Haus gehen“
2Ein Script, gewichtete Räume, zwei Personen⚠️ Gut, aber parallele Abläufe: Überschneidungen, zu kurze Dauern
3Fahrplan: Abend vorab berechnen und abarbeiten✅ Umgesetzt

🗓️ Das Muster eines Abends

S ist der Start (Sonnenuntergang minus 30 Minuten plus 0 bis 20 Minuten Zufall), E das Abendende. E ist der Zeitpunkt, an dem das letzte Licht ausgeht. Für Tests stelle ich 21:00 Uhr ein und wenn es wirklich im Einsatz ist wird die Endzeit wohl etwas später sein. Alle Zeiten passen sich an.

BereichMuster
WohnzimmerZu Beginn des Abends 2 bis 3 Stunden. Die Stehlampe brennt durchgehend, die LED-Streifen kommen zufällig später dazu und gehen früher aus. Später folgen kürzere Blöcke zu 30 bis 75 Minuten.
BürosBüro 1 und Büro 2 je 1 bis 2 Blöcke zu 25 bis 35 Minuten. Mitten im Block wechselt die Lampe (Leuchtkugel/Decke bzw. Schreibtischlampe/Decke), es brennt immer nur eine.
Flur2 bis 3 Blöcke zu 45 bis 70 Minuten, gleichmäßig über den Abend verteilt.
Schlafzimmer3 bis 4 Kurzbesuche zu 5 bis 10 Minuten zwischen 19 und 21 Uhr, wahlweise die Lampe von Person 1 oder Person 2. Am Ende ein Finale von 20 bis 30 Minuten: Person 1 zuerst, Person 2 kurz danach, Person 1 geht zuerst aus.
LichterketteEin Block von 60 bis 90 Minuten, Start zufällig, spätestens um 20 Uhr.
Gänge nach draußen2 bis 3 pro Abend mit 30 bis 45 Minuten Abstand. Ablauf: Treppenhaus, Haustür, Garten vorne (in 65 % der Fälle), Garten hinten (in 10 % davon). Jede Lampe ist 30 bis 60 Sekunden an, wie bei einem Bewegungsmelder.

Beispiel: Ein Abend im Winter

So sieht ein berechneter Beispielabend aus (Start 16:20 Uhr, Ende 23:00 Uhr). Das ist ein Ergebnis aus meiner Testrechnung, kein Protokoll eines echten Abends:

16:20-19:17  Wohnzimmer (177 min)
16:41-17:26  Flur (45 min)
17:05        Gang nach draußen
17:47        Gang nach draußen
18:02-19:02  Lichterkette (60 min)
19:09-20:00  Flur (51 min)
19:14-19:40  Büro 1 (26 min)
19:21-19:28  Schlafzimmer-Besuch (7 min)
19:38-20:32  Wohnzimmer (54 min)
19:54-20:00  Schlafzimmer-Besuch (6 min)
20:30-20:55  Büro 1 (25 min)
20:33-20:39  Schlafzimmer-Besuch (6 min)
20:52-21:33  Wohnzimmer (41 min)
21:04-21:54  Flur (50 min)
21:31-21:57  Büro 2 (26 min)
21:55-22:47  Wohnzimmer (52 min)
22:45-23:09  Schlafzimmer-Finale (24 min)

„Immer ein Licht an“ – wie das garantiert wird

Das war eine Vorgabe, die ich nicht dem Zufall überlassen wollte. Deshalb besteht der Fahrplan aus einer Hauptkette: Zuerst das Wohnzimmer, danach wechseln sich Büro und Wohnzimmer ab. Jeder neue Block beginnt 2 bis 3 Minuten, bevor der vorherige endet. Dadurch gibt es zwischen Start und Ende nie einen Moment, in dem alles dunkel ist. Alles andere (Flur, Schlafzimmer-Besuche, Lichterkette, Gänge nach draußen) liegt als Überlagerung darüber und kann die Kette nicht unterbrechen. Wenn zum Ende hin ein Rest übrig bleibt, der für einen neuen Block zu kurz ist, wird der letzte Block einfach verlängert.


⚙️ Die Technik dahinter

Ein Script, zwei Schritte

Das Herz ist script.urlaub_praesenz_abend. Es arbeitet in zwei Schritten:

  1. Berechnen: Aus Startzeit, Endzeit, den freigegebenen Räumen und der Stärke entsteht zuerst eine Liste von Blöcken (Raum, Beginn, Ende) und daraus eine Liste einzelner Schaltzeitpunkte (Lampe, Zeitpunkt, an oder aus). Das passiert in Jinja-Templates im Script, mit range(a, b) | random für alle Zufallswerte.
  2. Abarbeiten: Eine Schleife geht die Liste durch, wartet bis zum nächsten Zeitpunkt und schaltet. Sobald der Urlaubsmodus ausgeschaltet wird, bricht sie ab.

So sieht die Abarbeitungsschleife aus:

- repeat:
    while:
      - condition: state
        entity_id: input_boolean.urlaub_simulation
        state: "on"
      - condition: template
        value_template: "{{ repeat.index <= fahrplan | count }}"
    sequence:
      - variables:
          ev: "{{ fahrplan[repeat.index - 1] }}"
      - delay:
          seconds: "{{ [(ev.t - (now().timestamp() - start_ts | float)) | int, 0] | max }}"
      - choose:
          - conditions: "{{ ev.a == 'set' }}"
            sequence:
              - action: input_text.set_value
                target:
                  entity_id: "{{ ev.e }}"
                data:
                  value: "{{ ev.v }}"
        default:
          - action: script.urlaub_licht_gruppe
            data:
              lights: "{{ [ev.e] }}"
              aktion: "{{ ev.a }}"

💡 Tipp: Die Wartezeit wird nicht als „warte 7 Minuten“ gerechnet, sondern als Abstand zur Startzeit. Dadurch gleicht sich eine kleine Verzögerung bei einem Schaltvorgang beim nächsten Schritt automatisch wieder aus.

Die Impuls-Shellys im Spitzboden

Die Deckenlichter im Spitzboden hängen an Shellys, die nur einen kurzen Impuls auf den Taster geben. Ein turn_off bewirkt dort nichts, und Home Assistant sieht den echten Zustand nicht. Mein Workaround: Für jede Decke gibt es einen Merker (input_boolean). Das Hilfsscript schaltet nur dann per switch.toggle, wenn der gewünschte Zustand vom Merker abweicht, und setzt danach den Merker. Voraussetzung: Die Merker stehen auf „aus“, wenn die Decken aus sind. Die Merker liegen im Dashboard und lassen sich dort korrigieren, falls mal ein Impuls verloren geht.

Stärke, Abendende und Streuung

  • Stärke: „Wenig“, „Normal“ oder „Sehr aktiv“ ändert die Anzahl der Büro-Blöcke, Flur-Phasen, Schlafzimmer-Besuche und Gänge nach draußen und verschiebt das Ende um −45, 0 oder +30 Minuten.
  • Abendende: Ein Zeitwert im Dashboard. Ist er gesetzt, wird das tatsächliche Ende jeden Abend um bis zu ± Streuung Minuten verschoben (bei mir 10), damit es nicht jeden Abend auf die Minute gleich ist.
  • Raumschalter: Jeder Raum hat einen Schalter „… simulieren“. Ausgeschaltete Räume lässt der Fahrplan einfach aus.

Sicherheitsnetze

  • 🛑 Modus aus: Wird der Urlaubsmodus ausgeschaltet, stoppt das Script sofort, und alle Simulationslampen gehen aus.
  • 🌙 Nachtstopp: Zwei Stunden nach dem Abendende werden hängende Scripts beendet und noch brennende Lampen ausgeschaltet.
  • 🧹 Aufräumen: Am Ende des Fahrplans läuft zusätzlich ein „Alles aus“, auch für die Außenbeleuchtung.
  • 🔌 Lichterketten-Automationen: Die normalen Automationen für die Gartenlichterkette werden pausiert, solange der Urlaubsmodus an ist, damit sie nicht dazwischenfunken.

Startet Home Assistant mitten am Abend neu, ist der Fahrplan dieses Abends weg. Der nächste Abend läuft wieder normal an.

Das Protokoll per E-Mail

Ein Template-Sensor hängt jeden Schaltvorgang mit Uhrzeit an eine Liste. Nach dem Abend verschickt ein Script sie als HTML-Tabelle per E-Mail: Start, Abendende, Stärke, Anzahl der Schaltvorgänge, noch brennende Lampen und die komplette Zeitleiste mit ● AN und ○ AUS. Genau diese Mail war die Grundlage für die Auswertung oben. Ohne das Protokoll hätte ich nie gemerkt, dass die Lichterkette nur viereinhalb Minuten gebrannt hat.

💡 Tipp zu Google Mail: Der Benachrichtigungsdienst für Google Mail sendet den Text von message als HTML und ignoriert ein separates HTML-Feld. Die Tabelle steht deshalb direkt in message.

📷 Protokoll-Mail im Postfach


🖥️ Das Dashboard

Die Karte fasst alles zusammen, was ich im Alltag einstelle:

  • Urlaubsmodus an/aus und der aktuelle Status („Aus“, „Wartet auf Abend“, „Läuft“)
  • Start heute und Aktuell aktiv (welcher Raum unten und welcher im Spitzboden gerade brennt)
  • Simulationsstärke, Abendende und Streuung
  • Die Lampenauswahl: je ein Schalter pro Raum bzw. Außenlicht
  • Die beiden Merker für die Impuls-Decken im Spitzboden

📷 Dashboard-Ausschnitt Status und Lampenauswahl

Die Buttons folgen meinem eigenen Style Guide, den ich in einem früheren Beitrag beschrieben habe.


📦 Das komplette Package

Alles liegt in einer Datei: Helfer, Template-Sensoren, Scripts und Automationen. Sie gehört in das Verzeichnis /config/packages/, vorausgesetzt, deine configuration.yaml enthält packages: !include_dir_named packages. Die Entity-IDs der Lampen sind meine, sie musst du an dein System anpassen.

input_boolean:
  urlaub_simulation:
    name: Urlaubsmodus
    icon: mdi:beach
  # Lampenauswahl (Dashboard)
  urlaub_sim_wohnzimmer:
    name: Wohnzimmer simulieren
    icon: mdi:sofa
  urlaub_sim_schlafzimmer:
    name: Schlafzimmer simulieren
    icon: mdi:bed
  urlaub_sim_flur:
    name: Flur simulieren
    icon: mdi:door
  urlaub_sim_treppenhaus:
    name: Treppenhaus simulieren
    icon: mdi:stairs
  urlaub_sim_buero_1:
    name: Büro 1 simulieren
    icon: mdi:desk-lamp
  urlaub_sim_buero_2:
    name: Büro 2 simulieren
    icon: mdi:desk-lamp
  urlaub_sim_hauseingang:
    name: Hauseingang simulieren
    icon: mdi:door-open
  urlaub_sim_garten_vorne:
    name: Garten vorne simulieren
    icon: mdi:outdoor-lamp
  urlaub_sim_garten_hinten:
    name: Garten hinten simulieren
    icon: mdi:outdoor-lamp
  urlaub_sim_lichterkette:
    name: Lichterkette Freisitz simulieren
    icon: mdi:string-lights
  # Merker fuer Impuls-Shellys (Deckenlicht Spitzboden): der Shelly gibt nur einen
  # Impuls auf den Taster, der echte Lichtzustand ist HA unbekannt -> hier merken.
  urlaub_zustand_decke_vorne:
    name: Merker Decke Büro 1 (Impuls)
    icon: mdi:ceiling-light
  urlaub_zustand_decke_hinten:
    name: Merker Decke Büro 2 (Impuls)
    icon: mdi:ceiling-light

input_select:
  urlaub_intensitaet:
    name: Simulationsstärke
    options:
      - Wenig
      - Normal
      - Sehr aktiv
    icon: mdi:chart-bell-curve

input_number:
  urlaub_ende_streuung:
    name: Abendende Streuung (± Minuten)
    min: 0
    max: 30
    step: 1
    mode: box
    unit_of_measurement: min
    initial: 10
    icon: mdi:timer-sand

input_datetime:
  urlaub_abend_ende:
    name: Simulation Abendende
    has_date: false
    has_time: true
  urlaub_start_heute:
    name: Simulation Start heute
    has_date: true
    has_time: true

input_text:
  urlaub_raum_unten:
    name: Simulation Raum unten (EG/1. OG)
    max: 50
  urlaub_raum_oben:
    name: Simulation Raum oben (Spitzboden)
    max: 50

template:
  - sensor:
      - name: "Urlaub Simulation Status"
        unique_id: urlaub_simulation_status
        icon: mdi:home-account
        state: >
          {% if is_state('input_boolean.urlaub_simulation', 'off') %}Aus
          {% elif is_state('script.urlaub_praesenz_abend', 'on') %}Läuft
          {% else %}Wartet auf Abend{% endif %}

  # Protokoll: jeder echte Schaltvorgang einer Simulationslampe wird mit Uhrzeit
  # angehaengt (nur bei Urlaubsmodus an). Reset durch Event urlaub_log_reset
  # (Startautomation). Nach HA-Neustart ist das Protokoll leer.
  - triggers:
      - trigger: state
        id: schalt
        entity_id:
          - switch.stehlampe_wohnzimmer
          - light.wz_licht_schranke
          - light.wz_licht_fernseher
          - switch.steckdose_7_2
          - switch.steckdose_22
          - switch.steckdose_2_switch
          - switch.shelly_licht_treppenhaus
          - switch.steckdose_7
          - switch.a8m_3
          - input_boolean.urlaub_zustand_decke_vorne
          - input_boolean.urlaub_zustand_decke_hinten
          - switch.shelly_licht_hauseingang
          - switch.shelly_licht_freisitz_garten
          - switch.shelly_licht_garage_garten
          - switch.steckdose_14
        from:
          - "on"
          - "off"
        to:
          - "on"
          - "off"
      - trigger: event
        id: reset
        event_type: urlaub_log_reset
      # Beim HA-Start einmal leer anlegen, damit das Attribut "log" immer existiert
      - trigger: homeassistant
        id: reset
        event: start
    conditions:
      - condition: template
        value_template: "{{ trigger.id == 'reset' or is_state('input_boolean.urlaub_simulation', 'on') }}"
    sensor:
      - name: "Urlaub Protokoll"
        unique_id: urlaub_protokoll
        icon: mdi:text-box-clock
        state: "{{ now().strftime('%H:%M:%S') }}"
        attributes:
          log: >-
            {%- if trigger.id == 'reset' -%}
            {%- else -%}
              {%- set alt = (this.attributes.log if this.attributes is defined and this.attributes.log is defined else '') | string -%}
              {%- set namen = {'switch.steckdose_2_switch': 'Licht Flur', 'switch.steckdose_7': 'Lichtkugel Spitzboden', 'switch.a8m_3': 'Schreibtisch-Lampe', 'switch.steckdose_14': 'Gartenbeleuchtung'} -%}
              {%- set name = namen.get(trigger.entity_id, trigger.to_state.name | default(trigger.entity_id)) -%}
              {%- set neu = now().strftime('%H:%M:%S') ~ '  ' ~ name ~ ': ' ~ ('AN' if trigger.to_state.state == 'on' else 'AUS') -%}
              {{ ((alt ~ '\n' ~ neu) if alt else neu)[-12000:] }}
            {%- endif -%}

script:
  # ----------------------------------------------------------------------------
  # Hilfsscript: Lampenliste versetzt schalten (wirkt wie "Hand am Schalter")
  # ----------------------------------------------------------------------------
  urlaub_licht_gruppe:
    alias: "Urlaub: Lampen-Gruppe schalten"
    mode: parallel
    max: 10
    fields:
      lights:
        description: Liste von Entity-IDs
      aktion:
        description: "on oder off"
      pause_min:
        description: Mindestpause zwischen zwei Lampen in Sekunden (Standard 1)
      pause_max:
        description: Höchstpause zwischen zwei Lampen in Sekunden (Standard 12)
    sequence:
      - variables:
          # Impuls-Shellys: Entity -> Merker. Hier nur per switch.toggle schalten.
          impuls_map:
            switch.shelly_licht_spitzboden_vorne: input_boolean.urlaub_zustand_decke_vorne
            switch.shelly_licht_spitzboden_hinten: input_boolean.urlaub_zustand_decke_hinten
      - repeat:
          for_each: "{{ lights }}"
          sequence:
            - choose:
                - conditions: "{{ repeat.item in impuls_map }}"
                  sequence:
                    # Nur toggeln, wenn der gemerkte Zustand vom Wunsch abweicht
                    - if: "{{ is_state(impuls_map[repeat.item], 'on') != (aktion == 'on') }}"
                      then:
                        - action: switch.toggle
                          target:
                            entity_id: "{{ repeat.item }}"
                        - action: "input_boolean.turn_{{ aktion }}"
                          target:
                            entity_id: "{{ impuls_map[repeat.item] }}"
              default:
                - action: "homeassistant.turn_{{ aktion }}"
                  target:
                    entity_id: "{{ repeat.item }}"
            - if: "{{ not repeat.last }}"
              then:
                - delay:
                    seconds: "{{ range(pause_min | default(1) | int, (pause_max | default(12) | int) + 1) | random }}"

  # ----------------------------------------------------------------------------
  # Der Abend: Fahrplan berechnen und abarbeiten
  # ----------------------------------------------------------------------------
  urlaub_praesenz_abend:
    alias: "Urlaub: Abend-Simulation Innenräume"
    icon: mdi:home-account
    mode: single
    fields:
      sofort:
        description: Startverzögerung überspringen (Test)
        default: false
    sequence:
      # Zufaelliger Start nach dem Trigger (jeder Abend beginnt anders)
      - if: "{{ not (sofort | default(false)) }}"
        then:
          - delay:
              minutes: "{{ range(0, 21) | random }}"

      - variables:
          # Staerke: end_shift = Minuten Endzeit; b/f/sv/g = Anzahl [min, max] je Abend
          # (b = Bloecke je Buero, f = Flur-Bloecke, sv = Schlafzimmer-Besuche, g = Gaenge nach draussen)
          intens_map:
            Wenig:
              end_shift: -45
              b: [1, 1]
              f: [2, 2]
              sv: [2, 3]
              g: [2, 2]
            Normal:
              end_shift: 0
              b: [1, 2]
              f: [2, 3]
              sv: [3, 4]
              g: [2, 3]
            Sehr aktiv:
              end_shift: 30
              b: [2, 2]
              f: [3, 3]
              sv: [4, 5]
              g: [3, 3]
          intens: >
            {{ intens_map.get(states('input_select.urlaub_intensitaet'), intens_map['Normal']) }}
          # Welche Lampen/Raeume sind im Dashboard freigegeben?
          an: >-
            {{ {
              'W': is_state('input_boolean.urlaub_sim_wohnzimmer', 'on'),
              'S': is_state('input_boolean.urlaub_sim_schlafzimmer', 'on'),
              'F': is_state('input_boolean.urlaub_sim_flur', 'on'),
              'T': is_state('input_boolean.urlaub_sim_treppenhaus', 'on'),
              'BS': is_state('input_boolean.urlaub_sim_buero_1', 'on'),
              'BR': is_state('input_boolean.urlaub_sim_buero_2', 'on'),
              'H': is_state('input_boolean.urlaub_sim_hauseingang', 'on'),
              'GV': is_state('input_boolean.urlaub_sim_garten_vorne', 'on'),
              'GH': is_state('input_boolean.urlaub_sim_garten_hinten', 'on'),
              'LK': is_state('input_boolean.urlaub_sim_lichterkette', 'on')
            } }}
          start_ts: "{{ now().timestamp() }}"
          streuung: "{{ states('input_number.urlaub_ende_streuung') | int(10) }}"
          # Tatsaechliches Ende (letztes Licht aus): eingestellte Zeit +/- Streuung
          ende_ts: >
            {% set e = today_at(states('input_datetime.urlaub_abend_ende')).timestamp()
               + (range(-(streuung | int), (streuung | int) + 1) | random) * 60 + intens.end_shift * 60 %}
            {{ [e, now().timestamp() + 3600] | max }}
      - variables:
          # Alle Zeiten im Fahrplan in Minuten ab Start
          dm: "{{ ((ende_ts | float - start_ts | float) / 60) | int }}"
          final_len: "{{ (range(20, 31) | random) if an.S else 0 }}"
          c19: "{{ ((today_at('19:00').timestamp() - start_ts | float) / 60) | int }}"
          c20: "{{ ((today_at('20:00').timestamp() - start_ts | float) / 60) | int }}"
          c21: "{{ ((today_at('21:00').timestamp() - start_ts | float) / 60) | int }}"
      - variables:
          fm: "{{ dm - final_len }}"
          n_bs: "{{ (range(intens.b[0], intens.b[1] + 1) | random) if an.BS else 0 }}"
          n_br: "{{ (range(intens.b[0], intens.b[1] + 1) | random) if an.BR else 0 }}"
          n_f: "{{ (range(intens.f[0], intens.f[1] + 1) | random) if an.F else 0 }}"
          n_sv: "{{ (range(intens.sv[0], intens.sv[1] + 1) | random) if an.S else 0 }}"
          n_g: "{{ range(intens.g[0], intens.g[1] + 1) | random }}"

      # --- Bloecke: Hauptkette (lueckenlos), Ueberlagerungen, Gaenge, Lichterkette, Finale ---
      # k = Typ (W Wohnzimmer, BS/BR Buero, F Flur, SV Schlafzimmer-Besuch, FIN Finale,
      #          G Gang nach draussen, LK Lichterkette), s/e = Start/Ende in Minuten
      - variables:
          bloecke: >-
            {%- set w1 = ([range(120, 181) | random, fm - 5] | min) if an.W else 0 -%}
            {#- Ende der Kette: 2 min ueber den Finale-Start hinaus (Ueberlappung), ohne Finale genau bis zum Ende -#}
            {%- set fe = fm + (2 if an.S else 0) -%}
            {%- set ns = namespace(b=[], pos=w1, last=('W' if an.W else ''), nbs=n_bs, nbr=n_br, fin=false) -%}
            {%- if an.W -%}{%- set ns.b = [{'k': 'W', 's': 0, 'e': w1}] -%}{%- endif -%}
            {#- Hauptkette: nach dem Wohnzimmer ein Buero, danach wieder Wohnzimmer usw. -#}
            {%- for i in range(14) -%}
              {%- if not ns.fin -%}
                {%- if fm - ns.pos < 20 -%}
                  {#- Rest zu kurz fuer einen neuen Block: letzten Block bis zum Finale verlaengern -#}
                  {%- if ns.b | count > 0 -%}
                    {%- set l = ns.b[-1] -%}
                    {%- set ns.b = ns.b[:-1] + [{'k': l.k, 's': l.s, 'e': fe}] -%}
                  {%- endif -%}
                  {%- set ns.fin = true -%}
                {%- else -%}
                  {%- set cands = [] -%}
                  {%- if an.W and ns.last != 'W' -%}{%- set cands = cands + ['W'] -%}{%- endif -%}
                  {%- if ns.nbs > 0 and ns.last != 'BS' -%}{%- set cands = cands + ['BS'] -%}{%- endif -%}
                  {%- if ns.nbr > 0 and ns.last != 'BR' -%}{%- set cands = cands + ['BR'] -%}{%- endif -%}
                  {#- nach einem Buero bevorzugt Wohnzimmer, nach dem Wohnzimmer ein Buero -#}
                  {%- if 'W' in cands and cands | count > 1 and (range(0, 100) | random) < 75 -%}
                    {%- set cands = ['W'] -%}
                  {%- elif 'W' in cands and cands | count > 1 -%}
                    {%- set cands = cands | reject('eq', 'W') | list -%}
                  {%- endif -%}
                  {%- if cands | count == 0 -%}
                    {#- nichts Passendes mehr: letzten Block bis zum Finale verlaengern -#}
                    {%- if ns.b | count > 0 -%}
                      {%- set l = ns.b[-1] -%}
                      {%- set ns.b = ns.b[:-1] + [{'k': l.k, 's': l.s, 'e': fe}] -%}
                    {%- endif -%}
                    {%- set ns.fin = true -%}
                  {%- else -%}
                    {%- set typ = cands | random -%}
                    {%- set d = (range(30, 76) | random) if typ == 'W' else (range(25, 36) | random) -%}
                    {%- set ov = (range(2, 4) | random) if ns.pos > 0 else 0 -%}
                    {%- set s = ns.pos - ov -%}
                    {%- if s + d > fm - 15 -%}
                      {%- set e = fe -%}
                      {%- set ns.fin = true -%}
                    {%- else -%}
                      {%- set e = s + d -%}
                    {%- endif -%}
                    {%- set ns.b = ns.b + [{'k': typ, 's': s, 'e': e}] -%}
                    {%- set ns.pos = e -%}
                    {%- set ns.last = typ -%}
                    {%- if typ == 'BS' -%}{%- set ns.nbs = ns.nbs - 1 -%}{%- endif -%}
                    {%- if typ == 'BR' -%}{%- set ns.nbr = ns.nbr - 1 -%}{%- endif -%}
                  {%- endif -%}
                {%- endif -%}
              {%- endif -%}
            {%- endfor -%}
            {#- Flur: gleichmaessig verteilte Slots, je 45-70 min, ueberlagert die Kette -#}
            {%- set n = [n_f, ((fm - 20) / 55) | int] | min -%}
            {%- if n > 0 -%}
              {%- set sw = ((fm - 20) / n) | int -%}
              {%- for i in range(n) -%}
                {%- set d = [range(45, 71) | random, sw - 3] | min -%}
                {%- set s = 20 + i * sw + (range(1, sw - d) | random) -%}
                {%- set ns.b = ns.b + [{'k': 'F', 's': s, 'e': s + d}] -%}
              {%- endfor -%}
            {%- endif -%}
            {#- Schlafzimmer-Kurzbesuche zwischen 19 und 21 Uhr -#}
            {%- set lo = [c19, 30] | max -%}
            {%- set hi = [c21, fm - 15] | min -%}
            {%- set n = [n_sv, ((hi - lo) / 15) | int] | min -%}
            {%- if n > 0 -%}
              {%- set sw = ((hi - lo) / n) | int -%}
              {%- for i in range(n) -%}
                {%- set d = [range(5, 11) | random, sw - 3] | min -%}
                {%- set s = lo + i * sw + (range(1, sw - d) | random) -%}
                {%- set ns.b = ns.b + [{'k': 'SV', 's': s, 'e': s + d}] -%}
              {%- endfor -%}
            {%- endif -%}
            {#- Gaenge nach draussen: 30-45 min Abstand -#}
            {#- erster Gang irgendwann im Abend, so dass alle Gaenge noch vor das Ende passen -#}
            {%- set g = namespace(m=(range(15, ([15, dm - 10 - (n_g - 1) * 45] | max) + 1) | random)) -%}
            {%- for i in range(n_g) -%}
              {%- if g.m < dm - 10 -%}
                {%- set ns.b = ns.b + [{'k': 'G', 's': g.m, 'e': g.m + 4}] -%}
              {%- endif -%}
              {%- set g.m = g.m + (range(30, 46) | random) -%}
            {%- endfor -%}
            {#- Lichterkette: 60-90 min, Start spaetestens 20:00 Uhr -#}
            {%- if an.LK -%}
              {%- set d = range(60, 91) | random -%}
              {%- set mx = [[[c20, 10] | max, dm - d - 15] | min, 10] | max -%}
              {%- set s = range(10, mx + 1) | random -%}
              {%- set ns.b = ns.b + [{'k': 'LK', 's': s, 'e': [s + d, dm - 5] | min}] -%}
            {%- endif -%}
            {#- Finale: Schlafengehen bis zum Abendende -#}
            {%- if an.S -%}
              {%- set ns.b = ns.b + [{'k': 'FIN', 's': fm, 'e': dm}] -%}
            {%- endif -%}
            {{ ns.b }}

      # --- Fahrplan: aus den Bloecken die einzelnen Schaltzeitpunkte (t = Sekunden ab Start) ---
      - variables:
          fahrplan: >-
            {%- set ns = namespace(ev=[]) -%}
            {%- for b in bloecke -%}
              {%- set dur = b.e - b.s -%}
              {%- if b.k == 'W' -%}
                {%- set ns.ev = ns.ev + [
                  {'t': b.s * 60, 'e': 'input_text.urlaub_raum_unten', 'a': 'set', 'v': 'Wohnzimmer'},
                  {'t': b.s * 60, 'e': 'input_text.urlaub_raum_oben', 'a': 'set', 'v': ''},
                  {'t': b.s * 60 + (range(0, 31) | random), 'e': 'switch.stehlampe_wohnzimmer', 'a': 'on'},
                  {'t': b.e * 60 + (range(0, 31) | random), 'e': 'switch.stehlampe_wohnzimmer', 'a': 'off'}] -%}
                {%- if dur > 12 -%}
                  {%- for lamp in ['light.wz_licht_schranke', 'light.wz_licht_fernseher'] -%}
                    {%- set so = range(0, ([10, dur // 4] | min) + 1) | random -%}
                    {%- set eo = range(0, ([25, dur // 3] | min) + 1) | random -%}
                    {%- set ns.ev = ns.ev + [
                      {'t': (b.s + so) * 60 + (range(0, 31) | random), 'e': lamp, 'a': 'on'},
                      {'t': (b.e - eo) * 60 + (range(0, 31) | random), 'e': lamp, 'a': 'off'}] -%}
                  {%- endfor -%}
                {%- endif -%}
              {%- elif b.k in ['BS', 'BR'] -%}
                {%- set ls = ['switch.steckdose_7', 'switch.shelly_licht_spitzboden_vorne'] if b.k == 'BS' else ['switch.a8m_3', 'switch.shelly_licht_spitzboden_hinten'] -%}
                {%- set l1 = ls | random -%}
                {%- set l2 = ls | reject('eq', l1) | list | first -%}
                {%- set ns.ev = ns.ev + [
                  {'t': b.s * 60, 'e': 'input_text.urlaub_raum_oben', 'a': 'set', 'v': 'Büro 1' if b.k == 'BS' else 'Büro 2'},
                  {'t': b.s * 60, 'e': 'input_text.urlaub_raum_unten', 'a': 'set', 'v': ''},
                  {'t': b.s * 60 + (range(0, 31) | random), 'e': l1, 'a': 'on'}] -%}
                {#- Lampenwechsel mitten im Block (neue an, alte kurz danach aus) -#}
                {%- if dur >= 20 and (range(0, 100) | random) < 60 -%}
                  {%- set m = (b.s + range(8, dur - 7) | random) * 60 + (range(0, 31) | random) -%}
                  {%- set ns.ev = ns.ev + [
                    {'t': m, 'e': l2, 'a': 'on'},
                    {'t': m + (range(2, 7) | random), 'e': l1, 'a': 'off'},
                    {'t': b.e * 60 + (range(0, 31) | random), 'e': l2, 'a': 'off'}] -%}
                {%- else -%}
                  {%- set ns.ev = ns.ev + [{'t': b.e * 60 + (range(0, 31) | random), 'e': l1, 'a': 'off'}] -%}
                {%- endif -%}
              {%- elif b.k == 'F' -%}
                {%- set ns.ev = ns.ev + [
                  {'t': b.s * 60 + (range(0, 31) | random), 'e': 'switch.steckdose_2_switch', 'a': 'on'},
                  {'t': b.e * 60 + (range(0, 31) | random), 'e': 'switch.steckdose_2_switch', 'a': 'off'}] -%}
              {%- elif b.k == 'SV' -%}
                {%- set lamp = ['switch.steckdose_7_2', 'switch.steckdose_22'] | random -%}
                {%- set ns.ev = ns.ev + [
                  {'t': b.s * 60 + (range(0, 31) | random), 'e': lamp, 'a': 'on'},
                  {'t': b.e * 60 + (range(0, 31) | random), 'e': lamp, 'a': 'off'}] -%}
              {%- elif b.k == 'FIN' -%}
                {#- Person 1 zuerst, Person 2 kurz danach; Person 1 geht zuerst aus -#}
                {%- set ns.ev = ns.ev + [
                  {'t': b.s * 60, 'e': 'input_text.urlaub_raum_unten', 'a': 'set', 'v': 'Schlafzimmer'},
                  {'t': b.s * 60, 'e': 'input_text.urlaub_raum_oben', 'a': 'set', 'v': ''},
                  {'t': b.s * 60 + (range(0, 31) | random), 'e': 'switch.steckdose_7_2', 'a': 'on'},
                  {'t': (b.s + (range(2, 6) | random)) * 60, 'e': 'switch.steckdose_22', 'a': 'on'},
                  {'t': (b.e - (range(4, 9) | random)) * 60, 'e': 'switch.steckdose_7_2', 'a': 'off'},
                  {'t': b.e * 60, 'e': 'switch.steckdose_22', 'a': 'off'}] -%}
              {%- elif b.k == 'LK' -%}
                {%- set ns.ev = ns.ev + [
                  {'t': b.s * 60 + (range(0, 31) | random), 'e': 'switch.steckdose_14', 'a': 'on'},
                  {'t': b.e * 60 + (range(0, 31) | random), 'e': 'switch.steckdose_14', 'a': 'off'}] -%}
              {%- elif b.k == 'G' -%}
                {#- Gang: Treppenhaus -> Hauseingang -> Freisitz (65 %) -> hinterer Garten (10 %); je Lampe 30-60 s -#}
                {%- set t = namespace(v=b.s * 60 + (range(0, 31) | random)) -%}
                {%- if an.T -%}
                  {%- set d = range(30, 61) | random -%}
                  {%- set ns.ev = ns.ev + [{'t': t.v, 'e': 'switch.shelly_licht_treppenhaus', 'a': 'on'}, {'t': t.v + d, 'e': 'switch.shelly_licht_treppenhaus', 'a': 'off'}] -%}
                  {%- set t.v = t.v + d + (range(0, 5) | random) -%}
                {%- endif -%}
                {%- if an.H -%}
                  {%- set d = range(30, 61) | random -%}
                  {%- set ns.ev = ns.ev + [{'t': t.v, 'e': 'switch.shelly_licht_hauseingang', 'a': 'on'}, {'t': t.v + d, 'e': 'switch.shelly_licht_hauseingang', 'a': 'off'}] -%}
                  {%- set t.v = t.v + d -%}
                {%- endif -%}
                {%- if an.GV and (range(0, 100) | random) < 65 -%}
                  {%- set t.v = t.v + (range(5, 21) | random) -%}
                  {%- set d = range(30, 61) | random -%}
                  {%- set ns.ev = ns.ev + [{'t': t.v, 'e': 'switch.shelly_licht_freisitz_garten', 'a': 'on'}, {'t': t.v + d, 'e': 'switch.shelly_licht_freisitz_garten', 'a': 'off'}] -%}
                  {%- set t.v = t.v + d -%}
                  {%- if an.GH and (range(0, 100) | random) < 10 -%}
                    {%- set t.v = t.v + (range(10, 31) | random) -%}
                    {%- set d = range(30, 61) | random -%}
                    {%- set ns.ev = ns.ev + [{'t': t.v, 'e': 'switch.shelly_licht_garage_garten', 'a': 'on'}, {'t': t.v + d, 'e': 'switch.shelly_licht_garage_garten', 'a': 'off'}] -%}
                  {%- endif -%}
                {%- endif -%}
              {%- endif -%}
            {%- endfor -%}
            {{ ns.ev | sort(attribute='t') }}

      - action: input_datetime.set_datetime
        target:
          entity_id: input_datetime.urlaub_start_heute
        data:
          datetime: "{{ now().strftime('%Y-%m-%d %H:%M:%S') }}"

      # --- Fahrplan abarbeiten (bricht ab, sobald der Urlaubsmodus aus ist) ---
      - repeat:
          while:
            - condition: state
              entity_id: input_boolean.urlaub_simulation
              state: "on"
            - condition: template
              value_template: "{{ repeat.index <= fahrplan | count }}"
          sequence:
            - variables:
                ev: "{{ fahrplan[repeat.index - 1] }}"
            - delay:
                seconds: "{{ [(ev.t - (now().timestamp() - start_ts | float)) | int, 0] | max }}"
            - choose:
                - conditions: "{{ ev.a == 'set' }}"
                  sequence:
                    - action: input_text.set_value
                      target:
                        entity_id: "{{ ev.e }}"
                      data:
                        value: "{{ ev.v }}"
              default:
                - action: script.urlaub_licht_gruppe
                  data:
                    lights: "{{ [ev.e] }}"
                    aktion: "{{ ev.a }}"

      # --- Ende: Anzeige leeren, Sicherheitsnetz (Nacht = alles aus) ---
      - action: input_text.set_value
        target:
          entity_id:
            - input_text.urlaub_raum_unten
            - input_text.urlaub_raum_oben
        data:
          value: ""
      - if:
          - condition: state
            entity_id: input_boolean.urlaub_simulation
            state: "on"
        then:
          - action: script.urlaub_alles_aus
            data:
              aussen: true
      # Protokoll per E-Mail
      - action: script.turn_on
        target:
          entity_id: script.urlaub_protokoll_senden

  # ----------------------------------------------------------------------------
  # Protokoll aller Schaltvorgaenge per E-Mail
  # ----------------------------------------------------------------------------
  urlaub_protokoll_senden:
    alias: "Urlaub: Protokoll per E-Mail senden"
    icon: mdi:email-fast
    mode: single
    sequence:
      # Warten, bis die Simulation fertig ist (max. 1 h)
      - wait_template: >
          {{ not is_state('script.urlaub_praesenz_abend', 'on') }}
        timeout: "01:00:00"
        continue_on_timeout: true
      - delay: 5
      # Lampenliste vorab berechnen (getrennt vom Mailtext, damit ein Fehler hier nie den Versand verhindert)
      - variables:
          lampen_an: >-
            {%- set ns = namespace(an=[]) -%}
            {%- for e in ['switch.stehlampe_wohnzimmer','light.wz_licht_schranke','light.wz_licht_fernseher','switch.steckdose_7_2','switch.steckdose_22','switch.steckdose_2_switch','switch.shelly_licht_treppenhaus','switch.steckdose_7','switch.a8m_3','switch.shelly_licht_hauseingang','switch.shelly_licht_freisitz_garten','switch.shelly_licht_garage_garten','switch.steckdose_14'] -%}
              {%- if is_state(e, 'on') -%}
                {%- set namen = {'switch.steckdose_2_switch': 'Licht Flur', 'switch.steckdose_7': 'Lichtkugel Spitzboden', 'switch.a8m_3': 'Schreibtisch-Lampe', 'switch.steckdose_14': 'Gartenbeleuchtung'} -%}
                {%- set ns.an = ns.an + [namen.get(e, state_attr(e, 'friendly_name') | default(e))] -%}
              {%- endif -%}
            {%- endfor -%}
            {{ ns.an | join(', ') if ns.an | count > 0 else 'keine' }}
      # Protokollzeilen lesbar aufbereiten: "11:33:54  Lampe: AN" -> "11:33:54   ● AN    Lampe"
      - variables:
          log_zeilen: >-
            {%- set raw = state_attr('sensor.urlaub_protokoll', 'log') | default('', true) | string -%}
            {%- set ns = namespace(z=[]) -%}
            {%- for l in raw.split('\n') if l | trim != '' -%}
              {%- set t = l[:8] -%}
              {%- set rest = l[10:] -%}
              {%- if ': ' in rest -%}
                {%- set teile = rest.rsplit(': ', 1) -%}
                {%- set sym = '● AN ' if teile[1] == 'AN' else '○ AUS' -%}
                {%- set ns.z = ns.z + ['  ' ~ t ~ '   ' ~ sym ~ '   ' ~ teile[0]] -%}
              {%- else -%}
                {%- set ns.z = ns.z + ['  ' ~ l] -%}
              {%- endif -%}
            {%- endfor -%}
            {{ ns.z | join('\n') if ns.z | count > 0 else '  (keine Einträge)' }}
          anzahl: >-
            {{ (state_attr('sensor.urlaub_protokoll', 'log') | default('', true) | string).split('\n') | reject('eq', '') | list | count }}
          letzte: >-
            {%- set z = (state_attr('sensor.urlaub_protokoll', 'log') | default('', true) | string).split('\n') | reject('eq', '') | list -%}
            {{ z[-1][:8] if z | count > 0 else '–' }}
          # HTML-Tabellenzeilen fuer die Zeitleiste (Mail-Clients verschlucken Leerzeichen/Umbrueche im Reintext)
          log_html: >-
            {%- set raw = state_attr('sensor.urlaub_protokoll', 'log') | default('', true) | string -%}
            {%- for l in raw.split('\n') if l | trim != '' -%}
              {%- set rest = l[10:] -%}
              {%- if ': ' in rest -%}
                {%- set teile = rest.rsplit(': ', 1) -%}
                {%- set an = teile[1] == 'AN' -%}
                <tr><td style="padding:2px 12px 2px 0;color:#666;font-family:Consolas,monospace">{{ l[:8] }}</td><td style="padding:2px 12px 2px 0;color:{{ '#1a7f37' if an else '#999' }};font-weight:bold;white-space:nowrap">{{ '● AN' if an else '○ AUS' }}</td><td style="padding:2px 0">{{ teile[0] | e }}</td></tr>
              {%- else -%}
                <tr><td colspan="3" style="padding:2px 0">{{ l | e }}</td></tr>
              {%- endif -%}
            {%- endfor -%}
      - action: notify.DEIN_MAILDIENST
        metadata: {}
        continue_on_error: true
        data:
          target: [email protected]
          title: "Urlaubssimulation Protokoll {{ now().strftime('%d.%m.%Y') }}"
          # Google Mail sendet "message" als HTML und ignoriert data.html
          message: >-
              <div style="font-family:Segoe UI,Arial,sans-serif;font-size:14px;color:#222">
              <h2 style="margin:0 0 4px 0">Urlaubssimulation – Protokoll</h2>
              <div style="color:#666;margin-bottom:12px">{{ now().strftime('%d.%m.%Y') }}</div>
              <table style="border-collapse:collapse;margin-bottom:12px">
              <tr><td style="padding:2px 16px 2px 0;color:#666">Start</td><td>{{ states('input_datetime.urlaub_start_heute')[11:19] }} Uhr</td></tr>
              <tr><td style="padding:2px 16px 2px 0;color:#666">Abendende</td><td>{{ states('input_datetime.urlaub_abend_ende')[:5] }} Uhr (± {{ states('input_number.urlaub_ende_streuung') | int(10) }} min)</td></tr>
              <tr><td style="padding:2px 16px 2px 0;color:#666">Stärke</td><td>{{ states('input_select.urlaub_intensitaet') }}</td></tr>
              <tr><td style="padding:2px 16px 2px 0;color:#666">Schaltvorgänge</td><td><b>{{ anzahl }}</b></td></tr>
              <tr><td style="padding:2px 16px 2px 0;color:#666">Letzte Schaltung</td><td>{{ letzte }} Uhr</td></tr>
              <tr><td style="padding:2px 16px 2px 0;color:#666">Noch an</td><td>{{ lampen_an }}</td></tr>
              </table>
              <h3 style="margin:0 0 6px 0">Zeitleiste</h3>
              <table style="border-collapse:collapse">{{ log_html }}</table>
              </div>

  # ----------------------------------------------------------------------------
  # Alles aus (Sicherheitsnetz / Stopp)
  # ----------------------------------------------------------------------------
  urlaub_alles_aus:
    alias: "Urlaub: Simulationslampen ausschalten"
    icon: mdi:lightbulb-off
    mode: queued
    fields:
      aussen:
        description: Auch Außenlichter ausschalten
        default: false
    sequence:
      - action: homeassistant.turn_off
        target:
          entity_id:
            - switch.stehlampe_wohnzimmer
            - light.wz_licht_schranke
            - light.wz_licht_fernseher
            - switch.steckdose_7_2
            - switch.steckdose_22
            - switch.steckdose_2_switch
            - switch.shelly_licht_treppenhaus
            - switch.steckdose_7
            - switch.a8m_3
      # Impuls-Shellys (Decke Spitzboden): nur toggeln, wenn laut Merker an
      - if: "{{ is_state('input_boolean.urlaub_zustand_decke_vorne', 'on') }}"
        then:
          - action: switch.toggle
            target:
              entity_id: switch.shelly_licht_spitzboden_vorne
          - action: input_boolean.turn_off
            target:
              entity_id: input_boolean.urlaub_zustand_decke_vorne
      - if: "{{ is_state('input_boolean.urlaub_zustand_decke_hinten', 'on') }}"
        then:
          - action: switch.toggle
            target:
              entity_id: switch.shelly_licht_spitzboden_hinten
          - action: input_boolean.turn_off
            target:
              entity_id: input_boolean.urlaub_zustand_decke_hinten
      - if: "{{ aussen | default(false) }}"
        then:
          - action: homeassistant.turn_off
            target:
              entity_id:
                - switch.shelly_licht_hauseingang
                - switch.shelly_licht_freisitz_garten
                - switch.shelly_licht_garage_garten
                - switch.steckdose_14
      - action: input_text.set_value
        target:
          entity_id:
            - input_text.urlaub_raum_unten
            - input_text.urlaub_raum_oben
        data:
          value: ""

automation:
  # ----------------------------------------------------------------------------
  # Start: kurz vor Sonnenuntergang (Zufallsverzoegerung steckt im Script)
  # ----------------------------------------------------------------------------
  - id: urlaub_sim_start
    alias: "Urlaub: Simulation starten (Sonnenuntergang)"
    triggers:
      - trigger: sun
        event: sunset
        # 30 min vorher + bis zu 20 min Zufall im Script: erstes Licht spaetestens kurz vor Sonnenuntergang
        offset: "-00:30:00"
    conditions:
      - condition: state
        entity_id: input_boolean.urlaub_simulation
        state: "on"
    actions:
      # Protokoll des neuen Abends beginnt leer
      - event: urlaub_log_reset
      - delay: 1
      - action: script.turn_on
        target:
          entity_id: script.urlaub_praesenz_abend
    mode: single

  # ----------------------------------------------------------------------------
  # Sicherheitsnetz: 2 h nach Abendende muss alles aus sein (haengende Scripts
  # werden beendet, Protokoll trotzdem gesendet)
  # ----------------------------------------------------------------------------
  - id: urlaub_sim_nachtstopp
    alias: "Urlaub: Nachtstopp (Abendende + 2 h)"
    triggers:
      - trigger: time
        at:
          entity_id: input_datetime.urlaub_abend_ende
          offset: "+02:00:00"
    conditions:
      - condition: state
        entity_id: input_boolean.urlaub_simulation
        state: "on"
    actions:
      - action: script.turn_off
        target:
          entity_id:
            - script.urlaub_praesenz_abend
            - script.urlaub_licht_gruppe
      - delay: 1
      - action: script.urlaub_alles_aus
        data:
          aussen: true
      - action: script.turn_on
        target:
          entity_id: script.urlaub_protokoll_senden
    mode: single

  # ----------------------------------------------------------------------------
  # Stopp: Urlaubsmodus ausgeschaltet -> laufende Simulation beenden, Lampen aus
  # ----------------------------------------------------------------------------
  - id: urlaub_sim_stopp
    alias: "Urlaub: Simulation stoppen (Modus aus)"
    triggers:
      - trigger: state
        entity_id: input_boolean.urlaub_simulation
        to: "off"
    actions:
      - if:
          - condition: or
            conditions:
              - condition: state
                entity_id: script.urlaub_praesenz_abend
                state: "on"
        then:
          - action: script.turn_off
            target:
              entity_id:
                - script.urlaub_praesenz_abend
                - script.urlaub_licht_gruppe
          - delay: 1
          - action: script.urlaub_alles_aus
            data:
              aussen: true
    mode: single

  # ----------------------------------------------------------------------------
  # Normale Lichterketten-Automationen: pausieren, solange Urlaubsmodus an ist
  # (Entity-IDs aus den Aliasnamen abgeleitet, bitte in HA pruefen)
  # ----------------------------------------------------------------------------
  - id: urlaub_sim_lichterkette_umschalten
    alias: "Urlaub: Lichterketten-Automationen pausieren"
    triggers:
      - trigger: state
        entity_id: input_boolean.urlaub_simulation
        to:
          - "on"
          - "off"
      - trigger: homeassistant
        event: start
    actions:
      # stop_actions gibt es nur bei automation.turn_off, daher zwei getrennte Zweige
      - choose:
          - conditions:
              - condition: state
                entity_id: input_boolean.urlaub_simulation
                state: "on"
            sequence:
              - action: automation.turn_off
                target:
                  entity_id:
                    - automation.lichterkette_garten_ein
                    - automation.lichterkette_garten_aus
                data:
                  stop_actions: false
        default:
          - action: automation.turn_on
            target:
              entity_id:
                - automation.lichterkette_garten_ein
                - automation.lichterkette_garten_aus
    mode: restart

Beim Anpassen musst du an diesen Stellen eingreifen:

  • Lampen: Die Entity-IDs im Abschnitt bloecke/fahrplan und in urlaub_alles_aus sowie die Trigger-Liste des Protokoll-Sensors
  • E-Mail: Dienst und Empfänger in urlaub_protokoll_senden (bei mir notify.… für Google Mail)
  • Lichterketten-Automationen: Die IDs, die pausiert werden sollen, oder den Block löschen, wenn du keine hast
  • Impuls-Shellys: Wenn du nur normale Schalter hast, brauchst du die Merker und die Zuordnung impuls_map nicht

Und hier noch der YAML-Code für die Dashboardkarte:

type: vertical-stack
cards:
  - type: markdown
    content: '## 🏠 Anwesenheitssimulation'
  - square: false
    type: grid
    columns: 1
    cards:
      - type: custom:button-card
        show_state: true
        entity: input_boolean.urlaub_simulation
        name: Urlaubsmodus
        icon: mdi:beach
        tap_action:
          action: toggle
        hold_action:
          action: more-info
        state_display: '[[[ return entity.state === ''on'' ? ''aktiv'' : ''aus''; ]]]'
        styles:
          card:
            - height: 60px
            - padding: 6px 10px
            - border-radius: 10px
            - cursor: pointer
            - background: |
                [[[ return entity.state === 'on' ? '#2e7d32' : '#c62828'; ]]]
            - border: >
                [[[ return entity.state === 'on' ? '2px solid #ffffff' : '2px
                solid #c62828'; ]]]
          grid:
            - grid-template-areas: '"i n" "i s"'
            - grid-template-columns: 32px auto
            - align-items: center
            - justify-items: start
            - column-gap: 8px
          icon:
            - width: 22px
            - height: 22px
            - color: '#ffffff'
          name:
            - font-size: 14px
            - font-weight: 600
            - color: '#ffffff'
          state:
            - font-size: 14px
            - font-weight: bold
            - color: '#ffffff'
  - square: false
    type: grid
    columns: 2
    cards:
      - type: custom:button-card
        show_state: true
        entity: sensor.urlaub_simulation_status
        name: Status
        icon: mdi:home-account
        tap_action:
          action: none
        double_tap_action:
          action: none
        styles:
          card:
            - height: 60px
            - padding: 6px 10px
            - border-radius: 10px
            - border: 1px solid rgba(255,255,255,0.2)
            - background: '#4a148c'
            - cursor: default
          grid:
            - grid-template-areas: '"i n" "i s"'
            - grid-template-columns: 32px auto
            - align-items: center
            - justify-items: start
          icon:
            - width: 22px
            - height: 22px
            - color: '#ce93d8'
          name:
            - font-size: 14px
            - font-weight: 600
            - color: '#ce93d8'
          state:
            - font-size: 14px
            - font-weight: bold
            - color: '#ffffff'
      - type: custom:button-card
        show_state: true
        entity: input_datetime.urlaub_start_heute
        name: Start heute
        icon: mdi:clock-start
        tap_action:
          action: none
        double_tap_action:
          action: none
        state_display: >
          [[[ const v = entity.state; return (!v || v === 'unknown') ? '–' :
          v.substring(11, 16); ]]]
        styles:
          card:
            - height: 60px
            - padding: 6px 10px
            - border-radius: 10px
            - border: 1px solid rgba(255,255,255,0.2)
            - background: '#4a148c'
            - cursor: default
          grid:
            - grid-template-areas: '"i n" "i s"'
            - grid-template-columns: 32px auto
            - align-items: center
            - justify-items: start
          icon:
            - width: 22px
            - height: 22px
            - color: '#ce93d8'
          name:
            - font-size: 14px
            - font-weight: 600
            - color: '#ce93d8'
          state:
            - font-size: 14px
            - font-weight: bold
            - color: '#ffffff'
  - type: custom:button-card
    show_state: true
    entity: input_text.urlaub_raum_unten
    name: Aktuell aktiv
    icon: mdi:lightbulb-on
    tap_action:
      action: none
    double_tap_action:
      action: none
    state_display: |
      [[[
        const u = entity.state;
        const o = states['input_text.urlaub_raum_oben'] ? states['input_text.urlaub_raum_oben'].state : '';
        const l = [u, o].filter(x => x && !['unknown', 'unavailable'].includes(x));
        return l.length ? l.join(' + ') : '–';
      ]]]
    styles:
      card:
        - height: 60px
        - padding: 6px 10px
        - border-radius: 10px
        - border: 1px solid rgba(255,255,255,0.2)
        - background: '#4a148c'
        - cursor: default
      grid:
        - grid-template-areas: '"i n" "i s"'
        - grid-template-columns: 32px auto
        - align-items: center
        - justify-items: start
      icon:
        - width: 22px
        - height: 22px
        - color: '#ce93d8'
      name:
        - font-size: 14px
        - font-weight: 600
        - color: '#ce93d8'
      state:
        - font-size: 14px
        - font-weight: bold
        - color: '#ffffff'
  - type: markdown
    content: >-
      **Simulationsstärke** (Tipp = nächste Stufe) · **Abendende** ·
      **Streuung** (Ende ± Minuten, täglich zufällig)
  - type: grid
    columns: 3
    square: false
    cards:
      - type: custom:button-card
        show_state: true
        entity: input_select.urlaub_intensitaet
        icon: mdi:chart-bell-curve
        name: Stärke
        tap_action:
          action: call-service
          service: input_select.select_next
          data:
            entity_id: input_select.urlaub_intensitaet
            cycle: true
        hold_action:
          action: more-info
        styles:
          card:
            - height: 60px
            - padding: 6px 10px
            - border-radius: 10px
            - border: 1px solid rgba(255,255,255,0.2)
            - background: |
                [[[ const s = entity.state;
                    return s === 'Wenig' ? '#1565c0' : (s === 'Normal' ? '#f9a825' : '#c62828'); ]]]
          grid:
            - grid-template-areas: '"i n" "i s"'
            - grid-template-columns: 32px auto
            - align-items: center
            - justify-items: start
          icon:
            - width: 22px
            - height: 22px
            - color: '#ffffff'
          name:
            - font-size: 14px
            - font-weight: 600
            - color: '#ffffff'
          state:
            - font-size: 14px
            - font-weight: bold
            - color: '#ffffff'
      - type: custom:button-card
        show_state: true
        entity: input_datetime.urlaub_abend_ende
        name: Abendende
        icon: mdi:clock-end
        tap_action:
          action: more-info
        double_tap_action:
          action: none
        state_display: |
          [[[
            const v = entity.state;
            if (!v || ['unknown', 'unavailable'].includes(v)) return '–';
            return v.substring(0, 5) + ' Uhr';
          ]]]
        styles:
          card:
            - height: 60px
            - padding: 6px 10px
            - border-radius: 10px
            - border: 1px solid rgba(255,255,255,0.2)
            - background: '#1565c0'
            - cursor: pointer
          grid:
            - grid-template-areas: '"i n" "i s"'
            - grid-template-columns: 32px auto
            - align-items: center
            - justify-items: start
            - column-gap: 8px
          icon:
            - width: 22px
            - height: 22px
            - color: '#90caf9'
          name:
            - font-size: 14px
            - font-weight: 600
            - color: '#90caf9'
            - justify-self: start
            - text-align: left
          state:
            - font-size: 14px
            - font-weight: bold
            - color: '#ffffff'
            - justify-self: start
            - text-align: left
      - type: custom:button-card
        show_state: true
        entity: input_number.urlaub_ende_streuung
        name: Streuung
        icon: mdi:timer-sand
        tap_action:
          action: more-info
        double_tap_action:
          action: none
        state_display: |
          [[[
            const v = entity.state;
            if (!v || ['unknown', 'unavailable'].includes(v)) return '–';
            return '± ' + parseInt(v) + ' min';
          ]]]
        styles:
          card:
            - height: 60px
            - padding: 6px 10px
            - border-radius: 10px
            - border: 1px solid rgba(255,255,255,0.2)
            - background: '#1565c0'
            - cursor: pointer
          grid:
            - grid-template-areas: '"i n" "i s"'
            - grid-template-columns: 32px auto
            - align-items: center
            - justify-items: start
            - column-gap: 8px
          icon:
            - width: 22px
            - height: 22px
            - color: '#90caf9'
          name:
            - font-size: 14px
            - font-weight: 600
            - color: '#90caf9'
            - justify-self: start
            - text-align: left
          state:
            - font-size: 14px
            - font-weight: bold
            - color: '#ffffff'
            - justify-self: start
            - text-align: left
  - type: markdown
    content: '**Lampenauswahl** (Tipp = mitmachen / nicht mitmachen)'
  - type: grid
    columns: 2
    square: false
    cards:
      - type: custom:button-card
        entity: input_boolean.urlaub_sim_wohnzimmer
        name: Wohnzimmer
        icon: mdi:sofa
        template: urlaub_lampe
      - type: custom:button-card
        entity: input_boolean.urlaub_sim_schlafzimmer
        name: Schlafzimmer
        icon: mdi:bed
        template: urlaub_lampe
      - type: custom:button-card
        entity: input_boolean.urlaub_sim_flur
        name: Flur
        icon: mdi:door
        template: urlaub_lampe
      - type: custom:button-card
        entity: input_boolean.urlaub_sim_treppenhaus
        name: Treppenhaus
        icon: mdi:stairs
        template: urlaub_lampe
      - type: custom:button-card
        entity: input_boolean.urlaub_sim_buero_1
        name: Büro 1
        icon: mdi:desk-lamp
        template: urlaub_lampe
      - type: custom:button-card
        entity: input_boolean.urlaub_sim_buero_2
        name: Büro 2
        icon: mdi:desk-lamp
        template: urlaub_lampe
      - type: custom:button-card
        entity: input_boolean.urlaub_sim_hauseingang
        name: Hauseingang
        icon: mdi:door-open
        template: urlaub_lampe
      - type: custom:button-card
        entity: input_boolean.urlaub_sim_lichterkette
        name: Lichterkette
        icon: mdi:string-lights
        template: urlaub_lampe
      - type: custom:button-card
        entity: input_boolean.urlaub_sim_garten_vorne
        name: Garten vorne
        icon: mdi:outdoor-lamp
        template: urlaub_lampe
      - type: custom:button-card
        entity: input_boolean.urlaub_sim_garten_hinten
        name: Garten hinten
        icon: mdi:outdoor-lamp
        template: urlaub_lampe
  - type: markdown
    content: >-
      **Merker Decke Spitzboden** (nur korrigieren, wenn Licht und Merker nicht
      übereinstimmen)
  - type: grid
    columns: 2
    square: false
    cards:
      - type: custom:button-card
        entity: input_boolean.urlaub_zustand_decke_vorne
        name: Decke Büro 1
        icon: mdi:ceiling-light
        template: urlaub_lampe
      - type: custom:button-card
        entity: input_boolean.urlaub_zustand_decke_hinten
        name: Decke Büro 2
        icon: mdi:ceiling-light
        template: urlaub_lampe

🧪 Getestet, bevor es in Home Assistant lief

Weil ein Abend mit Test-Run in Home Assistant mehrere Stunden dauert, habe ich die Berechnung des Fahrplans außerhalb von Home Assistant getestet. Die Jinja-Templates aus dem Package habe ich in Python mit der Jinja-Bibliothek gerendert, jeweils mit Zufall, und das Ergebnis automatisch geprüft. Insgesamt waren das über 4.000 berechnete Abende in zehn Szenarien: Winter von 16:20 bis 23:00 Uhr in allen drei Stärken, der Testabend 17:53 bis 21:00 Uhr, ein Sommerabend, ein Mini-Abend von einer Stunde und Läufe mit abgeschaltetem Wohnzimmer, Schlafzimmer oder Büros.

Geprüft wurde jedes Mal:

  • ✅ Keine Lampe wird zweimal hintereinander eingeschaltet oder ausgeschaltet
  • ✅ Zu jedem Zeitpunkt ist mindestens eine Innenlampe an
  • ✅ Das letzte Licht geht zum Abendende aus, und am Ende ist nichts mehr an
  • ✅ Außenlampen brennen 30 bis 60 Sekunden
  • ✅ Flur-Blöcke dauern mindestens 45 Minuten, die Lichterkette 60 bis 90 Minuten und startet spätestens um 20 Uhr
  • ✅ Die Gänge nach draußen liegen 30 bis 45 Minuten auseinander

Der erste Durchlauf hat tatsächlich einen Fehler gefunden: Wenn das Schlafzimmer abgeschaltet war, lief die letzte Kette zwei Minuten über das Ende hinaus, weil sie auf ein Finale gewartet hat, das es nicht gab. Das war nach der Korrektur weg. Ein Test in der echten Anlage ersetzt das nicht, aber die Logik steht damit.


🚀 Einbau und erster Test

  1. Die Datei urlaub_simulation.yaml nach /config/packages/ legen (eine eventuelle ältere Fassung vorher sichern).
  2. Unter Entwicklerwerkzeuge → YAML die Konfiguration prüfen und Home Assistant neu starten (neue Helfer brauchen einen Neustart).
  3. Kontrollieren, dass es script.urlaub_praesenz_abend gibt. Home Assistant bildet Script-Entity-IDs manchmal aus dem Alias-Namen. Dann musst du sie auf die Package-ID umbenennen.
  4. Helfer setzen: Abendende (für den Test z. B. 21:00 Uhr), Stärke „Normal“, die gewünschten Räume einschalten, beide Decken-Merker auf „aus“.
  5. Urlaubsmodus einschalten und das Script mit sofort: true starten. Dann überspringt es die zufällige Startverzögerung.
  6. Nach dem Abend die Protokoll-Mail prüfen: durchgehend ein Innenlicht, Außenlicht 30 bis 60 Sekunden, Gänge im Abstand von 30 bis 45 Minuten, nichts mehr an.

Was noch möglich wäre

  • 🎬 Fernseher: Passend zum Wohnzimmer-Block ein Smart-TV oder Soundbar einschalten
  • 🪟 Rollläden abends gestaffelt schließen und morgens öffnen
  • 🌅 Sonnenaufgang: Ein kurzer Morgen-Fahrplan mit Bad und Küche
  • 📲 Push statt E-Mail mit Kurzfassung des Protokolls aufs Handy

✅ Fazit und Lessons Learned

Aus „irgendwelche Lampen schalten zufällig“ ist ein Ablauf geworden, der sich wie ein Abend im Haus verhält. Der wichtigste Schritt war nicht eine neue Technik, sondern die ehrliche Auswertung eines Testlaufs. Das nehme ich mit:

  • 📧 Ohne Protokoll weißt du nicht, was deine Simulation tut. Die E-Mail mit jedem Schaltvorgang war das wertvollste Werkzeug im ganzen Projekt.
  • 🎲 Zufall ist nicht Realismus. Wer glaubwürdig wirken will, braucht ein Muster mit Zufall in Zeit und Dauer, nicht Zufall in allem.
  • 🧮 Ein Ablauf statt vieler. Sobald mehrere Abläufe dieselbe Lampe schalten, entstehen Kurzimpulse und Überschneidungen. Ein einziger Fahrplan vermeidet das von Grund auf.
  • 🛡️ Regeln durch Aufbau garantieren, nicht durch Hoffnung. „Immer ein Licht an“ klappt, weil sich die Blöcke überlappen, nicht weil der Zufall es meistens hinbekommt.
  • 🧪 Logik außerhalb von Home Assistant testen. Templates lassen sich in Python tausendfach durchrechnen und automatisch prüfen. Das spart viele Abende Testbetrieb.
  • 🔦 Impuls-Schalter brauchen einen Merker. Wenn du den echten Zustand nicht kennst, musst du ihn dir selbst merken und das ehrlich im Dashboard zeigen.

Wie simulierst du Anwesenheit? Nutzt du eine Zeitschaltuhr, Zufallsregeln oder etwas Eigenes? Schreib es mir gern in die Kommentare.


Wenn dir dieses DIY-Projekt gefallen hat, schau dir auch meine weiteren Smart-Home- und Home-Assistant-Projekte an. Dort findest du viele weitere Ideen zum Nachbauen.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen