Automatisation avec input_number.cover

Bonjour je commence à créer des automatisations qui fonctionnent bien.

Mais je cherche à pouvoir modifier certaines valeurs/constantes de mon code sans avoir à intervenir dans le code mais par interface graphique.

Je suis donc parti pour utiliser les « input_number.cover » après pas mal d’essais j’ai trouver la bonne écriture, enfin je veux dire qui fonctionne pour un délai :

`delay: '{{(states("input_number.cover_delaifermeture") | int)}}'

En revanche je galère pour une position du tip :

position: 80 => position : 100- states("input_number.cover)

Et j’ai une action que j’effectue xx ;minute avant le lever ou coucher du soleil

offset: -00:15 je voudrais pouvoir piloter mon -00;15 depuis mon interface.

Prouvez vous m’aider à comprendre comment manipuler input_number.cover car ma première réussite est une adaptation d’un exemple et doit tenir du coup de chance car je ne compare pas tout.

En vous remerciant d’avance.

Salut mets les partie code dans les balise codes stp sinon ca devient vite illisible et cela permettra de voir si il y des problemes d’indentation.

Je vous prie de bien vouloir excuser mon oublie

Lol pas de soucis t’inquiete

De quelles valeurs/constantes parles-tu ? Ok je vois deux choses, modification de l’offset du soleil via l’interface, et une autre au sujet de la position d’un volet ?

Oui je suis en appartement et pour éviter de coincer quelqu’un sur le balcon

j’ai écrié cela et pour apprendre je cherche à pouvoir modifier des paramétré du code depuis l’interface graphique

fermeture_volet_securiser:
  alias: Fermeture volet securiser
  sequence:
  - choose:
    - conditions:
      - condition: state
        entity_id: input_boolean.cover_fermeturesecuriser
        state: 'on'
      sequence:
      - device_id: 7c2726e3059011ebaae9f308c0dc7bdd
        domain: cover
        entity_id: cover.shenzhen_neo_electronics_co_ltd_unknown_type_0200_id_102c_level
        type: set_position
        position: 80
        #position: (states("input_number.cover_pourcent_fermeture") | int)
        
      - delay: '{{(states("input_number.cover_delaifermeture") | int)}}'
      - device_id: 7c2726e3059011ebaae9f308c0dc7bdd
        domain: cover
        entity_id: cover.shenzhen_neo_electronics_co_ltd_unknown_type_0200_id_102c_switch
        type: close
    - conditions:
      - condition: state
        entity_id: input_boolean.cover_fermeturesecuriser
        state: 'off'
      sequence:
      - device_id: 7c2726e3059011ebaae9f308c0dc7bdd
        domain: cover
        entity_id: cover.shenzhen_neo_electronics_co_ltd_unknown_type_0200_id_102c_switch
        type: close
    default: []
  mode: single
  icon: mdi:window-shutter

Je pense qu’il faut que tu comprennes mieux les outils que tu utilises. La demarche est la bonne, mais l’utilisation est moins compréhensible.
input_number.cover n’est pas réellement une solution en elle meme (en tout cas, pas pour l’offset du soleil par exemple).

Dans un premier temps, input_number est une intégration. Elle te donne accès aux états et aux informations d’une entité (différemment dit: un équipement). input_number.cover on peut dire que c’est une entité unique pour un cover.

Du coup toi tu cherches à modifier l’état d’une intégration (par exemple input_number.la_position_souhaitee_de_mon_volet) afin d’utiliser cette valeur ailleurs?

Pour ca il faut comprendre que l’intégration input_number ne peut contenir qu’une donnée « nombre » au millième prêt (donc pas d’offset comme 00:15).

Par contre tu as effectivement des moyens de modifier ces valeurs via l’interface en ajoutant une carte entité, et en renseignant l’entité input_number.la_position_souhaitee_de_mon_volet.

Pour ton besoin, tu peux utiliser input_number qui peut renseigner une position ou un delay en nombre. Mais tu peux aussi utiliser input_datetime, qui peut renseigner un delay, ou un offset (ex: 00:15).

Verifie bien la documentation de ces deux integrations. Crées les deux. Puis ajoute deux cartes entité dans ton interface avec ces deux entites là. Une fois que cela est fait, tu pourras t’aider des deux parametre d’etat states(« input_number.xxx ») ou states(« input_datatime.yyy »)


1 « J'aime »

Hoo!!! Un très gros merci je n’avais pas vu que l’on pouvait intégrer par là je passais par le code.

@Nyco :

Ci dessous le code qui permet de gérer le décalage horaire (offset) du coucher de soleil de l’entité sun.sun sur +/- 59 minutes.

Je suis partis du principe que l’attribut next_setting de cette entité représente l’heure du coucher de soleil.

  1. Pour gérer le décalage, un input_number est utilisé :
input_number:
  volet_salon_decalage:
    name: "Volet Décalage en minutes"
    min: -59
    max: 59
    step: 1
  1. On récupère et converti l’état (state) de cette entité pour la stocker dans un input_datetime :
input_datetime:
  decalage_coucher_de_soleil:
    name: "décalage de l'heure du coucher de soleil"
    has_date: false
    has_time: true
automation:
    #Automatisation qui détermine l'heure du coucher de soleil
  - id: 'décalage_determination_de_l_heure'
    alias: décalage_determination_de_l_heure
    trigger:
      - platform: state
        entity_id: input_number.volet_salon_decalage   
      - platform: state
        entity_id: sun.sun
      - platform: homeassistant
        event: start
    condition:
    action:
      - service: input_datetime.set_datetime
        entity_id: input_datetime.decalage_coucher_de_soleil
        data:
            time: >
              {% set taille_du_tableau = states('input_number.volet_salon_decalage').split('-')|length %}
              {% if taille_du_tableau == 1 %}
                {# Décalage positif #}
                {{ "00:" + states('input_number.volet_salon_decalage').split('-')[0]|int|string + ":00" }}
              {% else %}
                {# Décalage négatif #}
                {{ "00:" + states('input_number.volet_salon_decalage').split('-')[1]|int|string + ":00" }}
              {% endif %}
  1. On détermine la nouvelle heure du coucher de soleil dans un autre input_datetime :
input_datetime:
  heure_coucher_de_soleil_avec_decalage:
    name: "Heure coucher de soleil avec décalage"
    has_date: false
    has_time: true

automation:
    #Automatisation qui détermine l'heure du coucher de soleil
  - id: 'décalage_determination_de_l_heure'
    alias: décalage_determination_de_l_heure
    trigger:
      - platform: state
        entity_id: input_number.volet_salon_decalage   
      - platform: state
        entity_id: sun.sun
      - platform: homeassistant
        event: start
    condition:
    action:
      - service: input_datetime.set_datetime
        entity_id: input_datetime.heure_coucher_de_soleil_avec_decalage
        data:
            time: >
              {% set taille_du_tableau = states('input_number.volet_salon_decalage').split('-')|length %}
              {% if taille_du_tableau == 1 %}
                {# Décalage positif #}
                {{  ( as_timestamp(state_attr('sun.sun', 'next_setting')) | int
                       + 
                       state_attr('input_datetime.decalage_coucher_de_soleil', 'timestamp') | int 
                    )| timestamp_custom('%H:%M', true)
                }}
              {% else %}
                {# Décalage négatif #}
                {{  ( as_timestamp(state_attr('sun.sun', 'next_setting')) | int
                       - 
                       state_attr('input_datetime.decalage_coucher_de_soleil', 'timestamp') | int 
                    )| timestamp_custom('%H:%M', true)
                }}
              {% endif %}

Maintenant, l’entité input_datetime.heure_coucher_de_soleil_avec_decalage contient la nouvelle horaire du coucher de soleil incluant le décalage qui est réglable dans Lovelace.

  1. Il reste donc à utiliser cette entité comme déclencheur (trigger) dans les automatisations :
  - id: 'décalage_coucher_de_soleil'
    alias: décalage_coucher_de_soleil
    trigger:
      platform: time
      at: input_datetime.decalage_coucher_de_soleil
    condition:
    action:
      - service: persistent_notification.create
        data:
          message: "Décalage de  {{ states('input_datetime.decalage_coucher_de_soleil') }}"
          title: "Décalage configurable"
          notification_id: "{{ (range(1, 9999)|random) }}"

Ce qui donne dans un fichier en mode packages

sensor:
  - platform: time_date
    display_options:
      - 'time'

input_number:
  volet_salon_decalage:
    name: "Volet Décalage en minutes"
    min: -59
    max: 59
    step: 1

input_datetime:
  decalage_coucher_de_soleil:
    name: "décalage de l'heure du coucher de soleil"
    has_date: false
    has_time: true
  heure_coucher_de_soleil_avec_decalage:
    name: "Heure coucher de soleil avec décalage"
    has_date: false
    has_time: true

automation:
    #Automatisation qui détermine l'heure du coucher de soleil
  - id: 'décalage_determination_de_l_heure'
    alias: décalage_determination_de_l_heure
    trigger:
      - platform: state
        entity_id: input_number.volet_salon_decalage   
      - platform: state
        entity_id: sun.sun
      - platform: homeassistant
        event: start
    condition:
    action:
      - service: input_datetime.set_datetime
        entity_id: input_datetime.decalage_coucher_de_soleil
        data:
            time: >
              {% set taille_du_tableau = states('input_number.volet_salon_decalage').split('-')|length %}
              {% if taille_du_tableau == 1 %}
                {# Décalage positif #}
                {{ "00:" + states('input_number.volet_salon_decalage').split('-')[0]|int|string + ":00" }}
              {% else %}
                {# Décalage négatif #}
                {{ "00:" + states('input_number.volet_salon_decalage').split('-')[1]|int|string + ":00" }}
              {% endif %}
      - service: input_datetime.set_datetime
        entity_id: input_datetime.heure_coucher_de_soleil_avec_decalage
        data:
            time: >
              {% set taille_du_tableau = states('input_number.volet_salon_decalage').split('-')|length %}
              {% if taille_du_tableau == 1 %}
                {# Décalage positif #}
                {{  ( as_timestamp(state_attr('sun.sun', 'next_setting')) | int
                       + 
                       state_attr('input_datetime.decalage_coucher_de_soleil', 'timestamp') | int 
                    )| timestamp_custom('%H:%M', true)
                }}
              {% else %}
                {# Décalage négatif #}
                {{  ( as_timestamp(state_attr('sun.sun', 'next_setting')) | int
                       - 
                       state_attr('input_datetime.decalage_coucher_de_soleil', 'timestamp') | int 
                    )| timestamp_custom('%H:%M', true)
                }}
              {% endif %}

  - id: 'décalage_coucher_de_soleil'
    alias: décalage_coucher_de_soleil
    trigger:
      platform: time
      at: input_datetime.decalage_coucher_de_soleil
    condition:
    action:
      - service: persistent_notification.create
        data:
          message: "Décalage de  {{ states('input_datetime.decalage_coucher_de_soleil') }}"
          title: "Décalage configurable"
          notification_id: "{{ (range(1, 9999)|random) }}"
2 « J'aime »

Hello, j’en profite pour une précision, le fichier en mode packages est intégré comment dans le configuration.yaml par exemple ?

Essayez de profiter de la recherche et de l’indexation :+1: :

C’était une précision demandée dans son contexte concret à lui.

La question arrivera toute seule…

Comme c’est souvent le cas (ma réponse est juste en dessous)

1 « J'aime »

@Clemalex:
Un gros merci pour ton travail. il y a beaucoup de chose que je ne comprend pas. Il va me falloir du temps pour comprendre tout, ça me change du vba et c.

Auriez vous des cours/tutoriels en fr de préférence pour commencer sur de bonne basse ?

1 « J'aime »

Pas à ma connaissance…

Mais n’hésite pas à extraire des bout de code et demander :+1:

Beaucoup d’exemple sur ce forum et énormément plus sur la communauté mondiale

Bon j’ai refais les intégrations et je bloc

      - delay: '{{(states("input_number.delai_avant_fermeture") | int)}}'

c’est ligne fonctionne mais je ne sais pas si elle est écrite dans les règles de l’art et je ne comprend pas sa syntaxe. Pouvez vous me l’expliquer s’il vous plaît afin que je puisse écrire correctement la ligne suivante qui pour le moment me pause problème.

position: {{(states("input_number.pourcentage_de_pre_fermeture_du_volet_de_la_baie_vitree") | int)}}

@Nyco :

En lisant la documentation du delay, on s’aperçoit qu’il y a plusieurs façon de l’utiliser :

  1. Seulement un nombre représentant des secondes (donc on peut utiliser un input_number)
# Seconds
# Waits 5 seconds
- delay: 5

est équivalent à :

#Déclaration de l'entité
# Example configuration.yaml entry
input_number:
  temporisation:
    name: "Temporisation modifiable dans Lovelace et par automatisations/scripts"
    min: 0
    max: 60
    step: 1
     
 #Utilisation de l'entité pour l'action delay
 # X secondes
- delay: {{ states('input_number.temporisation') | int }}

L’utilisation de la fonction states() renvoie un texte (string) alors que l’action delay dans ce cas attend un nombre (integer). On obtient un nombre en convertissant l’état renvoyé à l’aide de l’utilisation d’un filtre (filter) Jinja en l’occurrence int.

Dans l’exemple ci dessus, la temporisation ne pourra pas dépasser 1 minute (max: 60 ).

  1. Avec un format HH:MM (ou HH:MM:SS) (donc on peut utiliser un input_datetime)
# HH:MM
# Waits 1 hour
- delay: '01:00'

est équivalent à :

#Déclaration de l'entité
input_datetime:
  temporisation:
    name: "Temporisation modifiable dans Lovelace et par automatisations/scripts"
    has_date: false
    has_time: true
 
 #Utilisation de l'entité pour l'action délay
 # HH:MM:SS
- delay: "{{ states('input_datetime.temporisation') }}"

Ici, l’action attends un texte donc pas de conversion à faire. Il faut simplement englober la formule et ne pas utiliser les mêmes que dans la formules : on englobe avec des guillemets " car la formule utilise déjà des apostrophes '.

  1. Avec toutes les clés définies :
#Temporisation de 1 minute et 30 secondes
- delay:
    days: 0
    hours: 0
    minutes: 1
    seconds: 30
    milliseconds: 0

est équivalent à :

#Déclaration de l'entité
input_number:
  temporisation_heures:
    name: "Temporisation (H)"
    min: 0
    max: 24
    step: 1
input_number:
  temporisation_minutes:
    name: "Temporisation (m)"
    min: 0
    max: 59
    step: 1
input_number:
  temporisation_secondes:
    name: "Temporisation (s)"
    min: 0
    max: 59
    step: 1
 #Utilisation de l'entité pour l'action délay
 # HH:MM:SS
- delay:
    hours: {{ states('input_number.temporisation_heures') | int }}
    minutes: {{ states('input_number.temporisation_minutes') | int }}
    seconds: {{ states('input_number.temporisation_secondes') | int }}

Du coup, pour ton code :

position: {{(states("input_number.pourcentage_de_pre_fermeture_du_volet_de_la_baie_vitree") | int)}}

Tu récupère l’état de l’entité input_number.pourcentage_de_pre_fermeture_du_volet_de_la_baie_vitree :

position: {{ states("input_number.pourcentage_de_pre_fermeture_du_volet_de_la_baie_vitree") }}

Mais comme la clé position attend un nombre, il faut convertir l’état en nombre d’où | int :

position: {{ states("input_number.pourcentage_de_pre_fermeture_du_volet_de_la_baie_vitree") | int }}

Et donc pour reprendre ton code du premier post :

position: {{ 100 - ( states("input_number.pourcentage_de_pre_fermeture_du_volet_de_la_baie_vitree") | int ) }}`

