Tempo EDF + Voltalis

Bonjour,

J’ai déjà posté sur des sujets concernant l’offre Tempo EDF mais là, il s’agit d’autre chose.
J’ai besoin de passer le programme en cours de Voltalis en mode « Journée rouge » où tous les radiateurs sont mis en « Hors gel » lorsque je suis en jour rouge (offre Tempo) en heure pleine uniquement. Et ensuite, lorsque l’on sort de cette plage, repasser sur l’ancien mode qui était actif AVANT le basculement sur la journée rouge…

Que faire ?

  1. Faire un « capteur » ou un truc comme ça pour mémoriser le programme en cours. En fait j’ai 7 programmes sur voltalis et sur chaque j’ai donc une automatisation : lorsque le programme s’active, je set une entité de type string (input_text.voltalis_mode_en_cours) avec le nom du programme. C’est long, c’est une automatisation par capteur, si tous se désactivent ça n’efface pas le programme en cours. Et ajouté dans une carte, ça ajoute un champs éditable alors que ça devrait être en lecture seule, bref surement possible de faire mieux.
  2. Je voudrais que lorsque « RTE Tempo Heures Creuses » passe à false et que le jour courant est rouge alors on sauve le programme Voltalis courant dans une variable, et on set le programme « jour rouge ».
  3. Lorsque l’on quitte le jour rouge plein tarif, si le programme précédent n’est pas vide (donc basculé dans l’étape (2)) alors on repasse sur ce programme puis on reset la variable (remis à vide).

Déjà le (1) il y a certainement plus simple à faire que ce que j’ai fais !
Genre un truc en lecture seule et qui passe en revue tous les capteurs genres :
« est-ce que le mode normal est actif ? » oui alors normal sinon « est-ce que le programme …est actif ? » …etc…
Je pourrais faire ça directement dans la carte mais ça serait plus simple d’avoir une variable qui vaut la bonne valeur et se mette à jour seule.

Actuellement j’ai ça :

et ça :

Bonsoir @Feneck91
Dans le principe tu as bon je pense, malgré la multitude de tes Voltalis, j’ignore ce que c’est !

Un petit exemple que j’utilise à l’ouverture d’une fenêtre (pour toi journée rouge), tu vas avoir un peu froid :wink: :
Si ouverture mémorisation du preset de mon thermostat et passage en mode away (12.5 °C)

alias: FenetreOuvertePasDeChauffage
description: ""
mode: single
triggers:
  - entity_id:
      - binary_sensor.windowsopen
    from: "off"
    to: "on"
    for:
      hours: 0
      minutes: 0
      seconds: 2
    trigger: state
conditions:
  - condition: state
    entity_id: input_boolean.intchauffage
    state: "on"
actions:
  - data:
      value: "{{state_attr('climate.sejour','preset_mode')}}"
    target:
      entity_id: input_text.mem_preset_sejour
    action: input_text.set_value
  - data:
      preset_mode: away
    target:
      entity_id: climate.sejour
    action: climate.set_preset_mode

Fermeture de fenêre, retour au preset mémorisé :

alias: FenetreReferméeChauffage
description: ""
mode: single
triggers:
  - entity_id:
      - binary_sensor.windowsopen
    from: "on"
    to: "off"
    for:
      hours: 0
      minutes: 0
      seconds: 2
    trigger: state
conditions:
  - condition: state
    entity_id: input_boolean.intchauffage
    state: "on"
    for:
      hours: 0
      minutes: 0
      seconds: 0
actions:
  - data:
      preset_mode: "{{states('input_text.mem_preset_sejour')}}"
    target:
      entity_id: climate.sejour
    action: climate.set_preset_mode

C’est un peu ce que tu as en tête il me semble, à voir avec toutes tes entrées !

Bob

Merci je vais regarder et m’en inspirer. Je débute donc je ne comprend pas tout…

Je suis en triple vitrage + cheminée. Pendant la nuit, même en tarif rouge, le tarif n’est pas excessif donc il est possible de chauffer la nuit

Normal : c’est le mode normal où les lundi / mardi ma femme est en télétravail et le salon chauffe pendant la journée.
Journée Rouge : tout en hors gel
Mode télétravail : comme le mode normal mais le salon chauffe du lundi au vendredi, lorsque l’on change de jour de télétravail.
Mode Maman : un mode qui chauffe la chambre d’ami (sinon elle reste en ECO).
Les modes rapides sont les modes pré-configurés par Voltalis.

