Bouton poussoir

Bonjour à tous,

est-il possible de changer le format du bouton des switchs en bouton poussoir
image

Idéalement j’aurais besoin que le bouton revienne dans l’état de départ.

merci

A+

Nativement :
Non tu peux pas avoir de bouton de type poussoir.
Tu peux passer par customize pour afficher les icônes au lieu du bouton pour ton switch :

image

devient
image

après customisation :
homeassistant:
  customize:
    switch.decorative_lights:
      assumed_state: false

Dans ton cas, tu dois mettre true dans customize (si tu veux afficher les 2 boutons)

Avec une carte personnalisée :
Tu peux très bien te servir d’une carte personnalisée (custom-card), pour afficher un bouton donc la couleur de fond varie suivant l’état de l’entité (ici, button-card, fait une recherche sur le forum pour voir des exemples):

bouton poussoir

Pour ça j’utilise pour ma part une automatisation (automation) :
Le déclencheur se fait sur l’état on du switch, on attends 500ms puis on passe le switch à off

automation:
  - id: 'porte_de_garage_ouverture'
    alias: porte_de_garage_ouverture
    trigger:
      platform: state
      entity_id: switch.decorative_lights
      to: 'on'
    condition: []
    action:
    - delay:
        milliseconds: 500
    - data:
        entity_id: switch.decorative_lights
      service: switch.turn_off
bouton

Je vais essayer l’automation qui devrait répondre à mes attentes.
Est-il possible de faire un seul script pour 14 switchs?

merci :wink:

:warning: Essayons de faire un effort et d’utiliser les bons termes. :blush: (surtout pour ceux qui ne sont pas à l’aise avec l’anglais)


Pour te répondre :
Tu peux faire une seule automatisation pour gérer tous tes interrupteurs. Il faut que tu utilise la fonction choose (tu trouvera un exemple ici).

Si besoin de plus d’explications, n’hésite pas.

dur de se mettre aux scripts…:smiley:

image

J’avoue que j’ai un peu de mal à comprendre,
dans l’exemple, il l’utilise pour mettre des conditions d’état.
image

pas pour sélectionner toutes ses entités?

dsl c’est encore du chinois pour moi mais ca va venir…

merci pour ton aide

L’exemple c’est moi qui l’ai écrit.

Et ce n’est pas du script mais de l’automatisation (automation). Je pense que quand tu dit script c’est pour parler de ligne de code, car dans le HA, il y a une notion de script et je voudrais pas que tu fasses l’amalgame

Je te fais un mini tutoriel ce soir.

Il n’y a rien d’insurmontable et une fois la structure expliquée, tu comprendras mieux. :+1:

trop sympa merci :+1:

1 J'aime

Non ce n’est pas ça qui est fait.

Explications :

Situation

Prenons l’exemple suivant : Nous avons 3 interrupteurs et nous voulons que si l’un d’eux est activé, qu’il se désactive au bout de 2 secondes. Cela peut se faire par une automatisation (automation en anglais).

Automatisation

Déclencheur(s)

En premier lieu, il faut récupérer l’information qu’un des interrupteurs est activé. Cela se passe par la plateforme state (documentation):

    - platform: state #Surveillance de l'état
      entity_id: switch.interrupteur_01 #Entité à surveiller
      to: 'on' #Déclenché l'automation si l'entité passe à cet état

Ce bout de code permet de définir le déclenchement des actions de l’automatisation si l’entité switch.interrupteur_01 passe à l’état on.

Action(s)

Une fois que tu as défini tous tes déclencheurs, il faut maintenant indiquer quelles sont les actions que tu souhaites réaliser :

    action:
        ###################################################################################################
        ## Temporisation suivant l'état de l'entité input_datetime.desactivation_automatique_temps
        ## Si tu veux, tu peux coder en 'dure' le delai (https://www.home-assistant.io/docs/scripts/#delay)
      - delay: "{{ states('input_datetime.desactivation_automatique_temps') }}"
        ###################################################################################################
      
        #############################################
        ## Utilisation de la fonction 'choose' (https://www.home-assistant.io/docs/scripts/#choose-a-group-of-actions)
      - choose:
          - conditions: #Premiere condition vérifiéee
              #interrupteur_01
              - condition: state
                entity_id: switch.interrupteur_01
                state: "on"
            sequence:
              - service: switch.turn_off
                entity_id: switch.interrupteur_01
                
          - conditions:#Deuxième condition vérifiée (si vérification de la première échouée)
            #interrupteur_02
              - condition: state
                entity_id: switch.interrupteur_02
                state: "on"
            sequence:
              - service: switch.turn_off
                entity_id: switch.interrupteur_02
                
          - conditions:#Troisième condition vérifiée (si vérification de la deuxième échouée)
            #interrupteur_03
              - condition: state
                entity_id: switch.interrupteur_03
                state: "on"
            sequence:
              - service: switch.turn_off
                entity_id: switch.interrupteur_03

