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.

📷 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:
| Bereich | Lampen | Von 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ßen | Treppenhaus, Haustür, Garten vorne (Freisitz), Garten hinten, Lichterkette Freisitz | je 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:
| Licht | Gesamt an | Auffälligkeit |
|---|---|---|
| Wohnzimmer (Stehlampe) | 2 h 45 | passt, aber mit 23 Minuten Lücke |
| Büro 2 | ca. 2 h | drei Blöcke, zu viel |
| Büro 1 | ca. 64 min | ok |
| Schlafzimmer | 13 min | nur im Finale nach dem Abendende |
| Flur | 9 min | vier Mal, längste Phase 3 min 24 s |
| Treppenhaus | 20 min | 15 Mal, teils im Minutenabstand |
| Hauseingang | 6 min 45 s | 11 Mal |
| Lichterkette | 4,5 min | sechs 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
| Anlauf | Idee | Ergebnis |
|---|---|---|
| 1 | Pro Lampe eine Zufalls-Automation | ❌ Lampen kennen sich nicht, kein „durchs Haus gehen“ |
| 2 | Ein Script, gewichtete Räume, zwei Personen | ⚠️ Gut, aber parallele Abläufe: Überschneidungen, zu kurze Dauern |
| 3 | Fahrplan: 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.
| Bereich | Muster |
|---|---|
| Wohnzimmer | Zu 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üros | Bü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. |
| Flur | 2 bis 3 Blöcke zu 45 bis 70 Minuten, gleichmäßig über den Abend verteilt. |
| Schlafzimmer | 3 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. |
| Lichterkette | Ein Block von 60 bis 90 Minuten, Start zufällig, spätestens um 20 Uhr. |
| Gänge nach draußen | 2 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:
- 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) | randomfür alle Zufallswerte. - 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/fahrplanund inurlaub_alles_aussowie die Trigger-Liste des Protokoll-Sensors - E-Mail: Dienst und Empfänger in
urlaub_protokoll_senden(bei mirnotify.…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_mapnicht
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
- Die Datei
urlaub_simulation.yamlnach/config/packages/legen (eine eventuelle ältere Fassung vorher sichern). - Unter Entwicklerwerkzeuge → YAML die Konfiguration prüfen und Home Assistant neu starten (neue Helfer brauchen einen Neustart).
- Kontrollieren, dass es
script.urlaub_praesenz_abendgibt. Home Assistant bildet Script-Entity-IDs manchmal aus dem Alias-Namen. Dann musst du sie auf die Package-ID umbenennen. - 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“.
- Urlaubsmodus einschalten und das Script mit
sofort: truestarten. Dann überspringt es die zufällige Startverzögerung. - 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.