Mga Script sa Home Assistant: mga gamit, mode at praktikal na halimbawa

Kung matagal mo nang ginagamit ang Home Assistant, malamang pamilyar ka na sa mga automation, eksena, at grupo, ngunit maaaring hindi ka sigurado kung para saan ang mga script sa Home Assistant o kung kailan ito sulit gamitin . At sayang naman, dahil kapag ginamit nang epektibo, isa ang mga ito sa pinakamabisang tool para masulit ang iyong home automation.

Sa artikulong ito, titingnan natin nang sunud-sunod kung ano ang mga script, paano sila naiiba sa mga automation, kung paano i-configure ang mga ito sa pamamagitan ng graphical interface at paggamit ng YAML kasama ang scripting syntax ng Home Assistant , ang iba't ibang execution mode, kung paano magpasa ng mga variable, kung paano maghintay (o hindi) para matapos ang mga ito, at kung paano i-integrate ang mga ito sa mga eksena, grupo, at zone. Ang layunin ay, sa pagtatapos ng artikulong ito, magkakaroon ka ng malinaw at praktikal na pag-unawa kung paano gamitin ang mga ito sa iyong pang-araw-araw na workflow.

Ano ang script sa Home Assistant at para saan ito ginagamit?

Sa Home Assistant, ang isang script ay karaniwang isang pagkakasunod-sunod ng mga aksyon na tumatakbo sa pagkakasunud-sunod na iyong tinukoy . Hindi sila kusang nagti-trigger: tumatakbo ang mga ito kapag "binuksan mo ang mga ito" (kapag tinawag mo ang script) mula sa interface, mula sa ibang automation, mula sa ibang script, o sa pamamagitan ng isang serbisyo.

Ang integrasyon ng Scripts ay lumilikha ng isang entity para sa bawat script, na may uri na script.your_name . Para sa praktikal na layunin, ang entity na ito ay kumikilos na parang isang bagay na maaari mong i-activate, i-deactivate, o tawagin mula sa mga aksyon, tulad ng gagawin mo sa isang serbisyo tulad ng light.turn_on o switch.turn_off.

Ang maganda sa mga script ay pinapayagan ka nitong isama ang paulit-ulit na lohika: sa halip na kopyahin ang parehong pagkakasunud-sunod ng mga hakbang sa maraming automation , gagawa ka ng isang magagamit muli na script at tatawagin ito mula sa lahat ng mga ito. Pinapasimple nito ang pag-configure, binabawasan ang mga error, at ginagawang mas madali ang pagpapanatili ng iyong system.

Isang simpleng halimbawa: maaari kang magkaroon ng script na humahawak sa "night mode" (pagpatay ng mga ilaw, pagbaba ng mga blinds, pagsasaayos ng heating at pag-activate ng isang mahinang pag-iilaw na eksena) at pagkatapos ay tawagin ang script na iyon mula sa iba't ibang automation : kapag pinindot ang isang pisikal na button, kapag dumating ang isang partikular na oras, o kapag natukoy mong nakatulog na ang lahat.

Mula sa mas teknikal na pananaw, ang mga script ay umaasa sa YAML-based scripting syntax ng Home Assistant , ang parehong pilosopiya na ginagamit ng mga automation, ngunit walang mga trigger. Ikaw ang magpapasya kung kailan ito mati-trigger; ang script lamang ang tumutukoy kung ano ang gagawin at paano.

Mga pagkakaiba sa pagitan ng mga script, automation, eksena, grupo, at zone

Kapag una mong ginamit ang Home Assistant, madaling malito sa mga script, automation, scene, group, at zone, dahil madalas ay tila magkakatulad ang mga ito. Gayunpaman, ang bawat isa ay may partikular na papel sa loob ng ecosystem ng home automation.