:information_source: L’interprétation de la fonction choose est la suivante :
Comme on ne sait pas quel interrupteur à déclenché l’automatisation, on va vérifier un par un leur état.
La fonction choose est séquentielle, c’est à dire qu’elle vérifie un par un tous les interrupteurs.
Si elle vérifie la condition, elle exécute la ou les actions définies puis s’interrompt.
dans ton cas, la fonction choose ne vérifiera pas le deuxième interrupteur si et seulement si le premier est à l’état on.

Au final

Voici donc le code complet, contenant l’automatisation et l’heure (pour la définition de la temporisation)

input_datetime:
  desactivation_automatique_temps:
    name: Temporisation avant désactivation des interrupteurs
    has_date: false
    has_time: true

automation:
  - id: 'desactivation_automatique_automatisation' #identifiant unique
    alias: desactivation_automatique_automatisation # Nom présent dans l'interface Lovelace
    mode: parallel #Permet l'appel multiple à cette automatisation
    max: 3 #Le nombre de tes interrupteurs
    trigger: #Défintion des déclencheurs
    
      ###############################################################
    - platform: state #Surveillance de l'état
      entity_id: switch.interrupteur_01 #Entité à surveiller
      to: 'on' #Déclenché l'automation si l'entité passe à cet état
      ################################################################
      
      ################################################################
    - platform: state
      entity_id: switch.interrupteur_02
      to: 'on'
      ################################################################
      
      ################################################################
    - platform: state
      entity_id: switch.interrupteur_03
      to: 'on'
      ################################################################
      
    condition: [] #Pas de conditions dans ton cas
    action:
        ###################################################################################################
        ## Temporisation suivant l'état de l'entité input_datetime.desactivation_automatique_temps
        ## Si tu veux, tu peux coder en 'dure' le delai (https://www.home-assistant.io/docs/scripts/#delay)
      - delay: "{{ states('input_datetime.desactivation_automatique_temps') }}"
        ###################################################################################################
      
        #############################################
        ## Utilisation de la fonction 'choose' (https://www.home-assistant.io/docs/scripts/#choose-a-group-of-actions)
      - choose:
          - conditions: #Premiere condition vérifiéee
              #interrupteur_01
              - condition: state
                entity_id: switch.interrupteur_01
                state: "on"
            sequence:
              - service: switch.turn_off
                entity_id: switch.interrupteur_01
                
          - conditions:#Deuxième condition vérifiée (si vérification de la première échouée)
            #interrupteur_02
              - condition: state
                entity_id: switch.interrupteur_02
                state: "on"
            sequence:
              - service: switch.turn_off
                entity_id: switch.interrupteur_02
                
          - conditions:#Troisième condition vérifiée (si vérification de la deuxième échouée)
            #interrupteur_03
              - condition: state
                entity_id: switch.interrupteur_03
                state: "on"
            sequence:
              - service: switch.turn_off    
                entity_id: switch.interrupteur_03

Et voici un aperçu du résultat dans Lovelace (peut être les boutons bascule que tu voulais ?) :

Code de la carte (utilisation de card-mod)
type: vertical-stack
cards:
  - type: horizontal-stack
    title: Définition de la temporisation
    cards:
      - type: button
        tap_action:
          action: call-service
          service: input_datetime.set_datetime
          service_data:
            entity_id: input_datetime.desactivation_automatique_temps
            time: '00:00:02'
        name: Secondes
        icon: 'mdi:numeric-2-box-outline'
        icon_height: 100px
        hold_action:
          action: none
        entity: input_datetime.desactivation_automatique_temps
        style: |
          ha-card{ 
            opacity:
              {% if states(config.entity) == "00:00:02" %}
                    1
              {% else %}
                    0.33
              {% endif %}
              ;
            }
      - type: button
        tap_action:
          action: call-service
          service: input_datetime.set_datetime
          service_data:
            entity_id: input_datetime.desactivation_automatique_temps
            time: '00:00:05'
        name: Secondes
        icon: 'mdi:numeric-5-box-outline'
        icon_height: 100px
        hold_action:
          action: none
        entity: input_datetime.desactivation_automatique_temps
        style: |
          ha-card{ 
            opacity:
              {% if states(config.entity) == "00:00:05" %}
                    1
              {% else %}
                    0.33
              {% endif %}
              ;
            }
      - type: button
        tap_action:
          action: call-service
          service: input_datetime.set_datetime
          service_data:
            entity_id: input_datetime.desactivation_automatique_temps
            time: '00:00:10'
        name: Secondes
        icon: 'mdi:numeric-10-box-outline'
        icon_height: 100px
        hold_action:
          action: none
        entity: input_datetime.desactivation_automatique_temps
        style: |
          ha-card{ 
            opacity:
              {% if states(config.entity) == "00:00:10" %}
                    1
              {% else %}
                    0.33
              {% endif %}
              ;
            }
              
  - type: horizontal-stack
    title: Interrupteurs
    cards:
      - type: button
        tap_action:
          action: toggle
        entity: switch.interrupteur_01
        icon: 'mdi:alpha-a-circle-outline'
        show_name: false
        show_icon: true
        icon_height: 100px
      - type: button
        tap_action:
          action: toggle
        entity: switch.interrupteur_02
        icon: 'mdi:alpha-b-circle-outline'
        show_name: false
        show_icon: true
        icon_height: 100px
      - type: button
        tap_action:
          action: toggle
        entity: switch.interrupteur_03
        icon: 'mdi:alpha-c-circle-outline'
        show_name: false
        show_icon: true
        icon_height: 100px

