Créer un minuteur indiquant le temps restant avant le prochain événement

Dans mon fichier de config, je redirige les sensors vers le fichier sensor.yaml, voici son contenu:

- platform: prixCarburant
  stationID:
    - 31170001
    - 31170002
    - 31100003
    - 31880001

- platform: time_date
  display_options:
    - 'date' 
    - 'time'
    - 'date_time'

La première ligne indique dans quelle domaine l’entité est utilisé, donc ici sensor (ça aurait pû être dans un autre exemple input_datetime: ou input_select:).

Donc toi, tu copie/colle à partir de la ligne 2 en prenant soin d’adapter l’indentation à ton niveau d’inclusion (ici, tu va devoir diminuer l’indentation de 2xESPACE devant chaque ligne).

J’ai essayé d’adapter les codes avec mes sensors, voilà ce que ça donne :

- platform: template
  sensors:
    prochain_evenement_a_venir_avec_boucle:
      friendly_name: "Prochain événement à venir"
      attribute_templates:
        timestamp: >
          {# Définition de la liste des entités #}
          {% set liste_des_entites= ['sensor.fajr_mawaqit','sensor.dhuhr_mawaqit', 'sensor.asr_mawaqit','sensor.maghrib_mawaqit','sensor.isha_mawaqit'] %}
          {# Définition du `namespace` afin de pouvoir récupérer la valeur définie dans la boucle en dehors de celle-ci (spécificité du Jinja)#}
          {%set prochain_evenement = namespace(timestamp='')  %}
          {# Boucle parcourant tous les éléments de la liste `liste_des_entites` #}
          {% for entite in liste_des_entites %}
              {% if loop.first %}
                  {# Au premier passage on récupère les informations de la première entité de la liste #}        
                  {% set prochain_evenement.timestamp = (as_timestamp(states(entite))|float) %}
              {% else %}
                  {# On compare la valeur précédemment stockée avec celle correspondant au nouvel index de la boucle #}        
                  {% if (as_timestamp(states(entite))|float) < prochain_evenement.timestamp %}
                      {# la valeur de l'entité est inférieure à celle stockée, donc c'est elle qu'on stocke dorénavant #}        
                      {% set prochain_evenement.timestamp = (as_timestamp(states(entite))|float) %}
                  {% endif %}        
              {% endif %}
          {% endfor %}
          {{ prochain_evenement.timestamp }}
      value_template: >
        {# Définition de la liste des entités #}
        {% set liste_des_entites= ['sensor.fajr_mawaqit','sensor.dhuhr_mawaqit','sensor.asr_mawaqit','sensor.maghrib_mawaqit','sensor.isha_mawaqit'] %}
        {# Définition du `namespace` afin de pouvoir récupérer la valeur définie dans la boucle #}
        {%set prochain_evenement = namespace(timestamp='', nom_de_l_entite='')  %}
        {# Boucle parcourant tous les éléments de la liste `liste_des_entites` #}
        {% for entite in liste_des_entites %}
            {% if loop.first %}
                {# Au premier passage on récupère les informations de la première entité de la liste #}        
                {% set prochain_evenement.timestamp = (as_timestamp(states(entite))|float) %}
                {% set prochain_evenement.nom_de_l_entite = entite %}
            {% else %}
                {# On compare la valeur précédemment stockée avec celle correspondant au nouvel index de la boucle #}        
                {% if (as_timestamp(states(entite))|float) < prochain_evenement.timestamp %}
                    {# la valeur de l'entité est inférieure à celle stockée, donc c'est elle qu'on stocke dorénavant #}        
                    {% set prochain_evenement.timestamp = (as_timestamp(states(entite))|float) %}
                    {% set prochain_evenement.nom_de_l_entite = entite %}
                {% endif %}        
            {% endif %}
        {% endfor %}
        {{ prochain_evenement.nom_de_l_entite.split('sensor.cert_expiry_timestamp_')[1] }}
          
- platform: template
  sensors:
    prochain_evenement_a_venir_sans_boucle:
      friendly_name: "Prochain événement à venir"
      attribute_templates:
        timestamp: >
          {# Définition de la liste des entités #}
          {% set liste_des_entites = ['sensor.fajr_mawaqit', 'sensor.dhuhr_mawaqit','sensor.asr_mawaqit','sensor.maghrib_mawaqit','sensor.isha_mawaqit'] %}
          {% set timestamp_des_entites = [as_timestamp(states('sensor.fajr_mawaqit'))|float,as_timestamp(states('sensor.dhuhr_mawaqit'))|float,as_timestamp(states('sensor.asr_mawaqit'))|float,as_timestamp(states('sensor.maghrib_mawaqit'))|float,as_timestamp(states('sensor.isha_mawaqit'))|float] %}
          {% set entite_la_plus_petite = timestamp_des_entites|min %}
          {{timestamp_des_entites[timestamp_des_entites.index(entite_la_plus_petite)]}}
      value_template: >
        {# Définition de la liste des entités #}
        {% set liste_des_entites = ['sensor.fajr_mawaqit', 'sensor.dhuhr_mawaqit', 'sensor.asr_mawaqit', 'sensor.maghrib_mawaqit', 'sensor.isha_mawaqit'] %}
        {% set timestamp_des_entites = [as_timestamp(states('sensor.fajr_mawaqit'))|float,as_timestamp(states('sensor.dhuhr_mawaqit'))|float,as_timestamp(states('sensor.asr_mawaqit'))|float,as_timestamp(states('sensor.maghrib_mawaqit'))|float,as_timestamp(states('sensor.isha_mawaqit'))|float] %}
        {% set entite_la_plus_petite = timestamp_des_entites|min %}
        {{liste_des_entites[timestamp_des_entites.index(entite_la_plus_petite)].split('sensor.cert_expiry_timestamp_')[1]}}

Je ne sais pas par quoi remplacer les sensor.cert_expiry_timestamp dans le code…

Voici le code à utiliser (testé fonctionnel chez moi après avoir suivi les instructions de l’intégration Mawaqit) :

sensor:
  - platform: template
    sensors:
      soayux_priere:
        friendly_name: "Prochain événement à venir"
        value_template: >
          {# Définition de la liste des entités que l'on veut surveiller #}
          {% set liste_des_entites= ['sensor.fajr_mawaqit','sensor.dhuhr_mawaqit', 'sensor.asr_mawaqit','sensor.maghrib_mawaqit','sensor.isha_mawaqit'] %}
          {# 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 pr ochain_evenement = strptime(states(liste_des_entites[timestamp_des_entites.index(entite_la_plus_petite)]), '%Y-%m-%d %H:%M:%S') %}
          {# 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')}}
1 « J'aime »

Ça marche chez moi également! Un grand merci à toi @Clemalex tu ne manques vraiment pas de dévouement. T’es au top man :sunglasses::+1:

Désolé si jamais je t’es fait perdre patience… Et merci encore :wink:
A bientôt !

Pas du tout !

:+1: :grin:

1 « J'aime »

@Clemalex je reviens vers toi car ton bout de code a marchait le jour j, mais dès le lendemain il affiche « jour -1 » :
Screenshot_20210125_194621

Est-ce possible d’afficher seulement les heures/minutes et plus les jours ?
A+

Faut que je fasse de la mise au point alors :confused:

Est-tu sûr que le temps indiquer pour les HH:MM sont les bonnes ? Une fois l’heure de prière passée, l’entité se met t’elle à jour pour afficher l’heure du lendemain ou arrive t-il que toutes les prières soient passées et les entités ne sont pas encore mise à jour ?

En faite non effectivement, l’entité ne se met pas à jour vis à vis des prochaines prières. Elle affiche le temps restant pour la 1ère prière de la journée seulement et ignore les horaires des 4 suivantes…

Bon en réalité, avec les 5 sensors de mawaqit c’est largement suffisant pour suivre les horaires. La petite entité qui indique le temps restant avant la prochaine prière c’est un peu du luxe lol :grin:

Je viens de remettre l’intégration et effectivement, je pensais que les entités se mettaient à jour mais en faites non… du coup, forcément la ancienne date reste toujours la même (sensor.fajr_mawaqit dans mon cas).

Il va falloir reprendre le code.

J’essaierai de dégager du temps dans la semaine, sinon dans le week-end :+1:

Un sensor qui représente une date est sensé être affiché dans le Dashboard sous forme « dans … » ou « il y a … »
Pas besoin de le calculer.

Tu as raison, mais là, @Heihachi31 cherche un moyen d’afficher sur sa page principale le prochain évènement depuis une liste d’entité et non pas la liste complète des entités.

Comment ferais tu ?

Mise à jour du coup ce soir :+1:
A voir demain quand les entités seront à jour mais à l’heure où je poste, l’entité remonte En attente de mise à jour au lieu d’une valeur négative qui ne représente rien…

  - platform: template
    sensors:
      prochaine_priere:
        friendly_name: "Prochain événement à venir"
        value_template: >
          {# Définition de la liste des entités que l'on veut surveiller #}
          {% set liste_des_entites= ['sensor.fajr_mawaqit','sensor.dhuhr_mawaqit', 'sensor.asr_mawaqit','sensor.maghrib_mawaqit','sensor.isha_mawaqit'] %}
          {# 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 timestamp_le_plus_petit = namespace(timestamp='')  %}
          {%set texte_mise_a_jour = 'En attente de mise à jour'  %}
          {% for temps in timestamp_des_entites %}
              {% if loop.first %}
                  {# Au premier passage #}        
                  {% set timestamp_le_plus_petit.timestamp = texte_mise_a_jour %}
              {% endif %}
                  {# Pour tous les passages même le premier #}   
                  {% if as_timestamp(now()) < temps %}
                      {% set timestamp_le_plus_petit.timestamp = temps %} 
                  {% endif %}
          {% endfor %}
          {% set entite_la_plus_petite = timestamp_le_plus_petit.timestamp %}
          {% if entite_la_plus_petite != texte_mise_a_jour %}
              {# Définition de la date/heure du prochain évènement en objet datetime pour faire des calculs liés au temps #} 
              {% set prochain_evenement = strptime(states(liste_des_entites[timestamp_des_entites.index(entite_la_plus_petite)]), '%Y-%m-%d %H:%M:%S') %}
              {# 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')}}
          {% else %}
              {{ texte_mise_a_jour }}
          {% endif %}

image

La mise à jour est faite, ce n’est pas encore ça… :wink:
j’ai mal géré la nouvelle boucle…

edit :
et voilà

sensor:
  - platform: template
    sensors:
      prochaine_priere:
        friendly_name: "Prochain événement à venir"
        value_template: >
          {# Définition de la liste des entités que l'on veut surveiller #}
          {% set liste_des_entites= ['sensor.fajr_mawaqit','sensor.dhuhr_mawaqit', 'sensor.asr_mawaqit','sensor.maghrib_mawaqit','sensor.isha_mawaqit'] %}
          {# 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 timestamp_le_plus_petit = namespace(timestamp='',stop='')  %}
          {%set texte_mise_a_jour = 'En attente de mise à jour'  %}
          {% for temps in timestamp_des_entites %}
              {% if loop.first %}
                  {# Au premier passage #}        
                  {% set timestamp_le_plus_petit.timestamp = texte_mise_a_jour %}
              {% endif %}
                  {# Pour tous les passages même le premier #}   
                  {% if (as_timestamp(now()) < temps) and not(timestamp_le_plus_petit.stop) %}
                      {% set timestamp_le_plus_petit.stop = true %}
                      {% set timestamp_le_plus_petit.timestamp = temps %} 
                  {% endif %}
          {% endfor %}
          {% set entite_la_plus_petite = timestamp_le_plus_petit.timestamp %}
          {% if entite_la_plus_petite != texte_mise_a_jour %}
              {# Définition de la date/heure du prochain évènement en objet datetime pour faire des calculs liés au temps #} 
              {% set prochain_evenement = strptime(states(liste_des_entites[timestamp_des_entites.index(entite_la_plus_petite)]), '%Y-%m-%d %H:%M:%S') %}
              {# 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')}}
          {% else %}
              {{ texte_mise_a_jour }}
          {% endif %}