Tinutukoy ng mga automation ang "kailan": mayroon silang isa o higit pang mga trigger (oras, pagtukoy ng galaw, pagbabago ng estado, kaganapan, atbp.), mga opsyonal na kondisyon, at isang serye ng mga aksyon. Sa kabilang banda, tinutukoy ng mga script ang "ano" at "paano" —ibig sabihin, ang pagkakasunod-sunod ng mga aksyon —ngunit hindi kung kailan ang mga ito isinasagawa.

Sa kabilang banda, ang mga eksena ay idinisenyo upang mag-iwan ng isang hanay ng mga aparato sa isang partikular na pangwakas na estado: kung aling mga ilaw ang nakabukas, sa anong liwanag at kulay, kung aling mga blinds ang nakataas o nakababa, kung aling kontrol sa klima ang aktibo, atbp. Wala silang conditional logic o mga loop; "pinipinta" lamang nila ang isang paunang natukoy na estado.

Ang mga grupo at sona ay gumagana sa magkaibang antas: pinagsasama-sama ng isang grupo ang magkakatulad na entidad (halimbawa, ilang ilaw sa isang grupo ng ilaw) upang i-on o i-off ang mga ito na parang iisang entidad lamang . Karaniwang ginagamit ang mga sona para sa presensya at geolocation (home zone, work zone, gym zone), para malaman mo kung ang isang device o tao ay nasa loob o labas ng isang partikular na lugar.

Ang karaniwang tanong ay: "Ano ang pinakamahusay na gamitin: mga grupo, sona, o mga eksena?" Hindi talaga sila nagkukumpitensya sa isa't isa; nagpupuno sila sa isa't isa. Tinutukoy ng mga eksena ang mga estado, pinapasimple ng mga grupo ang magkasanib na kontrol, at ginagamit ang mga sona para sa pagtukoy ng lokasyon . Ang mga script ang pangunahing tool para sa pag-oorganisa ng mga kumplikadong daloy ng trabaho, at ang mga automation ang responsable sa pagpapasya kung kailan isasagawa ang mga ito.

Kailan gagamit ng script at kailan gagamit ng automation

Isang karaniwang tanong para sa mga nagsisimula ay kung kailan gagamit ng script at kailan mas mainam ang automation. Sa pangkalahatan, ang automation ay mainam para sa pagtugon sa mga pangyayari (bumukas ang pinto, gumabi, may umuwi), habang ang mga script ay perpekto para sa pagpapaliwanag ng lohikang gusto mong isagawa bilang tugon sa mga pangyayaring iyon.

Kung kailangan mo ng isang bagay na napakasimple, tulad ng pagbukas ng ilaw kapag may natukoy na galaw, malamang ay magagawa mo ito gamit ang isang direktang automation na nagsasagawa ng isa o dalawang aksyon. Ngunit kung ang mga aksyon ay magiging mahaba, na may maraming tawag sa serbisyo, paghihintay, mga panloob na kondisyon, atbp., ang karaniwang paraan ay kunin ang bahaging iyon sa isang hiwalay na script at tawagin na lang ito ng automation.

Isa pang sitwasyon kung saan maganda ang mga script ay kapag gusto mong gamitin muli ang eksaktong parehong pagkakasunod-sunod ng mga aksyon sa maraming lugar. Sa halip na ulitin ang lohikang iyon sa tatlong magkakahiwalay na automation, gagawa ka ng script at tatawagin ito mula sa lahat ng tatlo . Kung sakaling magpasya kang baguhin ang isang bagay, ia-update mo lang ang script, at tapos ka na.

Malaking tulong din ang mga ito kapag nakikipag-ugnayan sa mga panlabas na device o medyo mahirap na serbisyo, kung saan kailangan mo ng ilang magkakaugnay na hakbang, muling pagsubok, paghihintay, o pagsusuri ng katayuan . Ang pagkakaroon ng lahat ng iyan na nakasentro sa isang script ay lubos na nakakatulong sa pag-debug at pagpapanatili ng sistema.