Bonus

Et si j’ai 14 interrupteurs ? L’automation va comporter énormément de ligne !

C’est vrai ! Mais ce n’est pas grave, une automation peux comporter autant de ligne que nécessaire. Mais au delà d’un certain nombre (à la convenance du codeur), il est peut être utile d’exécuter des scripts depuis l’automatisation.

Mais après avoir lu la documentation, on se rend compte que l’on peux tout de même améliorer cette automatisation (et gagner énormément de lignes) avec l’utilisation du modèle (comprendre , balise remplacée par HA, lors de l’exécution de la commande. Template en anglais)

automation:
  - id: 'desactivation_automatique_automatisation_avec_trigger'
    alias: desactivation_automatique_automatisation_avec_trigger
    mode: parallel #Permet l'appel multiple à cette automatisation
    max: 3 #Le nombre de tes interrupteurs
    trigger:
    - platform: state
      entity_id: switch.interrupteur_01
      to: 'on'
    - platform: state
      entity_id: switch.interrupteur_02
      to: 'on'
    - platform: state
      entity_id: switch.interrupteur_03
      to: 'on'
    condition: []
    action:
      - delay: "{{ states('input_datetime.desactivation_automatique_temps') }}"
      - service: switch.turn_off
        data:
          entity_id: "{{ trigger.entity_id }}"
          #trigger contient l'objet qui a déclenché l'automatisation
          # On souhaite ici, remettre à zéro l'entité est passée à 'on'

Dans cette automatisation, tu définis tous tes déclencheurs, et une seule action.

Voilà, si tu as des questions, n’hésite pas. :+1:

n’hésitez pas à mettre un :heart: si vous avez appris quelque chose

:warning: Ce petit bout de code est à mettre soit dans le fichier automations.yaml, soit en accord avec votre méthode de configuration partagée

7 J'aime

Top ton investissement!

1 J'aime

J’ai bien galéré au début tout seul…donc maintenant j’en fais profité les autres…

Mais des réponses comme celle-ci prennent du temps c’est sûr… :innocent:

2 J'aime

Je n’en demandais pas temps!! :smiley:
Sacré boulot, un grand merci! :+1:

Il va falloir maintenant l’intégrer à HA et surtout à mon cerveau… :smiley:

je vais faire des tests et je reviendrais vers toi pour te tenir au courant.

A+ et merci encore :wink:

1 J'aime

Super tuto! Il va me servir pour faire une automation pour alerter quand mes sensors ont leur batterie qui chute en dessous de 3.7V

2 J'aime

j’ai intégré ce code dans la conf mais ce n’est pas bon!

automation:
- id: 'desactivation_automatique_automatisation_avec_trigger'
alias: desactivation_automatique_automatisation_avec_trigger
mode: parallel #Permet l'appel multiple à cette automatisation
max: 6 #Le nombre de tes interrupteurs
trigger:
- platform: state
  entity_id: switch.1
  to: 'on'
- platform: state
  entity_id: switch.2
  to: 'on'
- platform: state
  entity_id: switch.3
  to: 'on'
- platform: state
  entity_id: switch.4
  to: 'on'
- platform: state
  entity_id: switch.5
  to: 'on'
- platform: state
  entity_id: switch.6
  to: 'on'
condition: []
action:
  - delay: 1
  - service: switch.turn_off
    data:
      entity_id: "{{ trigger.entity_id }}"
      #trigger contient l'objet qui a déclenché l'automatisation
      # On souhaite ici, remettre à zéro l'entité est passée à 'on'

sur le delay, il est indiqué que l’on peut mettre 1 pour 1secondes
mais je dois faire une erreur, je n’ai pas tout bien compris encore.
pas mal de concept m’échappe pour l’instant.

Merci de fournir plus d’informations…
L’automatisation est-elle présente dans HA ?
Que dit le log home-assistant.log ?

