Scripts en scènes — Hergebruik zonder dubbel werk

In het vorige hoofdstuk heb je gezien wat er gebeurt wanneer een automatisering opnieuw wordt gestart terwijl een eerdere uitvoering nog bezig is. Dat lijkt misschien vooral iets technisch, maar het raakt aan een belangrijker onderwerp: hoe je automatiseringen overzichtelijk houdt wanneer ze groter worden.

Een eenvoudige automatisering is meestal goed te begrijpen:

Als er beweging is, doe het licht aan.

Maar na verloop van tijd wil je misschien meer.

Als er beweging is, moeten meerdere lampen aan. Dezelfde lampen moeten ook aan wanneer je thuiskomt. En misschien wil je vanaf het dashboard precies dezelfde verlichting kunnen inschakelen.

Je kunt al die acties steeds opnieuw in iedere automatisering zetten.

Dat werkt.

Maar zodra je later iets wilt veranderen, moet je dezelfde wijziging op meerdere plaatsen uitvoeren.

Home Assistant heeft daar twee hulpmiddelen voor:

scripts voor het hergebruiken van acties;
scènes voor het vastleggen van gewenste toestanden.

Ze lijken op elkaar, maar lossen een ander probleem op.

Eerst het probleem: dezelfde acties op meerdere plaatsen

Stel dat je in De Werkplaats drie lampen hebt:

de plafondlamp;
de lamp boven de werkbank;
een kleine achtergrondlamp.

Wanneer je De Werkplaats binnenkomt, wil je misschien dat deze verlichting wordt ingeschakeld.

Je automatisering zou dan drie acties kunnen bevatten.

Later maak je een tweede automatisering:

Wanneer het donker wordt en ik nog in De Werkplaats bezig ben, schakel dezelfde verlichting in.

Ook daar voeg je dezelfde drie acties toe.

Daarna maak je op het dashboard een knop waarmee je de verlichting handmatig kunt inschakelen.

Weer dezelfde drie acties.

Technisch is daar niets mis mee.

Maar stel dat je later besluit dat de achtergrondlamp niet meer automatisch aan moet.

Dan moet je onthouden dat die lamp op drie verschillende plaatsen wordt aangestuurd.

Dit is precies het soort situatie waarin automatiseringen langzaam moeilijker te onderhouden worden.

Het probleem is dus niet dat Home Assistant het niet kan uitvoeren.

Het probleem is dat jij later nog moet kunnen begrijpen waarom iets gebeurt en waar je het moet aanpassen.

Een script is een herbruikbare reeks acties

Een script kun je zien als een klein programma binnen Home Assistant dat uit één of meer acties bestaat.

Het script heeft geen eigen aanleiding nodig.

Het wacht niet zelf op beweging, een tijdstip of een sensorwaarde.

Een andere automatisering, een dashboardknop of zelfs een ander script kan het starten.

Je kunt bijvoorbeeld een script maken met de naam:

Werkplaatsverlichting inschakelen

Daarin zet je:

plafondlamp aan;
werkbanklamp aan;
achtergrondlamp aan.

Vanaf dat moment hoeven je automatiseringen niet meer afzonderlijk die drie lampen aan te sturen.

Ze hoeven alleen nog maar te zeggen:

Voer het script Werkplaatsverlichting inschakelen uit.

Daarmee heb je de uitvoering op één plaats ondergebracht.

Wil je later een vierde lamp toevoegen?

Dan verander je alleen het script.

Iedere automatisering die het script gebruikt, krijgt automatisch dezelfde nieuwe werkwijze.

Automatisering en script hebben verschillende taken

Het helpt om automatiseringen en scripts verschillende verantwoordelijkheden te geven.

Een automatisering bepaalt meestal:

Wanneer moet er iets gebeuren?

Een script bepaalt:

Wat moet er precies gebeuren?

Dat verschil is belangrijk.

Neem opnieuw De Werkplaats.

De automatisering kan bepalen:

Als de bewegingssensor beweging ziet én het is donker genoeg, start dan het script Werkplaatsverlichting inschakelen.

De automatisering bevat dan de beslissing.

Het script bevat de uitvoering.

Dat maakt beide onderdelen eenvoudiger.

Je hoeft niet iedere automatisering zo op te bouwen. Voor één enkele actie is een apart script vaak onnodig.

Maar wanneer dezelfde reeks acties op meerdere plaatsen voorkomt, is een script het overwegen waard.

Maak een eenvoudig script

Je kunt scripts in Home Assistant beheren via:

Instellingen → Automatiseringen & scènes → Scripts