Maaari natin itong ibuod nang ganito: kung ang iyong pangunahing pangangailangan ay "kapag nangyari ang X, gumawa ng isang bagay", magsimula sa automation; kung ang gusto mo ay "gawing kumplikado ang daloy na ito" at maaaring tawagin mula sa maraming lugar, planuhin ito bilang isang script at gamitin muli ito.

Mga paraan upang lumikha ng mga script: graphical interface at YAML

Binibigyang-daan ka ng Home Assistant na lumikha ng mga script sa dalawang paraan: mula sa web interface (ang built-in na script editor) o manu-mano sa mga YAML file. Ang parehong opsyon ay ganap na balido at kadalasang gumagana nang maayos, lalo na kung gusto mong pagsamahin ang visual na kaginhawahan at advanced na flexibility.

Sa interface, maaari kang pumunta sa seksyon ng mga script at lumikha ng bago mula sa simula. Binibigyang-daan ka ng editor na tukuyin ang pangalan, paglalarawan, at icon, pati na rin magdagdag ng mga aksyon sa istilo ng "block" (buksan ang ilaw, maghintay ng X segundo, tawagan ang isang serbisyo, patakbuhin ang isang template, atbp.). Para sa mga hindi pa pamilyar sa syntax ng YAML, ang opsyong ito ang pinaka-madaling gamitin at hindi gaanong madaling magkaroon ng mga error sa pag-format.

Kung mas gusto mo ang kumpletong kontrol, maaari mong isulat ang mga script sa iyong configuration.yaml file o sa isang hiwalay na file na kasama ng !include, halimbawa, gamit ang WSL para sa iyong mga script . Sa YAML, tinutukoy mo ang alias ng script, sequence, modes, fields, at higit pa, at maaari mong gamitin ang buong kapangyarihan ng scripting syntax ng Home Assistant, kabilang ang mga template ng Jinja para sa advanced logic.

Anuman ang paraan, ang Home Assistant ay gumagamit ng parehong lohika ng pagpapatupad sa loob ng sistema. Walang pagkakaiba sa kapangyarihan sa pagitan ng isang script na nilikha ng UI at ng isa na tinukoy ng purong YAML; ang pagkakaiba ay nasa katotohanan na ang UI ay nagbibigay ng mas visual na kapaligiran, habang ang YAML ay nag-aalok ng mas direktang kontrol sa teksto.

Ang mahalagang maunawaan ay ang "sequence" ng isang script ay isang listahan ng mga aksyon nang sunod-sunod, at marami sa mga opsyon sa automation na alam mo na (wait_template, choose, repeat, atbp.) ay makukuha rin sa loob ng mga script upang lumikha ng napakasalimuot na mga daloy ng automation.

Mga mode ng pagpapatupad ng script sa Home Assistant

Isa sa mga pinakamahalagang (at kadalasang nakaliligtaan) na aspeto ng mga script sa Home Assistant ay ang kanilang execution mode. Tinutukoy ng mode na ito kung paano kumikilos ang script kapag sinubukan mong i-restart ito habang tumatakbo na ito , na madalas nangyayari kapag tinawag mo ito mula sa maraming automation o kapag naiinip ang user at pinatakbo ito nang ilang beses nang sunud-sunod.

Nag-aalok ang Home Assistant ng apat na pangunahing mode: single, restart, queued, at parallel . Bawat isa ay may kanya-kanyang partikular na gamit, at mahalagang piliin ang pinakaangkop sa iyong mga pangangailangan.

Ang single mode ang pinakasimple: kung tumatakbo na ang script at susubukan mong ilunsad itong muli, hindi ito magsisimula ng panibagong pagtakbo. Sa halip, maglalabas ang Home Assistant ng babala at babalewalain lamang ang pagtatangka. Kapaki-pakinabang ito kapag walang saysay na kopyahin ang script , halimbawa, isang script na "i-off ang lahat" na ayaw mong mag-overlap.