De ce que je vois, de ce que tu as posté, ton indentation n’est pas bonne.

Pas d’erreur sur le delay (documentation).
Je te conseille tout de même, pour le jour où tu reviendras sur cette automatisation, de mettre le delay sous cette forme, beaucoup plus compréhensible :

- delay: '00:00:01'

ou sinon avec toutes les options de disponible :

- delay:
    milliseconds: 0
    seconds: 1
    minutes: 0
    hours: 0
    days: 0

j’ai réussi à faire fonctionner l’automatisation.
au depart j’avais intégré le code au fichier configuration.yaml
il trouvait 2 lignes « automation », j’ai vu qu’il y avait un fichier pour les automatisations « automations.yaml »
j’ai donc intégré le code et tout est ok.
je t’ai dis que j’étais un noob!! :smiley:

Un grand merci à toi @Clemalex

A+

N’hésite pas à marquer le post qui t’a aidé en solution pour l’indiquer aux autres.

@Captain, j’ai mis une petite explication en fin de réponse de mon premier post. Merci de ton retour :+1:

C’est fait, encore merci pour le taf!! :clap:

1 J'aime

Hello @Captain
Merci pour cette solution alternative.
Pour ma part je cherchais effectivement à « convertir » un bouton classique en bouton poussoir qui revenait à l’état d’origine.
Je suis passé par node-red et MQTT avec l’API de HA pour réaliser ça :

[
    {
        "id": "7bcfb492.596d6c",
        "type": "mqtt in",
        "z": "12339730.c71e41",
        "name": "Ouverture portail ON",
        "topic": "homeassistant/switch/fibaro_system_unknown_type_0204_id_1000_switch/state",
        "qos": "2",
        "datatype": "auto",
        "broker": "d32f05f2.4d0038",
        "x": 120,
        "y": 80,
        "wires": [
            [
                "b82219b.9f65a68"
            ]
        ]
    },
    {
        "id": "b82219b.9f65a68",
        "type": "switch",
        "z": "12339730.c71e41",
        "name": "Portail State ON",
        "property": "payload",
        "propertyType": "msg",
        "rules": [
            {
                "t": "eq",
                "v": "on",
                "vt": "str"
            }
        ],
        "checkall": "true",
        "repair": false,
        "outputs": 1,
        "x": 378,
        "y": 80,
        "wires": [
            [
                "db5cbdbc.ad11c"
            ]
        ]
    },
    {
        "id": "db5cbdbc.ad11c",
        "type": "delay",
        "z": "12339730.c71e41",
        "name": "",
        "pauseType": "delay",
        "timeout": "1",
        "timeoutUnits": "milliseconds",
        "rate": "1",
        "nbRateUnits": "1",
        "rateUnits": "second",
        "randomFirst": "1",
        "randomLast": "5",
        "randomUnits": "seconds",
        "drop": false,
        "x": 568,
        "y": 80,
        "wires": [
            [
                "184d677f.7b10b1"
            ]
        ]
    },
    {
        "id": "184d677f.7b10b1",
        "type": "change",
        "z": "12339730.c71e41",
        "name": "Button OFF",
        "rules": [
            {
                "t": "set",
                "p": "payload",
                "pt": "msg",
                "to": "{\"entity_id\":\"switch.fibaro_system_unknown_type_0204_id_1000_switch\"}",
                "tot": "str"
            },
            {
                "t": "set",
                "p": "query.device_type",
                "pt": "msg",
                "to": "switch",
                "tot": "str"
            },
            {
                "t": "set",
                "p": "query.service",
                "pt": "msg",
                "to": "turn_off",
                "tot": "str"
            }
        ],
        "action": "",
        "property": "",
        "from": "",
        "to": "",
        "reg": false,
        "x": 748,
        "y": 80,
        "wires": [
            [
                "d3726856.ed567"
            ]
        ]
    },
    {
        "id": "d3726856.ed567",
        "type": "link out",
        "z": "12339730.c71e41",
        "name": "",
        "links": [
            "acca563f.6da948"
        ],
        "x": 873,
        "y": 80,
        "wires": []
    },
    {
        "id": "d32f05f2.4d0038",
        "type": "mqtt-broker",
        "name": "MQTT BROKER",
        "broker": "192.168.X.X",
        "port": "1883",
        "clientid": "",
        "usetls": false,
        "compatmode": false,
        "keepalive": "60",
        "cleansession": true,
        "birthTopic": "",
        "birthQos": "0",
        "birthPayload": "",
        "closeTopic": "",
        "closeQos": "0",
        "closePayload": "",
        "willTopic": "",
        "willQos": "0",
        "willPayload": ""
    }
]

Et ça fonctionne plutôt bien !

@plus

1 J'aime