Maak een nieuw script.

Geef het bijvoorbeeld de naam:

Werkplaatsverlichting inschakelen

Voeg vervolgens de acties toe waarmee je de lampen inschakelt.

Afhankelijk van je apparaten kun je meerdere lampen in één actie selecteren of verschillende acties achter elkaar zetten.

Houd het voor deze oefening eenvoudig.

Gebruik bij voorkeur lampen of schakelaars waarvan je het gedrag al kent.

Voordat je het script opslaat, voorspel je eerst wat er gebeurt wanneer je het uitvoert.

Welke lampen moeten aan?

Moeten ze allemaal tegelijk reageren?

Sla het script daarna op en voer het handmatig uit.

Controleer vervolgens of het resultaat overeenkomt met je voorspelling.

Dat handmatig uitvoeren is nuttig. Je test daarmee het script los van een automatisering.

Als het script niet doet wat je verwacht, hoef je nog niet te onderzoeken of de trigger of voorwaarden van een automatisering misschien verkeerd zijn.

Je hebt het probleem kleiner gemaakt.

Roep het script aan vanuit een automatisering

Nu kun je een bestaande automatisering aanpassen.

Stel dat je eerder een automatisering hebt gemaakt die drie lampen afzonderlijk inschakelt.

Verwijder die drie acties niet meteen allemaal tegelijk.

Verander eerst één onderdeel.

Vervang de bestaande reeks acties door het nieuwe script.

Sla de automatisering op en test opnieuw.

Let daarbij op twee afzonderlijke dingen:

start de automatisering op het juiste moment?
voert het script daarna de juiste acties uit?

Door deze twee vragen uit elkaar te houden, wordt zoeken naar fouten veel eenvoudiger.

Als het script handmatig goed werkt maar vanuit de automatisering niet wordt gestart, weet je dat het probleem waarschijnlijk niet in de lampacties zelf zit.

Scripts zijn niet alleen voor lampen

Een script kan vrijwel iedere reeks acties bevatten die je ook in een automatisering kunt gebruiken.

Denk bijvoorbeeld aan:

meerdere lampen instellen;
een mediaspeler aanzetten en het volume instellen;
een melding versturen;
meerdere schakelaars uitschakelen;
een vertraging gebruiken;
een choose-beslissing uitvoeren;
wachten op een bepaalde toestand.

Je zou bijvoorbeeld een script kunnen maken met de naam:

Werkplaats afsluiten

Dat script kan:

de werkbanklamp uitschakelen;
de plafondlamp uitschakelen;
een slimme stekker uitschakelen;
controleren of een bepaald apparaat nog actief is;
eventueel een melding geven.

Datzelfde script kun je vervolgens starten:

vanaf een dashboardknop;
om 23:00 uur;
wanneer niemand meer in De Werkplaats aanwezig is.

Drie verschillende aanleidingen kunnen zo dezelfde betrouwbare afsluitprocedure gebruiken.

Een scène werkt anders

Een scène lijkt op het eerste gezicht op een script, omdat je er ook meerdere apparaten mee kunt aansturen.

Maar het uitgangspunt is anders.

Een script zegt:

Voer deze acties uit.

Een scène zegt:

Zorg dat deze apparaten deze toestand krijgen.

Dat verschil is klein in woorden, maar belangrijk in gebruik.

Stel dat je voor De Werkplaats een bepaalde verlichting wilt:

plafondlamp aan;
werkbanklamp aan op 80%;
achtergrondlamp aan op 30%.

Je zou daarvoor een script kunnen maken dat deze drie instellingen uitvoert.

Maar eigenlijk beschrijf je hier vooral een gewenste situatie.

Daar is een scène voor bedoeld.

Je kunt bijvoorbeeld een scène maken:

Werkplaats werken

Wanneer je die scène activeert, brengt Home Assistant de opgenomen apparaten naar de ingestelde toestand.

Denk aan een scène als een momentopname

Een handige manier om een scène te begrijpen is als een momentopname van een gewenste situatie.

Bijvoorbeeld:

Scène: Werkplaats werken

plafondverlichting: aan;
werkbanklamp: 80%;
achtergrondverlichting: 30%.

Daarnaast zou je een tweede scène kunnen maken:

Scène: Werkplaats opruimen

plafondverlichting: 100%;
werkbanklamp: 100%;
achtergrondverlichting: uit.

En misschien:

Scène: Werkplaats video opnemen

plafondverlichting: uit;
werkbanklamp: 40%;
achtergrondverlichting: aan.

Je hoeft dan niet telkens na te denken over iedere afzonderlijke lamp.

