Installer la carte Météo France

Je ne connais pas les entités remontés par Netatmo, mais tu peux tout faire en utilisant des modèles (templates).

Si besoin, hésite pas à demander :+1:

Netatmo créer des sensor pour chaque info, voici chez moi pour le station intérieure:
image

Je ne sais pas trop gérer les Template, j’en est quelques un de paramétrés mais j’ai bêtement suivi des tuto…

En fait mon idée est par exemple de remplacer la température du sensor Météo France par celui de mon netatmo car plus précis (enfin plus « localisé »).

Je te montre dans la soirée une façon d’arriver à tes fins…(enfin si ce que j’imagine dans ma tête est faisable :wink:)

Peux tu me montrer dans la partie Outils de développement l’entité (sensor) que tu veux utiliser pour la température ? (état + attributs stp) :+1:

Ok, merci de ton aide :slight_smile:

C’est ça que tu as besoin:


?

1 « J'aime »

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) :

: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 :

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] :

      [APRES] :

Ce qui donne dans Lovelace :

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 :
  3. Et remplir ainsi (pensez à adapter vos entités) :



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 »

Hello,
Merci beaucoup!! Je pensais pas que c’était si compliquer ^^
Je vais essayer de mettre cela en place dans les prochains jours.

Je pense que rajouter l’option de base serait pas mal, je suppose que je suis pas le seul a avoir des sensors à la maison :slight_smile:

Merci encore pour le temps passé et le tuto détaillé :slight_smile:

Tu verra ça semble compliqué car ce sont des nouvelles notions, mais avec un bon accompagnement… :wink: :innocent:

Mais au final, il n’y à ‹ que › 2 scripts et 1 automatisation :grin:

T’a question m’intéressait car elle me permettais d’introduire les scripts python :smiling_face_with_three_hearts:

Il y a plus qu’à demander :+1:

Il faut savoir codé en Python aussi ^^
Je suppose que l’on peu reprendre ton exemple pour changer également l’humidité? :wink:

Bon je suis impatient donc j’ai mis en place :slight_smile:
Par contre ma card ne et pas la temp à jour avec mon sensor, j’ai du rater un truc quelque part…
J’ai repris le tuto pourtant mais je ne trouve pas mon erreur.

Oui, c’est possible.

Il faut dans un premier temps aller voir l’entité clone et voir si elle est à jour.

Mais fait le tutoriel pas à pas, ça permet de vérifier que tout se met en place et pas se retrouver à la fin avec un truc qui marche pas :hugs:

Bonjour,

Je ne peux ajouter les previsions horaires.
Si je tente d’ajouter une integration météo France avec le mode « hourly », il me dit que la ville est déjà créee.
Par quel moyen passez vous pour ajouter une intergration hourly?

Beau boulot pour cette carte, j’adore :star_struck:

Passe dans ce post :+1:

Un message a été fusionné à un sujet existant : Release note de l’intégration Météo-France

Hello,

J’ai repris, j’avais juste pas sélectionné la bonne source… cela fonctionne impeccable!
Il faut que je trouve comment modifier une deuxième valeur maintenant.
Je doit créer un autre script « python_script.ecrire_attribut_entite » ou je peux utiliser le même avec deux valeurs a modifier ou lieu de une?

Merci pour ton aide.

Tu peux utiliser le même en changeant les paramètres :wink: :

entite_cible: WWW
attribut_cible: XXX
entite_source: YYY
attribut_source: ZZZ

:warning: Non, le script n’est pas écrit pour fonctionner ainsi. Il faut que tu fasse une nouvelle fois appel à lui avec les nouvelles entités cible et source.

Ok, compris, je vais faire ça.

Par contre depuis la maj de meteo france j’ai plus de données qui remonte:

[EDIT] J’ai trouvé, j’ai repassé le script de copy et par conséquent le script d’écriture.

J’ai retrouvé toutes les infos de base et les deux modifiées :slight_smile:

[EDIT2] Cela n’a pas fonctionné longtemps… :frowning:

Pour les non pythonistes (comme moi) et qui voudrait faire ça avec NodeRed. Voici une autre solution:

  1. J’interroge l’état de weather.ici toutes les X minutes
  2. Je sauvegarde (le change)
  3. Je requête le thermometre
  4. Je remplace dans les attributs la température
  5. Dans la fonction je constitue les champs de l’API (et donc j’envoie vers weather.ailleurs)
  6. Publication

est-ce que ton flow peux être déclenché quand un attribut de l’entité change ?
pour l’état j’ai mis à jour mon post avec une citation de toi :

Oui. Si, par exemple, le sensor.mon_thermometre a un nouvel état (donc une nouvelle température), un flot tout bête:

sera déclenché et on verra le résultat dans le fenêtre de debug de NR.

Donc, c’est un événement comme:

  • le changement d’état d’un capteur
  • une heure
  • un message reçu sur mqtt

qui va déclencher le flot.

Edit: En relisant mieux, ce n’est pas l’état qui change mais un attribut.

Dans ce cas, le trigger node peut être configuré comme ça:

C’est un exemple avec une lampe. Je teste si la nouvelle luminosité (new_state.attributes.brightness) est au dessus de 50 alors ça envoie sur le chemin « allowed ».
Le noeud trigger est donc appelé sur un événement de la lampe. L’état reste on mais un attribut change.

Quand tu marque que tu tests, je comprends que c’est une interrogation cyclique et non évènementielle, c’est ça ?

Ou le nœud est tout de même évènementiel sur l’entité globale ?

Car c’est une grosse différence de fonctionnement pour moi, non bloquante certes pour cette utilisation.

Oui. Dès qu’il y a un évènement concernant l’entité, le noeud est exécuté. Dans le noeud, on peut ajouter des tests sur des éléments de l’entité, comme les attributs. Ce n’est donc pas une interrogation toutes les X secondes/minutes (polling) mais bien un déclenchement sur modification de l’entité.

1 « J'aime »