Étant encore novice dans le domaine de la domotique et l’automatisation, j’aurai besoin d’un coup de pouce ou d’un aiguillage pour mener à bien un petit projet d’automatisation. Voici l’idée :
Je souhaiterai afficher sur mon interface Home Assistant un minuteur indiquant le temps restant avant le prochain événement.
J’ai, à la maison, 5 événements qui se déroulent chaque jour. Chaque événement est en faite représenté par un sensor ayant comme deviceclass du timestamp. Ce sont donc des événements définis par une date est une heure. Appelons ces événements dans ce topic : sensor.1, sensor.2, sensor.3, sensor.4, et sensor.5
Je souhaiterai créer un nouveau sensor de deviceclass timestamp qui aurait comme valeur : le temps restant avant le prochain événement. Je ne sais pas parfaitement comment mettre cela en oeuvre sur HA.
J’ai pensé à automatiser une comparaison entre la valeur des sensor.1, sensor.2, sensor.3, sensor.4, sensor.5 et le sensor.time :
Ainsi les résultats négatifs correspondent aux événements passés dans la journée et le résultat positif le plus petit est la différence de temps entre l’heure actuel et l’heure du prochain événement.
Ensuite, il faudrait transformer ce temps en minuteur…
Dans un langage comme python, je saurais à peu près faire ce genre de script mais je ne sais pas trop comment mettre cela en œuvre dans les fichiers .YAML de HA.
Avez-vous des tutos pour répondre à ce genre de problématique ? ou d’autres idées ?
Pas besoin de passer par une automatisation, tu peux faire tout ce que tu souhaites dans une entité créée juste pour ça indiquant le temps avant le prochain événement et son nom par exemple.
De plus quelle précision cherches tu ? La minute ? Car en dessous de la minute c’est moins évident…
Je trouve tout ça assez complexe pour le moment et je ne suis pas encore à l’aise avec les template et le language jinja… Enfaîte j’ai juste la théorie en tête. Je vois les choses comme ça :
En fesant ces comparaisons :
SI sensor.time < Event1 ALORS sensor.prochaine_event = Event1 - sensor.time
SI sensor.time < Event2 ALORS sensor.prochaine_event = Event2 - sensor.time
SI sensor.time < Event3 ALORS sensor.prochaine_event = Event3 - sensor.time
SI sensor.time < Event4 ALORS sensor.prochaine_event = Event4 - sensor.time
SI sensor.time < Event5 ALORS sensor.prochaine_event = Event5 - sensor.time
Ainsi on obtient le temps restant avant le prochain événement. Et si on fait tourner ce script en boucle, la valeur du prochaine_event va faire que de se mettre à jour et jouer le rôle de minuteur du prochain événement. C’est jouable ce genre de chose ?
En pratique c’est peu être bien moins simple à mette en œuvre… Et j’ai peut être était un peu trop ambitieux sur mon projet.
Ce n’est pas en rapport direct avec ta demande, mais ce n’est pas si éloigné car on récupère au final l’entité dont le timestamp est le plus bas qui peut être te sera nécessaire.
Je te laisse lire, mais je pense que ça peut te servir car il y a pas mal de notion qui te seront utiles, du moins j’espère.
Et du coup, voici le code qui permet d’obtenir le temps restant avant l’expiration de l’un des certificats de mes ndd (le prochain à expirer) :
{# Définition de la liste des entités que l'on veut surveiller #}
{% set liste_des_entites = ['sensor.cert_expiry_timestamp_ndd1_duckdns_org','sensor.cert_expiry_timestamp_ndd2_duckdns_org'] %}
{# Définition du namespace pour récupération de la valeur en dehors de la boucle #}
{%set timestamp_des_entites_boucle = namespace(timestamp='') %}
{# Boucle parcourant tous les éléments de la liste `liste_des_entites` #}
{# Cette boucle permet de définir une liste contenant les timestamp #}
{% for entite in liste_des_entites %}
{% if loop.first %}
{# Au premier passage #}
{% set timestamp_des_entites_boucle.timestamp = [as_timestamp(states(entite))] %}
{% else %}
{# Pour les autres passages #}
{% set timestamp_des_entites_boucle.timestamp = timestamp_des_entites_boucle.timestamp + [as_timestamp(states(entite))] %}
{% endif %}
{% endfor %}
{# Définition de la liste représentant les timestamp #}
{% set timestamp_des_entites = timestamp_des_entites_boucle.timestamp %}
{# Définition de la variable contenant le timestamp le plus petit représentant le prochain évènement #}
{% set entite_la_plus_petite = timestamp_des_entites|min %}
{# Définition de la date/heure du prochain évènement en objet datetime pour faire des calculs liés au temps #}
{% set prochain_evenement = as_local(strptime(states(liste_des_entites[timestamp_des_entites.index(entite_la_plus_petite)]), '%Y-%m-%dT%H:%M:%S.000Z')).replace(tzinfo=None) %}
{# Définition de la date/heure actuel en objet datetime pour faire des calculs liés au temps #}
{% set maintenant = strptime((states('sensor.date') + " " + states('sensor.time') + ":00"), '%Y-%m-%d %H:%M:%S') %}
{# On soustrait les deux objets datetime afin de récupérer le temps restant #}
{{(prochain_evenement - maintenant)|replace('days','jours')|replace('day','jour')}}
Pour l’adapter avec tes entités, il faut modifier la liste des entités contenues dans la variable liste_des_entites et modifier en conséquence le format utilisé pour la conversion en objet datetime à définition de la variable prochain_evenement, n’hésite pas à demander de l’aide
J’ai une question toute bête car je ne suis pas sûr de ce que tu veux. Tu veux le temps restant … mais en faire quoi ? uniquement l’afficher ?
Si c’est uniquement pour de l’affichage dans l’interface et que tu as un peu de compétence de dev Web, le mieux est d’utiliser une lib js d’horloge, tu l’initialises avec le décompte du déclenchement à venir et c’est joué uniquement dans le client, pas coté HA.
Il n’y a pas cela dans HACS ? Hummmm une idée de dev ça tiens
Merci pour tes explications clemalex. Je me plonge dans tes codes pour voir un peu comment ça se goupille. Si j’ai des questions j’hésiterais pas alors !
Voici une capture d’écran d’une de mes entité en question :
Les 4 autres entités ont les mêmes attributs que celle ci et la même structure d’état (c à d date et heure). Seule leur valeur d’état diffère entre elle.
Hello Pozzi, il n’y a pas de question bête, j’ai peut être tout simplement pas été précis dans mon explication !
En faite oui c’est simplement pour de l’affichage sur une carte dans l’interface de HA. C’est juste histoire de consulter combien de temps il me reste avant le prochain événement.
D’accord pour la lib js horloge, je ne suis hyper à l’aise avec ça non plus, qu’est ce que tu veux dire par côté client ?
A+
Cela veut dire que le code est exécuté côté client, comprendre le navigateur internet et non pas le serveur domotique, donc pas de ressources utilisées.
En toute sincérité, non je ne m’y suis pas encore penché. Je vais tenter quelques choses d’ici là fin du week-end maintenant que mon système d’alarme est finalisé. Je vais sûrement avoir besoin de toi oui