Je kiest de gewenste situatie.

Scènes veranderen toestanden, maar onthouden geen stappen

Dit is een belangrijk verschil.

Een scène is geen stappenplan.

Een script kan zeggen:

zet lamp A aan;
wacht vijf seconden;
zet lamp B aan;
stuur een melding.

Een scène kan dat niet op dezelfde manier beschrijven.

Een scène legt vooral vast hoe apparaten moeten staan.

Daarom zijn scènes vooral geschikt voor zaken zoals:

verlichting;
helderheid;
kleur;
mediainstellingen;
andere apparaatstatussen die samen één gewenste situatie vormen.

Wanneer volgorde, wachttijden of beslissingen belangrijk zijn, past een script meestal beter.

Script en scène kunnen samenwerken

Je hoeft niet te kiezen tussen scripts óf scènes.

Ze kunnen elkaar juist aanvullen.

Stel dat je een scène hebt:

Werkplaats werken

Daarin staat de gewenste verlichting.

Je kunt vervolgens een script maken:

Werkplaats starten

Dat script doet bijvoorbeeld:

activeer de scène Werkplaats werken;
schakel een slimme stekker in;
wacht twee seconden;
stuur eventueel een melding dat De Werkplaats gereed is.

Nu gebruik je de scène voor de toestand van de verlichting en het script voor de volgorde van de werkzaamheden.

Een automatisering hoeft vervolgens alleen nog te bepalen wanneer het script moet worden gestart.

Je krijgt dan drie duidelijke lagen:

Automatisering

Wanneer moet het gebeuren?

Script

Welke stappen moeten worden uitgevoerd?

Scène

Welke toestand moeten bepaalde apparaten krijgen?

Dat is geen verplicht ontwerpmodel, maar bij grotere automatiseringen kan het veel overzicht geven.

Wanneer maak je géén script?

Hergebruik is nuttig, maar je kunt er ook te ver in gaan.

Stel dat een automatisering maar één ding doet:

Bij beweging: lamp aan.

Dan levert een script met de naam Lamp aanzetten waarschijnlijk weinig voordeel op.

De automatisering wordt er eerder moeilijker door te volgen.

Je moet dan immers vanuit de automatisering naar het script gaan om te ontdekken wat er werkelijk gebeurt.

Een goede vuistregel is daarom:

Maak pas een script wanneer het daadwerkelijk iets vereenvoudigt.

Bijvoorbeeld wanneer:

dezelfde acties op meerdere plaatsen worden gebruikt;
een reeks acties behoorlijk lang wordt;
je die reeks apart wilt kunnen testen;
je de uitvoering los wilt houden van de aanleiding.

Niet iedere herhaalde regel hoeft onmiddellijk te worden weggewerkt.

Begrijpelijkheid blijft belangrijker dan technische netheid.

Geef scripts duidelijke namen

Een naam als:

Script 3

vertelt je over een half jaar vrijwel niets meer.

Ook namen als:

Lampen

of:

Werkplaats

zijn vaak te algemeen.

Gebruik liever namen die beschrijven wat het script doet:

Werkplaatsverlichting inschakelen
Werkplaats afsluiten
Benedenverlichting uitschakelen
Avondmelding versturen
Verwarming tijdelijk verhogen

Datzelfde geldt voor scènes:

Werkplaats werken
Werkplaats opruimen
Woonkamer avond
Woonkamer televisie
Alles beneden helder

Een goede naam bespaart later verrassend veel zoekwerk.

Let ook bij scripts op opnieuw starten

In het vorige hoofdstuk heb je gezien dat een automatisering opnieuw kan worden gestart terwijl een eerdere uitvoering nog bezig is.

Voor scripts speelt iets vergelijkbaars.

Ook een script kan nog bezig zijn wanneer het opnieuw wordt aangeroepen.

Dat wordt vooral belangrijk wanneer een script wachttijden bevat of langere acties uitvoert.

Stel dat een script dit doet:

lamp aan;
tien minuten wachten;
lamp uit.

Als het script tijdens die tien minuten opnieuw wordt gestart, moet Home Assistant weten wat er met de eerdere uitvoering moet gebeuren.

Scripts hebben daarom, net als automatiseringen, een uitvoeringsmodus.

Je herkent onder andere dezelfde ideeën:

één uitvoering tegelijk;
eerdere uitvoering opnieuw starten;
meerdere uitvoeringen naast elkaar;
uitvoeringen achter elkaar plaatsen.