Pour pouvoir retourner une valeur calculée, il faut indiquer à l’interpréteur où se trouve ton calcul d’où les accolades {{ }}(qui manquent dans ton premier post pour la position).

Elles indiquent à l’interpréteur que le texte à l’intérieur est du code :

  • {{ le code ici }} : fait le traitement du code et renvoie la valeur dans la clé
  • {% %} : fait le traitement du code mais ne renvoie pas de valeur (utilisé pour les affectations)
  • : > ou : | : indique à l’interpréteur que le code se trouve sur plusieurs ligne. C’est l’indentation qui fixe le début et la fin du code (généralement 2 espaces après le début de la clé)

Un exemple concret avec ton code serait :

position: >
  {% set Position_Ouverte = 100 %}
  {% set Position_Pre_Fermeture = states("input_number.pourcentage_de_pre_fermeture_du_volet_de_la_baie_vitree") | int %}
  {{ Position_Ouverte - Position_Pre_Fermeture  }}

Des questions ? Attention ! Car tu auras des réponses ! :wink:

3 « J'aime »

Effectivement, et quelle réponse ! Je te remercie pour cette superbe réponse, tu me donnes plein de clés de compréhension. Ce qui va bien m’aider à décrypter ta première réponse avec toutes les manipulations pour le décalage lever du soleil.

