Installer la carte Météo France

Entraide Home Assistant
46

J’ai fait en sorte de franciser le maximum pour la compréhension (mais je mettrais les termes en anglais entre parenthèses) :wink:

Pour faire ce veux @Galadan (remplacer sur la carte Météo-France la température affichée par son capteur extérieur pour une meilleur représentativité), il faut que les entités (sensors) soient jumelles dans leur état (state) et attributs (attributs) pour fonctionner avec la carte.

Soient elles le sont nativement, et on n’a rien d’autre à faire que de remplacer dans la carte météo-france (faut pas réver… :sleepy:), on demande au créateur de la carte de faire en sorte d’ajouter un paramètre supplémentaire dans la configuration de la carte (être gentil et courtois dans sa demande :heart:), soit on passes par un modèle (template).

Je vais pour ma part, vous montrer comment faire avec un modèle (template), @Galadan, rien ne t’empêche de demander l’évolution :+1:.

Pré-requis

:warning: Testé avec la version 1.12 de la carte et Home Assistant Core 0.118 pour l’intégration

  1. Avoir ajouté l’intégration Météo-France
  2. Avoir installé via HACS (ou manuellement) la carte Météo-France (custom-card)

Quelle est l’entité qui sert à afficher la température ?

Pour savoir quoi modifier, il faut savoir ce que la carte utilise pour afficher la température :

  1. On se rend sur notre tableau de bord (dashboard) et on ajoute la carte avec seulement l’entité (sensor) :
type: 'custom:meteo-france-weather-card'
entity: weather.bordeaux

Ce qui donne :

animate

Il faut donc dupliquer l’entité weather.bordeaux (à adapter avec ton entité :wink: ).

Dupliquer une entité

Pour dupliquer une entité, ma façon de faire est de passer par un modèle (template).

Créer une entité

  1. Direction le fichier de configuration configuration.yaml et ajouter la ligne suivante (à adapter suivant la méthode de configuration mise en place) :
#configuration.yaml
sensor:
  - platform: template
    sensors:
      weather_bordeaux:
        value_template: ""

Après un redémarrage du serveur, l’entité sensor.weather_bordeaux est disponible (Outils de développement -> Onglet États) :

image
image876×187 6.31 KB

:eyes: :face_with_raised_eyebrow: :expressionless:
« Mais elle est vide ! »

:thinking:
Pour cela, on va passer par un script python :innocent:.

Script Python

Activation des scripts

  1. Direction le fichier de configuration configuration.yaml et ajouter la ligne suivante (à adapter suivant la méthode de configuration mise en place) :
#configuration.yaml
python_script:
  1. Sauvegarder (:wink:)
  2. Créer le dossier python_scripts au même niveau que votre fichier de configuration configuration.yaml
  3. Redémarrer le serveur
    Pour l’instant, rien à vérifier dans l’interface graphique :pensive:.

Création du script de recopie d’entité

  1. Créer un fichier nommer ‹ copier_une_entite.py › dans le dossier python_scripts
  2. L’ouvrir avec votre éditeur préféré
  3. Coller ce code (malgré les commentaires, si besoin, ne pas hésiter à demander des infos :+1:) :
#--------------------------------------------------------------------------------------------------
# Recopie d'une entité (état et attributs) dans une autre entité
#--------------------------------------------------------------------------------------------------
# service: python_script.copier_une_entite
# data:
#   entite_source: Entité Source
#   entite_cible: Entité Cible
#--------------------------------------------------------------------------------------------------

#Récupération des paramètres
EntiteSource = data.get('entite_source')
EntiteCible = data.get('entite_cible')
if EntiteCible is not None and EntiteSource is not None:
    #Assignation de l'entite cible avec les données de l'entite source
    EntiteCible_Objet = hass.states.get(EntiteSource)
    
    #Affection de l'état de l'entité cible (avec l'état de l'entité source)
    EntiteCible_Etat = EntiteCible_Objet.state
    
    #Affection des attributs de l'entité cible (avec les attributs de l'entité source)
    EntiteCible_Attributs = EntiteCible_Objet.attributes.copy()
    
    #Ecriture de l'entité cible dans Home Assistant
    hass.states.set(EntiteCible, EntiteCible_Etat, EntiteCible_Attributs)
else:
    logger.warning("==> renseigner 'entite_cible' et/ou 'entite_source' pour éxécuter ce script.")
  1. Sauvegarder (:wink:)
  2. Se rendre sous Outils de développement -> Onglet Services
    1. Dans service, sélectionner python_script.reload
    2. Cliquer sur le bouton Exécuter le service
    3. Dans service, vérifier que le service python_script.copier_une_entite est maintenant présent (:+1:) et le sélectionner
    4. Dans le champ Données de service (YAML, facultatif) , mettre (toujours en adaptant votre ville :wink:) :
    entite_source: weather.bordeaux
entite_cible: sensor.weather_bordeaux
    1. Cliquer sur le bouton Exécuter le service
    2. Se rendre dans l’onglet ÉTATS, et :
      image
      image954×734 22.3 KB