Sa restart mode , kapag ang script ay muling inilunsad habang tumatakbo pa rin ito, ang kasalukuyang pagpapatupad ay agad na ihihinto at muling magsisimula mula sa simula. Ang mode na ito ay mainam kapag ang prayoridad ay ang huling utos na mauna , halimbawa, isang script na nag-aayos ng ilaw at klima ng isang silid ayon sa isang profile, at gusto mong patungan ng anumang bagong tawag ang nauna.

Mga pagpapatupad sa queue mode : ang bawat tawag na natanggap habang tumatakbo ang script ay iniimbak sa isang queue at isinasagawa kapag natapos na ang nauna. Tinitiyak ng Home Assistant na ang mga pagpapatupad ay isinasagawa ayon sa pagkakasunud-sunod ng pagtanggap sa mga ito , na lubhang kapaki-pakinabang kapag ang mga aksyon ay hindi dapat mag-overlap ngunit kailangan mo pa ring iproseso ang lahat ng ito, tulad ng pagkontrol sa parehong device gamit ang ilang mabilisang kahilingan.

Panghuli, pinapayagan ng parallel mode ang bawat bagong tawag na bumuo ng isang independiyenteng pagpapatupad, kaya maraming thread ng parehong script ang maaaring tumakbo nang sabay-sabay . Dapat itong gamitin nang matalino, dahil maaari itong humantong sa hindi inaasahang pag-uugali kung ang lahat ng mga thread na iyon ay manipulahin ang parehong mga entity, ngunit ito ay napakalakas para sa mga non-blocking task o iyong mga tumatakbo sa iba't ibang resources.

Paggamit ng mga variable at field sa mga script

Nagkakaroon ng karagdagang antas ng kakayahang umangkop ang mga script kapag ipinapasa mo sa kanila ang mga variable. Sa halip na magkaroon ng isang nakapirming script, maaari kang magkaroon ng isang bagay tulad ng isang "function" na iyong sasabihin, halimbawa, kung aling ilaw ang bubuksan, anong antas ng liwanag ang gagamitin, o kung gaano katagal dapat panatilihing aktibo ang isang device.

Mula sa graphical interface, ginagawa ito sa pamamagitan ng pagdaragdag ng "mga field" sa script . Sa script editor, maaari mong buksan ang three-dot menu at piliin ang opsyong "Magdagdag ng mga field" upang tukuyin ang mga custom na entry . Magbubukas ito ng seksyong Mga Field kung saan mo iko-configure ang pangalan, uri (teksto, numero, tagapili ng entity, atbp.), at iba pang mga opsyon para sa bawat field.

Ang mga field na ito ay gagamitin sa mga template ng script, gamit ang key na iyong tinukoy. Halimbawa, kung gagawa ka ng field na tinatawag na "brightness_level" (siyempre, mas mainam na ispeling nang ganoon), sa loob ng mga aksyon, maaari mo itong i-reference gamit ang isang template na kumukuha ng value na iyon upang isaayos ang isang serbisyo , tulad ng liwanag ng isang ilaw.

Ang kawili-wili ay kapag ang script na ito ay ginamit mula sa ibang bahagi ng interface (halimbawa, mula sa isang automation), ang mga field na ito ay lilitaw bilang mga configurable input sa editor . Pinapayagan ka nitong muling gamitin ang parehong script na may iba't ibang parameter, nang hindi dinoble ang lohika.

Bukod sa mga field na tinukoy sa editor, maaari kang magpasa ng mga variable sa isang script sa loob ng action data kapag tinatawag ito. Gumagana ito kapwa kapag direktang tinawag mo ang script.name entity at kapag ginamit mo ang script.turn_on service, at lahat ng key na ipapadala mo ay magiging available bilang mga variable sa mga template ng script, kahit na hindi mo pa natutukoy ang mga ito bilang mga field.

Mga script ng tawag: script.NAME vs script.turn_on

Sa Home Assistant, may dalawang pangunahing paraan para simulan ang isang script mula sa isang aksyon: sa pamamagitan ng direktang pagtawag sa script entity (hal. script.night_mode) o sa pamamagitan ng paggamit ng generic service script.turn_on at pagpasa sa entity bilang target.