Ça sert à quoi ? Attendre 2 secondes ?

Ton yaml, il est où ? C’est un fichier copié dans configuration.yaml ? C’est un fichier inclu par configuration.yaml ?
C’est une automation ? (bizarre je n’ai pas vu la possibilité de charger en yaml).
C’est quoi ce yaml ? Une automaition, un capteur, un truc ? (Pour savoir de quoi on parle).

Ma première question c’est le (1) : comment stocker le nom du mode en cours sans faire des choses aussi complexes que ce que j’ai fais ?

EDIT : J’ai tenté d’ajouter un sensor :

- sensor:
    - name: "Voltalis_Current_Program"
      unique_id: voltalis_mode_en_cours
      icon: mdi:radiator
      state: >-
        {% if is_states('switch.normal', 'on') %}
          Mode : Normal
        {% elif is_states('switch.journee_rouge', 'on' %}
          Mode : Journée Rouge
        {% elif is_states('switch.teletravail', 'on' %}
          Mode : Télétravail
        {% elif is_states('switch.vacances_maison_maman', 'on' %}
          Mode : Maman
        {% elif is_states('switch.quicksettings_athome', 'on' %}
          Mode Rapide : À la maison
        {% elif is_states('switch.quicksettings_shortleave', 'on' %}
          Mode Rapide : absence courte
        {% elif is_states('switch.quicksettings_longleave', 'on' %}
          Mode Rapide : absence longue
        {% else %}
          Aucun
        {% endif %}

Rien ne fonctionne !
Plein d’exemples différents sur le net, pas du tout les mêmes codes !
Parfois il faut mettre sous la forme (mais ça n’a pas l’air de fontionner !) :

- sensor:
    - platform: template
      sensors:
        voltalis_programme_en_cours:
          friendly_name: "Voltalis_Current_Program"
          icon: mdi:radiator
          state: >-
            {% if is_states('switch.normal', 'on') %}
              Mode : Normal
            {% elif is_states('switch.journee_rouge', 'on' %}
              Mode : Journée Rouge
            {% elif is_states('switch.teletravail', 'on' %}
              Mode : Télétravail
            {% elif is_states('switch.vacances_maison_maman', 'on' %}
              Mode : Maman
            {% elif is_states('switch.quicksettings_athome', 'on' %}
              Mode Rapide : À la maison
            {% elif is_states('switch.quicksettings_shortleave', 'on' %}
              Mode Rapide : absence courte
            {% elif is_states('switch.quicksettings_longleave', 'on' %}
              Mode Rapide : absence longue
            {% else %}
              Aucun
            {% endif %}

Bonjour @Feneck91
Oui, il faut que mon capteur de fenêtre passe à ‹ on › pendant 2 secondes pour que l’automatisation soit déclenchée.

J’ai créé un input_text ‹ input_text.mem_preset_sejour › pour mémoriser le preset_mode de mon chauffage.
Mes yaml sont deux automatisations:

  1. FenetreOuvertePasDeChauffage
    Si ouverture fenêtre pendant 2s, alors je mets dans l’input_text mon preset_mode actuel et je passe mon chauffage à ‹ away › (12.5°C)

  2. FenetreReferméeChauffage
    Si la fenêtre est refermée depuis 2s, je remets la valeur sauvegardée dans l’input_text dans le preset_mode.

Je ne connais pas Voltalis, je viens juste de regarder leur site.
Peux-tu dire ce que tu as comme entrants dans HA avec Voltalis, en donnant une capture depuis les outils de DEV comme ceci:

Ce serait plus facile de t’aiguiller en sachant ce que tu as comme entités en entrée parce que sur tes deux premières captures je ne vois pas à quoi correspondent les éléments affichés, des boutons, des inputs ?

Bob

Je ne sais pas comment tu as ça sous la forme yaml, moi c’est graphique !

Ton délai de 2 secondes peut-être utile.
En effet si plusieurs éléments changent simultanément au sein d’un même capteur, il se peut (il se pourrait) que l’un change avant l’autre et que du coup je lise par exemple « jour rouge » alors que le mode heure creuse soit à « on » et pas encore mis à jour.
Par exemple, je pourrais attendre une minute ou trente seconde avant de faire le test.

Tu cliques sur l’élément bleu et tu auras le détail au-dessus :wink:
Ceux-sont les entités de Voltalis :thinking:
Comment as-tu l’infos « Journée rouge » ou autre « couleur » par exemple, je n’ai ni Voltalis, ni Tempo EDF, c’est ce capteur je pense qu’il faudrait montrer.
Bob

Pour l’instant je voudrais un capteur qui me donne le programme voltalis actuel.
J’ai ça pour les programmes voltalis : (ce sont des switch on/off)

icon: mdi:toggle-switch
friendly_name: Normal

icon: mdi:toggle-switch
friendly_name: Télétravail

icon: mdi:toggle-switch
friendly_name: Maman

etc...

C’est une de mes questions ?

Le programme Voltalis il vient d’où, c’est toi qui le construit avec des switch ou c’est une remontée de Voltalis ?

J’avoue ne pas comprendre grand chose à ce que tu souhaites faire !
Pour le chauffage j’utilise un Thermostat avec des preset_mode:
image

Un Scheduler:
image

Qui prend en charge des input comme conditions:
image

Pilotable depuis une automatisation:
image

Tu utilises quoi pour piloter ton chauffage ?
Ne sachant pas ce que tu as comme entrées disponibles et d’où sortent les infos dont tu parles ça me parait compliqué d’en dire plus !
Bob

J’ai une intégration Voltalis qui me remonte plein de choses.
Les chauffages, divers trucs (j’avoue j’ai pas tout regardé) et surtout une série de switch on/off dont le nom est le programme que j’ai rempli dans l’application Voltalis.

Un programme pilote tous les chauffages sur toute une semaine. Ils ont une application très bien faite, c’est gratuit ! Juste ils coupent le chauffage quand ils veulent pour écrêter les pics EDF.
J’avais pas de fil pilote câblés dans la maison, c’est un bon compromis.

Le problème avec mon étape (1) c’est que j’ai un paquet de switch mais pas de sensor qui me donne le programme courant qui me permettrait de le tester et de le mémoriser pour revenir dessus une fois la période rouge passée.

Dans un premier temps, il faudrait que je crée un sensor que j’appelle et qui me remonte le nom du programme en cours (ou aucun si rien n’est activé), c’est déjà une première étape.

J’ai fais ça avec un paquet d’automation mais c’est franchement nul, on peut mieux faire je pense.
D’où mon sensor mais j’arrive pas à trouver la syntaxe !
J’ai vu aussi qu’il y a des triggers : ce serait bien que sur changement d’état d’un des switchs il recalcule la valeur correcte.

- sensor:
    - platform: template
      sensors:
        voltalis_programme_en_cours:
          friendly_name: "Voltalis_Current_Program"
          icon: mdi:radiator
          state: >-
            {% if is_states('switch.normal', 'on') %}
              Mode : Normal
            {% elif is_states('switch.journee_rouge', 'on' %}
              Mode : Journée Rouge
            {% elif is_states('switch.teletravail', 'on' %}
              Mode : Télétravail
            {% elif is_states('switch.vacances_maison_maman', 'on' %}
              Mode : Maman
            {% elif is_states('switch.quicksettings_athome', 'on' %}
              Mode Rapide : À la maison
            {% elif is_states('switch.quicksettings_shortleave', 'on' %}
              Mode Rapide : absence courte
            {% elif is_states('switch.quicksettings_longleave', 'on' %}
              Mode Rapide : absence longue
            {% else %}
              Aucun
            {% endif %}

ça va être la fête le jour où ils seront piratés :blush:, pas de ça chez moi mais bon si tu n’avais pas le choix !
Donc si tu as une intégration Voltalis peux-tu donner un aperçu de ce quelle te donne comme entités ?
Sous cette forme en cliquant sur service :
image

image
Ou en cliquant sur entités:
image
image

Parce que les autres je ne sais pas mais moi je ne vois vraiment pas ce que tu as en entrées avec ton intégration, ce dont tu disposes de base et ce que toi tu as créé, j’imagine que ‹ switch.vacances_maison_maman › n’est pas fourni d’origine par l’intégration, soit tus l’as ajouté dans ton interface Voltalis (que je ne connais pas), soit dans Home Assistant.
C’est peut être moi qui n’y comprends rien mais essaie de donner tes entrants comme demandé et peut être quelqu’un pourra t’aider plus.
Bob

Il suffit de débrancher le bloc qui contrôle tous les radiateurs ou débrancher le bloc voltalis de chaque radiateur.
Et les coupure ne durent pas plus de 30 minutes, donc ça ne se sent pas, une maison a quand même un minimum d’inertie.

Ben si, Actuellement j’ai tous ces switchs qui valent on / off et qui sont fournis par l’intégration Voltalis :

switch.normal
switch.journee_rouge
switch.teletravail
switch.vacances_maison_maman
switch.quicksettings_athome
switch.quicksettings_shortleave
switch.quicksettings_longleave

Si j’ajoute un programme de gestion des radiateurs « Bob » via l’application / web Voltalis et que je rafraichis l’intégration, j’aurais switch.bob en plus.

Dans configuration.yaml :

template: !include /config/YAML/template_voltalis.yaml

Pour le (1) :
Plein de petits problèmes ! J’avais mal refermé la parenthèse de {% if is_states('switch.quicksettings_athome', 'on' %} comme j’avais commencé le code par utiliser la méthode states(, par la suite j’ai utilisé state( pour tester l’état mais j’avais oublié de retirer le ‹ s › ! Les messages de logs ne sont pas très explicites et je ne savais pas si c’était une erreur de code ou de formattage du yaml.
A priori, pas besoin de trigger, il détecte automatiquement les switchs utilisés et se met à jour comme il faut.

Passons à l’étape (2)

# Sensor qui permet de mémoriser le programme en cours dans l'intégration Voltalis
# Attention, les modes rapides sont prioritaires !
sensor:
  - name: voltalis_current_program
    icon: mdi:heat-wave
    state: >-
      {# Voir la documentation : https://www.voltalis.com/faq/parametrage-modes-rapides#:~:text=Vous%20pouvez%20param%C3%A9trer%20vous%2Dm%C3%AAme,%3E%20Configuration%20des%20modes%20rapides). #}
      {# Le mode rapide est prioritaire, il doit être placé au début ! #}
      {% if is_state('switch.quicksettings_athome', 'on') %}
        Mode rapide - à la maison
      {% elif is_state('switch.quicksettings_shortleave', 'on') %}
        Mode rapide - absence courte
      {% elif is_state('switch.quicksettings_longleave', 'on') %}
        Moder rapide - absence longue
      {% elif is_state('switch.normal', 'on') %}
        Normal
      {% elif is_state('switch.journee_rouge', 'on') %}
        Journée Rouge
      {% elif is_state('switch.teletravail', 'on') %}
        Télétravail
      {% elif is_state('switch.vacances_maison_maman', 'on') %}
        Maman
      {% else %}
        Aucun
      {% endif %}

Comme piste, tu peut faire autrement avec scheduler-card et les conditions

J’ai configurer 7 input_select (un par jour), et dedans je choisi le mode de chauffage pour la journée :

ha- scheduler_chauffage

cela active le scheduler en question pour ce jour là.

Si tu fait comme ça tu pourrais facilement faire une automatisation pour changer le input_select en chauffage « rouge » et enregistrer dans quel mode il était dans un autre input_select pour le remettre par la suite.

1 « J'aime »

Parce que tel que tu es parti, bon perso je ne comprends pas !

Tu peux être en télétravail en journée rouge non ?

Bob

Ce sont les programmes Voltalis. Si tu actives un programme, ça désactive l’autre.
Sauf les programmes rapides qui ne désactivent pas les autres mais sont prioritaires.
Donc si tu actives le programme jour rouge ça désactive le programme télétravail ou normal

Tu trouveras j’espère ta réponse, perso chez moi c’est sans cloud et sans ressources externes à l’excellent HA, mais bon tu n’avais peut être pas le choix avec tes radiateurs.
Bonne soirée
Bob

Stocker l’ancien mode pour le ressortir plus tard est une mauvaise idée car peu robuste. Si il se produit un alignement défavorable des planètes (crash, reboot, ou juste pas de bol) il est toujours possible que le système « oublie » de remettre l’ancienne valeur…

Je te propose deux solutions pour pallier à ce problème :

  1. Le sélecteur
  • Le programme souhaité par l’utilisateur est mémorisé quelque part (input select ou autre).
  • Un certain nombre de variables d’état existent (jour rouge, heures pleines, etc)
  • Tu ajoutes un truc genre template sensor dont la valeur de sortie est : « si jour rouge et heures pleines, alors [hors gel], sinon [programme souhaité par l’utilisateur ». L’idée est de prendre le programme souhaité et les variables d’état, et de décider ce qu’on va faire en fonction des circonstances.
  • La sortie du bloc précédent est le programme à envoyer aux thermostats

Dans ce scénario, on ne peut pas oublier de remettre l’ancienne valeur, puisqu’il n’y a pas d’ancienne valeur… Quand la variable d’état « heures pleines » passe en « off » la sortie du deuxième bloc repasse automatiquement sur le programme choisi, qui n’a jamais changé.

  1. Les priorités

C’est une variante simpliste du précédent. On part avec une liste. Chaque variable d’état ajoute un item dans la liste, avec un niveau de priorité. À la fin, on prend celui qui a la priorité la plus élevée, ça devient le programme en cours.


Par exemple, le code de Bob (salut cher homonyme) stocke l’état précédent dans une variable, on ne peut donc pas le croiser avec un code similaire qui gère les heures pleines rouges, parce que personne ne sait qui arrivera en premier, la fin des heures pleines ou la fermeture de la fenêtre, pour remettre l’état précédent. Et si on ouvre la fenêtre puis arrivent les heures pleines, on risque de sauvegarder l’état deux fois, donc écraser l’état initial.

Dans ce cas en utilisant l’option 1 ci dessus, on aurait :

  • Si fenêtre ouverte ou heures pleines rouges, le thermostat reçoit « hors gel » sinon le themrostat reçoit le programme défini par l’utilisateur.

Cela suppose d’avoir un thermostat « virtuel » qui est contrôlé par l’utilisateur, dont l’état est copié dans le thermostat réel seulement si le programme prioritaire (fenêtre, heures pleines rouges, etc) ne prend pas le contrôle.

Bon… C’est un peu compliqué, je reprend.

On ne stocke l’ancien mode QUE lorsque l’on passe sur le programme Jour Rouge, donc on ne peut oublier QUE si on n’est pas passé sur le programme Jour Rouge, ce qui est d’ailleurs un problème car les jours rouges coutent 5 fois plus cher.

Je ne suis pas d’accord, il faut remettre le mode précédent. D’ailleurs si il n’y a pas de mode précédent (bug ?) je remettrais en mode Normal mais ça ne doit pas se produire.

J’ai juste besoin de ça en effet. Pas de Heure pleine mais « RTE Tempo Heures Creuses ».

  • « RTE Tempo Heures Creuses » qui doit passer à false => RTE passe en heure pleine.
  • « RTE Tempo Couleur actuelle » qui passe à la bonne couleur à minuit ! Donc 6h00 avant le changement d’état de « RTE Tempo Heures Creuses »

Voici mon automatisation pour l’entrée en jour rouge :
J’ai ajouté une nouvelle entrée « input_text.voltalis_previous_program_rouge_name » qui me permettra de l’afficher à l’utilisateur.

alias: Entrée jour rouge
description: >-
  Lorsque passe à un jour rouge, passe le programme en cours de Voltalis à un
  jour rouge.
triggers:
  - trigger: state
    entity_id:
      - binary_sensor.rte_tempo_heures_creuses
    from: "on"
    to: "off"
    for:
      hours: 0
      minutes: 0
      seconds: 20
conditions:
  - condition: state
    entity_id: sensor.rte_tempo_couleur_actuelle
    state: Rouge
actions:
  - action: input_text.set_value
    metadata: {}
    data:
      value: "{{ states('sensor.voltalis_current_program_switch') }}"
    target:
      entity_id: input_text.voltalis_previous_program_rouge_switch
  - action: input_text.set_value
    metadata: {}
    data:
      value: "{{ states('sensor.voltalis_current_program_name') }}"
    target:
      entity_id: input_text.voltalis_previous_program_rouge_name
  - action: switch.turn_on
    metadata: {}
    data: {}
    target:
      entity_id: switch.journee_rouge
mode: single

Bon, voilà, j’ai fini.
Voilà ce que ça donne :

Mode normal :

Mode jour rouge :

Pour réaliser cette carte :
Ajouter dans votre fichier configuration.yaml (je mets le fichier template_voltalis.yaml dans /config/YAML/)

template: !include /config/YAML/template_voltalis.yaml

Le contenu du fichier template_voltalis.yaml
Ce fichier permet de créer 2 senseurs : un pour le nom du switch / l’autre pour un nom compréhensible par l’utilisateur.
Ce fichier est hélas à modifier pour vos programmes Voltalis et à chaque programme ajouté / supprimé / renommé. Seul ce fichier est à modifier, le reste est générique.

# Sensor qui permet de mémoriser le programme en cours dans l'intégration Voltalis
# Attention, les modes rapides sont prioritaires !
sensor:
  - name: voltalis_current_program_name
    icon: mdi:heat-wave
    unique_id: BBD098D2-8447-4CB2-8B54-0A01D228A895
    state: >-
      {# Voir la documentation : https://www.voltalis.com/faq/parametrage-modes-rapides#:~:text=Vous%20pouvez%20param%C3%A9trer%20vous%2Dm%C3%AAme,%3E%20Configuration%20des%20modes%20rapides). #}
      {# Le mode rapide est prioritaire, il doit être placé au début ! #}
      {% if is_state('switch.quicksettings_athome', 'on') %}
        Mode rapide - à la maison
      {% elif is_state('switch.quicksettings_shortleave', 'on') %}
        Mode rapide - absence courte
      {% elif is_state('switch.quicksettings_longleave', 'on') %}
        Moder rapide - absence longue
      {% elif is_state('switch.normal', 'on') %}
        Normal
      {% elif is_state('switch.journee_rouge', 'on') %}
        Journée Rouge
      {% elif is_state('switch.teletravail', 'on') %}
        Télétravail
      {% elif is_state('switch.vacances_maison_maman', 'on') %}
        Maman
      {% else %}
        Aucun
      {% endif %}
  - name: voltalis_current_program_switch
    icon: mdi:heat-wave
    unique_id: 0A1C5E6D-B1CE-4942-B3BA-F8FE04CBD7E1
    device_class: enum
    attributes:
      options: "{{ ['none',
        'switch.quicksettings_athome',
        'switch.quicksettings_shortleave',
        'switch.quicksettings_longleave',
        'switch.normal',
        'switch.journee_rouge',
        'switch.teletravail',
        'switch.vacances_maison_maman',
        ] }}"
    state: >-
      {# Voir la documentation : https://www.voltalis.com/faq/parametrage-modes-rapides#:~:text=Vous%20pouvez%20param%C3%A9trer%20vous%2Dm%C3%AAme,%3E%20Configuration%20des%20modes%20rapides). #}
      {# Le mode rapide est prioritaire, il doit être placé au début ! #}
      {% if is_state('switch.quicksettings_athome', 'on') %}
        switch.quicksettings_athome
      {% elif is_state('switch.quicksettings_shortleave', 'on') %}
        switch.quicksettings_shortleave
      {% elif is_state('switch.quicksettings_longleave', 'on') %}
        switch.quicksettings_longleave
      {% elif is_state('switch.normal', 'on') %}
        switch.normal
      {% elif is_state('switch.journee_rouge', 'on') %}
        switch.journee_rouge
      {% elif is_state('switch.teletravail', 'on') %}
        switch.teletravail
      {% elif is_state('switch.vacances_maison_maman', 'on') %}
        switch.vacances_maison_maman
      {% else %}
        none
      {% endif %}

Puis créer deux entrées texte qui servent à restaurer le programme voltalis qui était activé avant le passage à la journée rouge :

  • input.text.voltalis_previous_program_rouge_name qui contient le nom du programme à restaurer en sortie de la journée rouge.
  • input.text.voltalis_previous_program_rouge_switch qui contient le nom du switch à restaurer en sortie de la journée rouge.

Il faut ensuite créer deux automatisations :

Pour entrée en journée rouge :

alias: Entrée jour rouge
description: >-
  Lorsque passe à un jour rouge, passe le programme en cours de Voltalis à un
  jour rouge.
triggers:
  - trigger: state
    entity_id:
      - binary_sensor.rte_tempo_heures_creuses
    from: "on"
    to: "off"
    for:
      hours: 0
      minutes: 0
      seconds: 20
conditions:
  - condition: state
    entity_id: sensor.rte_tempo_couleur_actuelle
    state: Rouge
actions:
  - action: input_text.set_value
    metadata: {}
    data:
      value: "{{ states('sensor.voltalis_current_program_switch') }}"
    target:
      entity_id: input_text.voltalis_previous_program_rouge_switch
  - action: input_text.set_value
    metadata: {}
    data:
      value: "{{ states('sensor.voltalis_current_program_name') }}"
    target:
      entity_id: input_text.voltalis_previous_program_rouge_name
  - action: switch.turn_on
    metadata: {}
    data: {}
    target:
      entity_id: switch.journee_rouge
mode: single

Pour sortir de la journée rouge :

alias: Sortie jour rouge
description: >-
 Lorsque quitte un jour rouge ou que l'on passe en heure creuse, passe le
 programme en cours de Voltalis a celui qui était mémorisé avant.
triggers:
 - trigger: state
   entity_id:
     - binary_sensor.rte_tempo_heures_creuses
   from: "off"
   to: "on"
   for:
     hours: 0
     minutes: 0
     seconds: 20
conditions:
 - condition: template
   value_template: >-
     {{ not is_state('input_text.voltalis_previous_program_rouge_switch', '')
     }}
actions:
 - action: switch.turn_on
   metadata: {}
   data: {}
   target:
     entity_id: |
       {{ states('input_text.voltalis_previous_program_rouge_switch') }}
 - action: input_text.set_value
   metadata: {}
   data:
     value: ""
   target:
     entity_id: input_text.voltalis_previous_program_rouge_switch
 - action: input_text.set_value
   metadata: {}
   data:
     value: ""
   target:
     entity_id: input_text.voltalis_previous_program_rouge_name
mode: single

Puis la carte :
Attention, les lignes vides sous < h1 >< center >< font color=#1565c0 >Voltalis< /font >< /center >< /h1 > sont a respecter sinon les étoiles sont visibles et ne passe pas le texte en gras.
Il faut ajouter la carte markdown :

square: false
type: grid
columns: 1
cards:
  - type: markdown
    content: >
      <h1><center><font color=#1565c0>Voltalis</font></center></h1>


      Le mode <font color=#1565c0>**{{
      states('sensor.voltalis_current_program_name') }}**</font> est
      actuellement actif.<br/> <font color=red>**Attention**</font>, les modes
      rapides sont prioritaires sur les autres modes.

      {% if not is_state('input_text.voltalis_previous_program_rouge_switch',
      '') %}

      Le mode <font color=#c62828>**Journée rouge**</font> a été activé
      automatiquement.<br/> Lors du passage en heure creuse, le mode <font
      color=#1565c0>**{{
      states('input_text.voltalis_previous_program_rouge_name') }}**</font> sera
      réactivé.  {% endif %}
    card_mod:
      style: >
        {% if not is_state('input_text.voltalis_previous_program_rouge_switch',
        '') %} ha-card {
          background-color: #FF60A050;
        {% endif %}
  - type: entities
    entities:
      - entity: switch.normal
        icon: mdi:radiator
        name: Mode Normal
      - entity: switch.journee_rouge
        name: Mode Journée Rouge
        icon: mdi:radiator
      - entity: switch.teletravail
        icon: mdi:radiator
        name: Mode Télétravail
      - entity: switch.vacances_maison_maman
        icon: mdi:radiator
        name: Mode Maman
      - entity: switch.quicksettings_athome
        icon: mdi:radiator
        name: "Mode rapide : A la maison"
      - entity: switch.quicksettings_shortleave
        icon: mdi:radiator
        name: "Mode rapide : Absence courte"
      - entity: switch.quicksettings_longleave
        icon: mdi:radiator
        name: "Mode rapide : Absence prolongée"
    show_header_toggle: false
    state_color: true

Voilà, c’est fait.
Amélioration : Je ne sais pas ce qui est possible et ce qui ne l’est pas.

  1. N’avoir qu’un seule sensor qui regroupe name et switch (est-ce possible ?)
  2. N’avoir qu’un seule texte qui regroupe name et switch (input.text.voltalis_previous_program_rouge_name et input.text.voltalis_previous_program_rouge_switch) (est-ce possible ?)
  3. Le mieux serait la découverte automatique des programmes dans les sensor et dans la carte !
1 « J'aime »