L’entité sensor.weather_bordeaux a prit l’état et les attributs de l’entité sensor.weather_bordeaux.

:star_struck: :heart_eyes:
:thinking: Mais pourquoi avoir fait une sorte de clone de l’entité ?

Très bonne question ! :innocent:

Le but de la manœuvre initiale est d’utiliser l’état/attribut d’une autre entité comme affichage de la température sur la carte Météo-France.
On peux très bien, à l’aide de script python, venir écrire directement sur l’état/attribut de l’entité créée par l’intégration Météo-France.
Mais, dès que l’intégration Météo-France va mettre à jour son entité, l’écriture précédente sera perdue…Dommage !
Donc, je suis partie du principe suivant : comme je n’ai pas la main sur la mise jour de l’entité créée et gérée par l’intégration, je vais utiliser pour la carte une entité dont j’ai la maîtrise totale. C’est pourquoi je vous présente cette méthode.
Pour ceux qui pensent que l’on peux venir tout de même écraser par dessus l’entité de l’intégration et gérer les mises à jour à l’aide d’une automatisation et de la plateform state, c’est vrai ! Mais je vous recommande de ne pas toucher à vos données d’entrée et de faire des copies de celles-ci pour travailler dessus…Mais au final, faite ce que vous voulez :wink:, mais si vous le faites…partagez :+1: :heart:

Donc, on en est au fait que nous avons une entité sur laquelle travailler.

Création du script d’écriture d’un attribut d’une entité cible

La valeur de la température extérieur affichée sur la carte Météo-France est contenue dans l’attribut temperature de l’entité clonée.
Il nous faut donc un moyen de venir écraser cette valeur et mettre à la place la valeur de l’état ou d’un attribut d’une autre entité.
On va donc créer un deuxième script python.

Ce script va écrire dans l’attribut cible de l’entité cible la valeur de l’état ou de l’attribut de l’entité source :

  1. Créer un fichier nommer ‹ ecrire_attribut_entite.py › dans le dossier python_scripts
  2. L’ouvrir avec votre éditeur préféré
  3. Coller ce code (malgré les commentaires, si besoin, ne pas hésiter à demander des infos :+1:) :
#--------------------------------------------------------------------------------------------------
# Ecriture d'un attribut d'une entité (son état et ses autres attributs ne sont pas modifiés)
# Peut être à partir d'une autre entité (état ou attribut) ou non
#--------------------------------------------------------------------------------------------------
# A partir d'une valeur :
# (Priorité 1)
#
# service: python_script.ecrire_attribut_entite
# data:
#   entite_cible: Entité cible
#   attribut_cible: Attribut cible
#   attribut_valeur: Nouvelle valeur de l'attribut
#--------------------------------------------------------------------------------------------------
# A partir d'une autre entité et de son état ('entity_state' comme valeur pour attribut_source) :
# (Priorité 2)
#
# service: python_script.ecrire_attribut_entite
# data:
#   entite_cible: Entité cible
#   attribut_cible: Attribut cible
#   entite_source: Entité source
#   attribut_source: 'entity_state'
#--------------------------------------------------------------------------------------------------
# A partir d'une autre entité et de l'un de ses attributs:
# (Priorité 3)
#
# service: python_script.ecrire_attribut_entite
# data:
#   entite_cible: Entité cible
#   attribut_cible: Attribut cible
#   entite_source: Entité source
#   attribut_source: Attribut source
#--------------------------------------------------------------------------------------------------

#Récupération de l'entité cible
EntiteCible = data.get('entite_cible')
#Récupération de l'attribut à écrire
AttributCible = data.get('attribut_cible')
#Récupération de l'entité source
EntiteSource = data.get('entite_source')
#Récupération de l'attribut source
AttributSource = data.get('attribut_source')
#Récupération de la valeur
AttributValeur = data.get('attribut_valeur')

if EntiteCible is not None and AttributCible is not None:
    #Récupération de l'entité cible
    EntiteCible_Objet = hass.states.get(EntiteCible)
    
    #Récupération de l'état de l'entité cible
    EntiteCible_Etat = EntiteCible_Objet.state
    
    #Récupération des attributs de l'entité cible
    EntiteCible_Attributs = EntiteCible_Objet.attributes.copy()
    
    if AttributValeur is not None:
        #Ecriture de la valeur passée dans l'attribut cible
        EntiteCible_Attributs[AttributCible] = AttributValeur
        
        #Ecriture de la nouvelle valeur de l'entité avec conservation des attributs
        hass.states.set(EntiteCible, EntiteCible_Etat, EntiteCible_Attributs)
        
    elif EntiteSource is not None and AttributSource is not None:
        #Récupération de l'entité source
        EntiteSource_Objet = hass.states.get(EntiteSource)
        
        if AttributSource == 'entity_state':
            #Récupération de l'état de l'entité source
            EntiteSource_Etat = EntiteSource_Objet.state
            
            #Ecriture de l'état de l'entité source dans l'attribut cible
            EntiteCible_Attributs[AttributCible] = EntiteSource_Etat
        else:
            #Récupération des attributs de l'entité cible
            EntiteSource_Attributs = EntiteSource_Objet.attributes.copy()
            
            #Ecriture de l'attribut passé en paramètre de l'entité source dans l'attribut cible
            EntiteCible_Attributs[AttributCible] = EntiteSource_Attributs[AttributSource]
        
        #Ecriture de la nouvelle valeur de l'entité avec conservation des attributs
        hass.states.set(EntiteCible, EntiteCible_Etat, EntiteCible_Attributs)
        
    else:
        logger.warning("==> renseigner 'attribut_valeur' ou le couple 'entite_source' 'attribut_source' pour éxécuter ce script.")