Sa unang tingin, tila pareho lang sila, ngunit ang pangunahing pagkakaiba ay nasa paghihintay. Kapag tinawag mo ang script nang "direkta" (ginagamit ito bilang isang aksyon ng script), ang automation o script na tumatawag dito ay naghihintay na matapos ang pagpapatupad ng tinawag na script bago magpatuloy sa mga susunod na hakbang nito.

Sa mode na ito, kung ang tinawag na script ay nabigo dahil sa isang error at nahinto, ang script o automation na nag-invoke nito ay nahinto rin . Ito ay isang napaka-kapaki-pakinabang na pag-uugali kapag kailangan mo ang lahat ng bagay na kumilos na parang isang atomic block: alinman sa lahat ng bagay ay gumana nang tama, o ihihinto mo ang high-level na aksyon.

Gayunpaman, kung gagamitin mo ang serbisyong script.turn_on upang maglunsad ng isa o higit pang mga script , hindi na hinihintay ng tumatawag na matapos ang mga ito. Hinihiling lamang nito na simulan ang mga ito (ayon sa pagkakasunod-sunod na inilista mo) at pagkatapos ay magpapatuloy sa sarili nitong mga aksyon nang hindi naharang.

Sa pangalawang pagkakataong ito, ang anumang mga error na maaaring mangyari sa mga tinawag na script ay hindi makakaapekto sa script na tumawag . Binubuksan nito ang pinto para sa mga pattern na "tumakbo sa background": inilulunsad mo ang isang script na gumagawa ng mabibigat na gawain (halimbawa, pag-log ng data, pagsasaayos ng maraming device, atbp.) habang nagpapatuloy ang iyong automation sa sarili nitong mga gawain.

Isang kawili-wiling pattern ang pagsasama ng `script.turn_on` sa isang mas huling paghihintay (halimbawa, gamit ang `wait_template`) upang hintayin na maabot ng background script ang isang partikular na estado, ngunit nang walang pagkabigo ay ibinababa ang lahat . Ito ay isang banayad na paraan upang i-decouple ang mga proseso at gawing mas matatag ang iyong home automation system laban sa paminsan-minsang mga error.

Mga script, seguridad, at pinakamahuhusay na kagawian

Sa isang masalimuot na sistema ng home automation, ang mga script ay hindi lamang para sa pagbukas ng mga ilaw o paggalaw ng mga blinds; maaari rin nilang ma-access ang mga sensitibong device, ilantad ang data, o makipag-ugnayan sa mga panlabas na serbisyo. Kaya naman mahalagang ipatupad ang mahusay na mga kasanayan sa seguridad kapag nagdidisenyo ng mga script sa Home Assistant.

Kung ang iyong mga script ay kumokonekta sa mga remote service, API, o humahawak ng mga token at credential, pinakamahusay na gamitin ang mga sikretong opsyon ng Home Assistant sa halip na direktang i-hardcoding ang mga password o API key sa YAML . Pinapanatili nitong mas malinis ang iyong configuration at pinipigilan ka nitong maglabas ng sensitibong impormasyon kung magbabahagi ka ng mga snippet ng script.

Maipapayo rin na ang iyong mga script ay may kasamang ilang lohika sa pagsusuri ng estado bago magsagawa ng mga sensitibong aksyon. Halimbawa, maaari mong i-verify na ang isang device ay nasa inaasahang estado bago ito baguhin, o kung natutugunan ang ilang mga kundisyon sa seguridad (walang tao sa bahay, nakakandado ang mga pinto, atbp.) bago mag-isyu ng mga utos na nakakaapekto sa pisikal na pag-access.

Sa mas advanced na mga kapaligiran, kung saan isinama ang mga customized na solusyon, artificial intelligence, o mga sistema ng data analytics, nagiging kritikal ang cybersecurity. Sa mga sitwasyong ito, karaniwan nang pagsamahin ang Home Assistant sa mga partikular na development at security audit , sa pamamagitan man ng mga external provider o mga eksperto sa larangan.