Dans ton explication tu parles de ne pas pouvoir dépasser les 60 secondes, j’avais testé avant ton explication et effectuer un test de 180 secondes qui fonctionne à moins qu’il ai une subtilité qui m’échappe je ne vois pas pourquoi on ne peut pas dépasser la minute si l’on raisonne toujours en seconde.

En revanche je n’arrive toujours pas à faire fonctionner le code de position.
Si je rentre la ligne de code :

position: {{ states("input_number.pourcentage_de_pre_fermeture_du_volet_de_la_baie_vitree") | int }}

lors de la vérification du serveur j’obtiens le message suivant :

Error loading /config/configuration.yaml: invalid key: "OrderedDict([('states("input_number.pourcentage_de_pre_fermeture_du_volet_de_la_baie_vitree") | int', None)])"
  in "/config/scripts.yaml", line 15, column 0

J’ai encore une petite question, je cherche à écrire quelque chose du type :

message: {{ 100 - ( states("input_number.pourcentage_de_pre_fermeture_du_volet_de_la_baie_vitree") | int ) }}`

afin de pouvoir visualiser les valeurs que les lignes me renvoient. Je te remercie encore du temps que tu m’accordes.

Si tu trouve mon post utile n’oublie pas de mettre un :heart:

Oui, car c’est la définition de l’entité utilisée dans l’exemple :

input_number:
  temporisation:
    name: "Temporisation modifiable dans Lovelace et par automatisations/scripts"
    min: 0
    max: 60    #<--- La valeur maximale définie ici représente la valeur maximale du délais
    step: 1

Pour avoir un maximum de 20 min par exemple, il faut revoir la définition de l’entité comme ceci :

input_number:
  temporisation:
    name: "Temporisation modifiable dans Lovelace et par automatisations/scripts"
    min: 0
    max: 1200 #<--- 20 min maximum
    step: 1

Montre nous le contenu de ton fichier scripts.yaml car column 0 semble indiquer une erreur d’indentation (mais , None semble indiquer que la valeur n’est pas récupérée et donc que ça plante sur le filtre car l’interpréteur ne sait pas filtrer sur une valeure nulle) ou peut être encore un problème d’englobement.

Tout se passe dans la partie Outils de développement :

1 « J'aime »

Désolé je n’ai pas encore le réflexe.

je pensais que c’était par rapport au code en lui-même et par rapport à l’entité car pour l’entité j’avais mis une valeur me permettant les trois minutes.

Voici mon code de script:

fermeture_securiser_du_volet_de_la_baie_vitree:
  alias: Fermeture sécuriser du volet de la baie vitrée
  sequence:
  - choose:
    - conditions:
      - condition: state
        entity_id: input_boolean.fermeture_securisee_du_volet
        state: 'on'
      sequence:
      - device_id: 094433a079fc3abacb93177271540c77
        domain: cover
        entity_id: cover.shenzhen_neo_electronics_co_ltd_unknown_type_0200_id_102c_level
        type: set_position
        #position: 85
        position: {{ 100 - ( states("input_number.pourcentage_de_pre_fermeture_du_volet_de_la_baie_vitree") | int ) }}`
      - delay: '{{(states("input_number.delai_avant_fermeture") | int)}}'
      #- delay: '60'
      - device_id: 094433a079fc3abacb93177271540c77
        domain: cover
        entity_id: cover.shenzhen_neo_electronics_co_ltd_unknown_type_0200_id_102c_switch
        type: close
    default:
    - device_id: 094433a079fc3abacb93177271540c77
      domain: cover
      entity_id: cover.shenzhen_neo_electronics_co_ltd_unknown_type_0200_id_102c_switch
      type: close
  mode: single

un gros merci pour le tuyau des outils de développeur. Très utile!!

1 « J'aime »