else:
    logger.warning("==> renseigner 'entite_cible' et 'attribut_cible' pour éxécuter ce script.")

  1. Sauvegarder (:wink:)

  2. Se rendre sous Outils de développement -> Onglet Services

    1. Dans service, sélectionner python_script.reload
    2. Cliquer sur le bouton Exécuter le service
    3. Dans service, vérifier que le service python_script.ecrire_attribut_entite est maintenant présent (:+1:) et le sélectionner
    4. Dans le champ Données de service (YAML, facultatif) , mettre (en adaptant à votre entité représentant la température extérieure) :
    entite_cible: sensor.weather_bordeaux
attribut_cible: temperature
entite_source: sensor.temperature_exterieure
attribut_source: entity_state

    :information_source:
    attribut_source: entity_state : ici on indique que l’on veut mettre la valeur de l’état de l’entité source (non modifiable)
    attribut_source: temperature : ici on indique que l’on veut mettre la valeur de l’attribut temperaturede l’entité source (modifiable avec le nom de l’attribut)

    1. Cliquer sur le bouton Exécuter le service
    2. Se rendre dans l’onglet ÉTATS, et :
      [AVANT] :
      image
      image945×210 7.05 KB

      [APRES] :
      image
      image945×210 7.13 KB

Ce qui donne dans Lovelace :

image
image1348×584 28.2 KB

C’est super non ? Hein ? Comment ? Pourquoi les autres informations présentées par la carte son différentes ? Euh… :door::running_man:

Bravo :clap: ! Bien vu !

Que s’est-il passé ?
L’intégration Météo-France s’est mise à jour tout simplement et l’entité clonée ne s’est pas mise à jour :sob:

On va y remédier !

Automatisation

Mise à jour de l’entité clonée

Je vous ai parlé un peu plus haut (mais si, c’était en italique :wink:), que certaines personnes pouvaient prendre le parti de mettre à jour l’entité source à l’aide de la plateform state , et bien on va leur piquer l’idée du déclencheur ! :innocent:

Création de l’automatisation par l’interface graphique

  1. Direction Configuration , Automatisations puis cliquer sur le bouton orange en bas à droite AJOUTER UNE AUTOMATISATION
  2. Cliquer sur Passer :
    image
    image677×575 15.1 KB
  3. Et remplir ainsi (pensez à adapter vos entités) :
    image
    image872×536 16.9 KB

    image
    image872×772 9.34 KB

    image
    image872×166 1.58 KB

    image
    image872×840 15.9 KB

Ce que j’ai ajouté sans en parler, c’est le déclencheur (triggeur) Home Assistant : Démarrage.
Cela permet de mettre à jour l’entité clonée au démarrage, car rappelez-vous, nous l’avons nous même définie et elle est vide.
Si on ne met pas ce déclencheur, l’entité clonée sera vide (et donc la carte ne fonctionnera pas) tant que l’entité de l’intégration de Météo-France ne changera pas.

Code de l'automatisation (cliquer pour afficher le code) 
- id: 'super_identifiant_unique_pouvant_contenir_des_caracteres_et_pas_seulement_des_chiffres'
  alias: Météo France - Mise à jour de la température affichée
  description: Permet de mettre à jour la valeur de la température affichée sur la
    carte Météo-France en fonction du capteur extérieur
  trigger:
  - platform: state
    entity_id: weather.bordeaux
  - platform: homeassistant
    event: start
  condition: []
  action:
  - service: python_script.copier_une_entite
    data:
      entite_source: weather.bordeaux
      entite_cible: sensor.weather_bordeaux
  - service: python_script.ecrire_attribut_entite
    data:
      entite_cible: sensor.weather_bordeaux
      attribut_cible: temperature
      entite_source: sensor.temperature_exterieure
      attribut_source: entity_state
  mode: single

Voilà, vous pouvez maintenant utiliser votre propre capteur de température extérieur et l’afficher avec la carte Météo-France :

animate

Ne prêtez pas attention aux valeurs, ce sont des entités de test

source(EN)

Donc @Galadan, toi tu dois remplacer sensor.temperature_exterieure par sensor.netatmo_galahome_galastation_galamodule_temperature :+1:

4 « J'aime »