Je hoeft dat nu niet opnieuw volledig uit te werken. Het belangrijkste is dat je beseft dat het probleem uit het vorige hoofdstuk niet verdwijnt zodra je acties naar een script verplaatst.

Een script met wachttijden verdient dezelfde aandacht als een automatisering met wachttijden.

Test een script los van zijn automatisering

Scripts hebben nog een praktisch voordeel: je kunt ze afzonderlijk testen.

Dat maakt foutzoeken overzichtelijker.

Stel dat een automatisering niet goed werkt.

De automatisering bestaat uit:

een bewegingssensor als trigger;
een lichtwaarde als voorwaarde;
het script Werkplaats starten als actie.

Je kunt dan eerst het script handmatig uitvoeren.

Werkt het script goed?

Dan hoef je dat gedeelte voorlopig niet verder te onderzoeken.

Vervolgens kun je kijken naar de automatisering zelf.

Kwam de trigger binnen?

Was de voorwaarde waar?

Werd het script aangeroepen?

Zo werk je van klein naar groot.

Dat is betrouwbaarder dan meerdere onderdelen tegelijk aanpassen.

Maak bewust één fout

Een kleine fout kan helpen om beter te begrijpen hoe de onderdelen samenhangen.

Pas bijvoorbeeld tijdelijk één apparaat in je script aan naar een verkeerd gekozen lamp.

Voer vervolgens het script handmatig uit.

Observeer wat er gebeurt.

Herstel daarna alleen dat ene onderdeel en test opnieuw.

Het doel is niet om fouten te veroorzaken om het fouten maken.

Je leert hiermee waar je moet zoeken wanneer later een echt probleem ontstaat.

Als de verkeerde lamp aangaat terwijl het script handmatig wordt uitgevoerd, weet je dat de fout in het script zit en niet in de trigger van de automatisering.

Wanneer gebruik je een scène en wanneer een script?

Je kunt jezelf een eenvoudige vraag stellen.

Wil je zeggen:

Doe eerst dit en daarna dat?

Gebruik dan meestal een script.

Wil je zeggen:

Zorg dat alles zo staat?

Gebruik dan meestal een scène.

Bij twijfel kun je kijken of volgorde belangrijk is.

Bij een script kan volgorde essentieel zijn.

Bij een scène draait het vooral om het eindresultaat.

Voor De Werkplaats zou dit bijvoorbeeld logisch zijn:

Scène

Zet de verlichting in de stand werken.

Script

Activeer de werkverlichting, schakel de apparatuur in en stuur daarna een melding.

Automatisering

Doe dat wanneer aanwezigheid wordt gedetecteerd en het donker genoeg is.

Zo krijgt ieder onderdeel een duidelijke taak.

Niet alles hoeft in één automatisering

Wanneer je begint met Home Assistant is het verleidelijk om één automatisering steeds verder uit te bouwen.

Eerst komt er een extra lamp bij.

Daarna een melding.

Dan een vertraging.

Dan een choose.

Daarna nog een tweede kamer.

Op een gegeven moment werkt het misschien nog steeds prima, maar wordt begrijpen wat er gebeurt steeds moeilijker.

Scripts en scènes geven je een manier om zo'n grote automatisering op te delen.

Niet omdat Home Assistant anders niet meer werkt, maar omdat jij degene bent die het later moet kunnen onderhouden.

Een goede automatisering is daarom niet alleen een automatisering die vandaag doet wat je wilt.

Je wilt over zes maanden ook nog kunnen begrijpen waarom hij het doet.

Wat je nu hebt geleerd

Je hebt inmiddels verschillende bouwstenen gezien waarmee een automatisering behoorlijk uitgebreid kan worden.

Je kent:

triggers;
voorwaarden;
acties;
choose;
wachttijden en vertragingen;
herhalingen;
uitvoeringsmodi;
scripts;
scènes.

Daarmee kun je al automatiseringen bouwen die veel verder gaan dan alleen:

Als dit gebeurt, zet dan die lamp aan.

Maar er ontbreekt nog iets.

Tot nu toe reageren je automatiseringen vooral op wat Home Assistant op dit moment weet.

Soms wil je echter zelf een instelling kunnen bewaren.

Bijvoorbeeld:

staat de automatische verlichting ingeschakeld?
welke temperatuur wil je gebruiken?
is de woning in vakantiestand?
moet een automatisering tijdelijk worden onderdrukt?
welke bedrijfsmodus heb je gekozen?

Daarvoor heeft Home Assistant helpers.

In het volgende hoofdstuk bekijken we hoe je daarmee je automatiseringen als het ware een klein beetje geheugen en instelbare waarden kunt geven.