Kasabay nito, mainam na pana-panahong suriin ang iyong mga script at automation upang matiyak na hindi pa luma ang mga ito, walang mga sanggunian sa mga tinanggal na entity, at hindi ka pa nakakaipon ng mga hindi kinakailangang lohika na maaaring magdulot ng hindi inaasahang pag-uugali . Ang isang malinis at organisadong pundasyon ay susi sa pagpapanatili ng isang matatag at ligtas na pag-install.

Mga script at pagsusuri ng datos sa smart home

Ang isa pang aspeto kung saan maaaring maging lubhang kapaki-pakinabang ang mga script ay sa pangongolekta at pagproseso ng datos. Itinatala ng Home Assistant ang maraming impormasyon tungkol sa pagkonsumo ng enerhiya, temperatura, katayuan ng device, presensya, at iba pa, at maaaring magsilbing pandikit ang mga script upang ihanda ang datos na iyon bago ipadala o iproseso ito.

Halimbawa, maaari kang lumikha ng mga script na pana-panahong nangongolekta ng ilang partikular na halaga at ipinapadala ang mga ito sa isang business analytics system, tulad ng Power BI dashboard o iba pang visualization tool, o pinoproseso ang mga ito gamit ang Python para sa pagsusuri . Binabago nito ang iyong home automation system tungo sa isang mapagkukunan ng totoong datos tungkol sa mga gawi sa paggamit at kahusayan sa enerhiya , na tumutulong sa iyong gumawa ng mas matalinong mga desisyon.

Kung pagsasamahin mo ito sa mga advanced na logic o external AI model, mas malayo pa ang magagawa mo: maaaring tumawag ang iyong mga script sa mga serbisyong nagsusuri ng mga pattern, nagmumungkahi ng mga pagsasaayos sa pag-iiskedyul, o tumuklas ng mga anomalya sa pag-uugali ng device . Ang lahat ng ito ay maaaring isama muli sa Home Assistant sa pamamagitan ng mga automation o karagdagang script.

Sa ganitong uri ng mga senaryo, karaniwan para sa mga kumpanya ng custom development na mag-alok ng mga partikular na solusyon na nag-uugnay sa Home Assistant sa mga personalized na dashboard, mga algorithm ng prediksyon ng pagkonsumo, o mga smart alert system. Ang mga script ay nagiging praktikal na mekanismo kung saan nakikipag-ugnayan ang Home Assistant sa panlabas na ecosystem na ito.

Ang kawili-wili ay, sa pamamagitan ng mahusay na pagpaplano, magagawa mong hindi lamang mas komportable at awtomatiko ang iyong tahanan, kundi pati na rin mas episyente at transparent sa mga tuntunin ng data, kung saan ang lahat ay inayos sa pamamagitan ng mahusay na dinisenyong mga script at automation na nagpapagana sa mga ito sa tamang oras.

Matapos makita ang lahat ng ito, malinaw na ang mga script sa Home Assistant ay higit pa sa isang makabagong bagay lamang: ang mga ito ang pangunahing kagamitan para sa pagbubuo ng kumplikadong lohika ng iyong system, muling paggamit ng mga aksyon, paghihiwalay ng "ano" mula sa "kailan," pagsasama ng mga panlabas na serbisyo, pagtiyak ng seguridad, at paghahanda ng data para sa mas malalim na pagsusuri. Gamit ang isang makatwirang kumbinasyon ng mga script, automation, eksena, grupo, at zone, ang iyong system ay umuunlad mula sa isang simpleng koleksyon ng mga konektadong device patungo sa isang magkakaugnay at nababaluktot na platform ng home automation, handang lumago nang hindi nagiging magulo.

Kaugnay na artikulo:

Paano gumawa at mag-debug ng mga script nang sunud-sunod gamit ang Copilot