Ici un petit récap des données qui vont me permettre d’enregistrer les données de la dernière session de charge dans sensor.wallbox_charges.

J’ai déjà décrit toutes les entités de l’intégration Wallbox sur ce Retex :

• J’intègre la Wallbox à Home Assistant

Le déclencheur

Je vais donc utiliser sensor.wallbox_portal_status_description comme déclencheur de l’enregistrement de la dernière session de charge.

Je vais donc utiliser le changement d’état de « Charging » à autre chose pour déclencher l’enregistrement.

Les données

• Wallbox Portal Added Energy (sensor.wallbox_portal_added_energy) va me donner le nombre de kWh ajoutés à la batterie de la voiture durant la dernière charge
• Wallbox Portal Added Range (sensor.wallbox_portal_added_range) va me donner une estimation du  nombre de km ajoutés pouvant être réalisés grâce à la dernière charge.
• Wallbox Portal Energy Price (sensor.wallbox_portal_energy_price) va me donner le prix du kWh, je l’utiliserai pour calculer le coût de la charge

J’ajoute l’intégration qui va stocker les données de charge

J’ai trouvé l’intégration hass-variables, absolument géniale. Merci à Ankama et à Snuffy2 pour ce travail et ce suivi.

Elle permet de créer un sensor qui ne soit relié à rien (pas un template). Ce sensor garde ses valeurs même à la relance de HA. Exactement ce dont j’avais besoin sans utiliser de mode de sauvegarde externe des données (json, autre base de données…).

Le nouveau sensor s’appelle : sensor.wallbox_charges

J’ajoute un sensor détectant le début de la charge

En effet, l’intégration ne me donne pas l’heure et la date de début de la dernière charge. Pour en calculer la durée, je trouve intéressant de disposer de cette information. Je vais donc la créer.

Je me base sur l’entité sensor.wallbox_portal_added_range et je vais aller chercher l’heure/date du début de charge (donc sa valeur minimale sur les 5 dernières heures)

Dans mon fichiers sensors.yaml, j’ajoute cette entité :

- platform: statistics
  name: "Wallbox Portal Added Range Min"
  entity_id: sensor.wallbox_portal_added_range
  state_characteristic: datetime_value_min
  max_age:
    hours: 5  

Cela va me créer l’entité : sensor.wallbox_portal_added_range_min

Je vais utiliser cette entité pour enregistrer le début de charge et pour calculer la durée de charge.

J’ajoute l’automatisation qui va enregistrer les données

Elle est assez complexe, j’imagine qu’elle est simplifiable, je vais l’expliquer étape par étape

Voici tout d’abord le code complet

alias: Enregistre une session de charge
description: ""
trigger:
  - platform: state
    entity_id:
      - sensor.wallbox_portal_status_description
    from: Charging
    to: null
    alias: Quand la charge se termine
condition: []
action:
  - alias: >-
      Initialiser la première conso, à ne lancer qu'une fois (en désactivant les
      autres actions)  puis désactiver
    service: variable.update_sensor
    data:
      replace_attributes: true
      value: INIT
      attributes:
        sessionscharge: null
    target:
      entity_id: sensor.wallbox_charges
    enabled: false
  - service: variable.update_sensor
    data:
      replace_attributes: true
      value: >-
        {{ as_timestamp(states('sensor.wallbox_portal_added_range_min')) | int
        |     timestamp_custom('%d/%m/%Y %H:%M:%S', true)}}      
      attributes:
        sessionscharge: >
          {% set sessioncharge = {'consommation': 2.14, 'coût': 0.43, 'durée':
          '00:27', 'début': '19/09/2023 20:36', 'fin': '21:03', 'km': 17,
          'saved_at': 1695150359} %}{{ sessioncharge }},{% set sessioncharge =
          {'consommation': 23.29, 'coût': 4.66, 'durée': '04:19', 'début':
          '21/09/2023 21:06', 'fin': '01:25', 'km': 192, 'saved_at': 1695323159}
          %}{{ sessioncharge }},{% set sessioncharge = {'consommation': 7.68,
          'coût': 1.54, 'durée': '01:23', 'début': '22/09/2023 08:45', 'fin':
          '10:08', 'km': 63, 'saved_at': 1695409559} %}{{ sessioncharge }},{%
          set sessioncharge = {'consommation': 23.8, 'coût': 4.76, 'durée':
          '04:26', 'début': '23/09/2023 16:57', 'fin': '21:23', 'km': 196,
          'saved_at': 1695495959} %}{{ sessioncharge }},{% set sessioncharge =
          {'consommation': 23.64, 'coût': 4.73, 'durée': '04:05', 'début':
          '26/09/2023 20:59', 'fin': '01:04', 'km': 195, 'saved_at': 1695755159}
          %}{{ sessioncharge }},{% set sessioncharge = {'consommation': 24.04,
          'coût': 4.81, 'durée': '05:17', 'début': '28/09/2023 21:21', 'fin':
          '02:38', 'km': 198, 'saved_at': 1695927959} %}{{ sessioncharge }},{%
          set sessioncharge = {'consommation': 17.3, 'coût': 3.46, 'durée':
          '03:51', 'début': '30/09/2023 21:31', 'fin': '01:22', 'km': 143,
          'saved_at': 1696100759} %}{{ sessioncharge }},{% set sessioncharge =
          {'consommation': 22.18, 'coût': 4.44, 'durée': '04:25', 'début':
          '03/10/2023 20:43', 'fin': '01:08', 'km': 183, 'saved_at': 1696359959}
          %}{{ sessioncharge }},{% set sessioncharge = {'consommation': 23.86,
          'coût': 4.77, 'durée': '05:26', 'début': '05/10/2023 21:03', 'fin':
          '02:29', 'km': 197, 'saved_at': 1696532759} %}{{ sessioncharge }},{%
          set sessioncharge = {'consommation': 23.43, 'coût': 4.69, 'durée':
          '05:07', 'début': '07/10/2023 20:34', 'fin': '01:41', 'km': 193,
          'saved_at': 1696705559} %}{{ sessioncharge }},{% set sessioncharge =
          {'consommation': 23.32, 'coût': 4.66, 'durée': '04:40', 'début':
          '10/10/2023 20:57', 'fin': '04:40', 'km': 192, 'saved_at': 1696964759}
          %}{{ sessioncharge }},{% set sessioncharge = {'consommation': 25.19,
          'coût': 5.04, 'durée': '04:39', 'début': '12/10/2023 19:53', 'fin':
          '00:32', 'km': 208, 'saved_at': 1697137559} %}{{ sessioncharge }},{%
          set sessioncharge = {'consommation': 8.61, 'coût': 1.72, 'durée':
          '01:32', 'début': '13/10/2023 21:05', 'fin': '22:37', 'km': 71,
          'saved_at': 1697223959} %}{{ sessioncharge }},{% set sessioncharge =
          {'consommation': 27.76, 'coût': 5.55, 'durée': '04:46', 'début':
          '16/10/2023 02:11', 'fin': '06:57', 'km': 231, 'saved_at': 1697474976}
          %}{{ sessioncharge }},{% set sessioncharge = {'consommation': 24.18,
          'coût': 4.84, 'durée': '04:12', 'début': '18/10/2023 02:11', 'fin':
          '06:23', 'km': 201, 'saved_at': 1697657509} %}{{ sessioncharge }},{%
          set sessioncharge = {'consommation': 20.17, 'coût': 4.03, 'durée':
          '03:38', 'début': '19/10/2023 02:11', 'fin': '05:50', 'km': 168,
          'saved_at': 1697688628} %}{{ sessioncharge }},{% set sessioncharge =
          {'consommation': 23.08, 'coût': 4.62, 'durée': '04:13', 'début':
          '21/10/2023 02:12', 'fin': '06:25', 'km': 192, 'saved_at': 1697867735}
          %}{{ sessioncharge }},{% set sessioncharge = {'consommation': 12.19,
          'coût': 2.44, 'durée': '03:21', 'début': '22/10/2023 02:13', 'fin':
          '05:34', 'km': 101, 'saved_at': 1697946854} %}{{ sessioncharge }}
    target:
      entity_id: sensor.wallbox_charges
    enabled: false
    alias: >-
      Initialiser les premières conso, à ne lancer qu'une fois  (en désactivant
      les autres actions) puis désactiver
  - service: variable.update_sensor
    data:
      replace_attributes: true
      value: >-
        {{ as_timestamp(states('sensor.wallbox_portal_added_range_min')) | int
        |     timestamp_custom('%d/%m/%Y %H:%M:%S', true)}}      
      attributes:
        sessionscharge: >-
          {% set diff_seconds = now().timestamp() -
          states.sensor.wallbox_portal_added_range_min.state | as_timestamp %}
          {% set hours = (diff_seconds / 3600) | int %} {% set minutes =
          ((diff_seconds % 3600) / 60) | int %} {% set sessioncharge =  { 
          'consommation': states('sensor.wallbox_portal_added_energy') | float |
          round(2),  'coût': (states('sensor.wallbox_portal_energy_price') |
          float * states('sensor.wallbox_portal_added_energy') | float |
          round(2)) | round(2), 'durée': '%02d:%02d' | format(hours, minutes) , 
          'début': as_timestamp(states('sensor.wallbox_portal_added_range_min'))
          | int |
            timestamp_custom('%d/%m/%Y %H:%M', true), 
          'fin':  now().strftime('%H:%M') ,  'km':
          states('sensor.wallbox_portal_added_range') | int,  'saved_at':
          now().timestamp() | int }  %}

          {% if state_attr('sensor.wallbox_charges', 'sessionscharge') is not
          none %}
            {{ state_attr('sensor.wallbox_charges', 'sessionscharge') }}, {{ sessioncharge }}
          {% else %}
            {{ sessioncharge }}, {{ sessioncharge }}
          {% endif %}
    target:
      entity_id: sensor.wallbox_charges
    enabled: true
    alias: Enregistre la session de charge qui vient de se terminer
mode: single

Explication partie par partie

• Le déclencheur : c’est quand la charge est terminée
• L’action 1 (désactivée par défaut) n’est a activer qu’une fois en pensant à désactiver les 2 autres actions, c’est pour initialiser à « null » une fois l’entité qui enregistre les données.
• L’action 2 (désactivée par défaut) n’est à activer qu’une fois en pensant à désactiver les 2 autres actions, c’est pour initialiser quelques données antérieures. En effet, je ne voulais pas perdre les données de charge depuis l’achat de la voiture, donc je les ai stockées là. 
• L’action 3 (à activer par défaut) est l’action qui calcule et enregistre les données de charge.

Explication du code du déclencheur 

Ce déclencheur est basé sur la plateforme « state » de Home Assistant. Il surveille l’état d’une entité spécifique, en l’occurrence, « sensor.wallbox_portal_status_description ». Plus précisément, il est configuré pour réagir lorsqu’un changement d’état de cette entité se produit. Les détails de la configuration sont les suivants :

– `entity_id`: Il spécifie l’entité dont l’état est surveillé. Dans ce cas, il s’agit de « sensor.wallbox_portal_status_description ». Plusieurs entités peuvent être surveillées en fournissant une liste d’entités sous la forme d’une liste. Cependant, dans cet exemple, une seule entité est surveillée.

– `from: Charging`: Cela signifie que le déclencheur réagit lorsque l’état précédent de « sensor.wallbox_portal_status_description » était « Charging ». Il s’agit d’une condition pour déclencher l’automatisation. Le déclencheur ne réagit que si l’état précédent était « Charging ».

– `to: null`: Cela signifie que le déclencheur réagit lorsque l’état actuel de « sensor.wallbox_portal_status_description » est passé de « Charging » à n’importe quel autre état, y compris « null ». Il s’agit de la nouvelle condition pour déclencher l’automatisation. Le déclencheur réagit lorsque l’état change de « Charging » à tout autre état.

– `alias: Quand la charge se termine`: C’est un alias pour le déclencheur, un nom qui vous permet de le reconnaître plus facilement. Dans ce cas, il indique simplement que l’automatisation sera déclenchée lorsque la charge se termine.

En résumé, cet automatisation est déclenchée chaque fois que l’état de « sensor.wallbox_portal_status_description » change de « Charging » à tout autre état, ce qui signifie qu’elle est conçue pour réagir lorsque la charge de la voiture électrique se termine.

Explication de l’action 1 

Cette action est destinée à initialiser la première consommation (charge) pour un capteur appelé « sensor.wallbox_charges » en utilisant le service « variable.update_sensor » de Home Assistant. Voici une explication détaillée de chaque composant de l’action :

– `alias`: C’est simplement un nom ou une description de l’action pour la rendre plus compréhensible. Dans ce cas, il indique que cette action est destinée à l’initialisation de la première consommation et qu’elle ne doit être exécutée qu’une fois. Il suggère également de désactiver d’autres actions après son exécution.

– `service: variable.update_sensor`: Cette ligne spécifie le service à utiliser pour effectuer l’action. Le service « variable.update_sensor » est utilisé pour mettre à jour ou initialiser les attributs d’une entité (dans ce cas, « sensor.wallbox_charges »).

– `data`: Cette section contient les données à envoyer avec le service. Dans ce cas :
– `replace_attributes: true`: Cela indique que les attributs de l’entité existante doivent être remplacés par les nouvelles données. Si « replace_attributes » est à « true », les attributs existants de « sensor.wallbox_charges » seront remplacés par les nouvelles données.

– `value: INIT`: Cela indique la valeur à attribuer à l’attribut « sessionscharge » de « sensor.wallbox_charges ». Dans ce cas, la valeur « INIT » est attribuée.

– `attributes: sessionscharge: null`: Cette ligne indique que l’attribut « sessionscharge » de « sensor.wallbox_charges » doit être initialisé à « null ».

– `target`: Il spécifie l’entité cible, c’est-à-dire l’entité dont les attributs sont mis à jour. Dans ce cas, l’entité cible est « sensor.wallbox_charges ».

– `enabled: true`: Cela indique que cette action est activée et peut être exécutée.

En résumé, cette action sert à initialiser l’attribut « sessionscharge » de l’entité « sensor.wallbox_charges » avec la valeur « null » en utilisant le service « variable.update_sensor ». Elle est destinée à être exécutée une seule fois pour effectuer cette initialisation, après quoi, il est recommandé de désactiver cette action. Cela pourrait être utile pour démarrer avec des valeurs initiales spécifiques dans vos automatisations ou entités.

Explication de l’action 2

Cette action vise à initialiser l’attribut « sessionscharge » d’une entité appelée « sensor.wallbox_charges » avec une série de données de sessions de charge préexistantes. Voici une explication détaillée de chaque élément de l’action :

– `service: variable.update_sensor`: Il s’agit du service utilisé pour mettre à jour ou initialiser les attributs d’une entité dans Home Assistant.

– `data`: Cette section contient les données à envoyer avec le service. Dans ce cas :
– `replace_attributes: true` : Cela indique que les attributs existants de l’entité « sensor.wallbox_charges » seront remplacés par les nouvelles données.

– `value`: Cette partie est utilisée pour définir la valeur de l’attribut « sessionscharge » de l’entité « sensor.wallbox_charges ». La valeur est générée dynamiquement à l’aide de modèles Jinja2. Il utilise l’horodatage de la première session de charge (c’est-à-dire « sensor.wallbox_portal_added_range_min ») pour obtenir une date et une heure, puis le formate dans le style « jour/mois/année heure:minute:seconde ». Cela signifie que la valeur « sessionscharge » sera initialisée avec la date et l’heure de la première session de charge.

– `attributes`: C’est là que les données de chaque session de charge sont définies. Chaque session de charge est définie dans un format spécifique en utilisant des modèles Jinja2. Ces sessions de charge sont séparées par des virgules.

– `target`: Il spécifie l’entité cible, c’est-à-dire l’entité dont les attributs sont mis à jour. Dans ce cas, l’entité cible est « sensor.wallbox_charges ».

– `enabled: true`: Cela indique que cette action est activée et peut être exécutée.

Le but de cette action est d’initialiser l’attribut « sessionscharge » de « sensor.wallbox_charges » avec des données simulées de sessions de charge. Cela peut être utile pour tester ou démarrer avec des données de charge fictives. Une fois l’initialisation effectuée, il est recommandé de désactiver cette action, comme indiqué dans l’alias, car elle n’a pas besoin d’être répétée.

Explication de l’action 3 – Principale action

Cette action vise à mettre à jour l’attribut « sessionscharge » de l’entité « sensor.wallbox_charges » avec les données de la session de charge qui vient de se terminer. Voici une explication détaillée de chaque élément de l’action :

– `service: variable.update_sensor`: Il s’agit du service utilisé pour mettre à jour ou initialiser les attributs d’une entité dans Home Assistant.

– `data`: Cette section contient les données à envoyer avec le service. Dans ce cas :
– `replace_attributes: true`: Cela indique que les attributs existants de l’entité « sensor.wallbox_charges » seront remplacés par les nouvelles données.

– `value`: Cette partie est utilisée pour définir la valeur de l’attribut « sessionscharge » de l’entité « sensor.wallbox_charges ». La valeur est générée dynamiquement à l’aide de modèles Jinja2. Elle comprend :
– La conversion de l’horodatage de « sensor.wallbox_portal_added_range_min » en un format de date et d’heure spécifique à l’aide de la fonction `timestamp_custom`.

– `attributes`: C’est là que les données de la session de charge sont définies. Ces données sont calculées à partir de diverses entités, notamment « sensor.wallbox_portal_added_energy », « sensor.wallbox_portal_energy_price », « sensor.wallbox_portal_added_range_min », « sensor.wallbox_portal_added_range », et l’horodatage actuel (obtenu via `now()`). Les données incluent la consommation, le coût, la durée, le début, la fin, les kilomètres et l’horodatage de la session de charge.

– La durée est calculée en soustrayant l’horodatage de début de la session de charge de l’horodatage actuel (exprimé en secondes). Ensuite, ces secondes sont converties en heures et minutes.

– Dans la section `{% if … %}`, le code vérifie si l’attribut « sessionscharge » de l’entité « sensor.wallbox_charges » est déjà défini. Si c’est le cas, les données existantes sont conservées. Sinon, les nouvelles données de session de charge sont ajoutées.

– `target`: Il spécifie l’entité cible, c’est-à-dire l’entité dont les attributs sont mis à jour. Dans ce cas, l’entité cible est « sensor.wallbox_charges ».

– `enabled: true`: Cela indique que cette action est activée et peut être exécutée.

L’objectif de cette action est d’enregistrer les données de chaque session de charge qui vient de se terminer dans l’attribut « sessionscharge » de l’entité « sensor.wallbox_charges ». Cela permet de garder une trace de chaque session de charge effectuée.

Résultat

Ainsi à chaque fin de charge, un nouvel enregistrement est ajouté à l’entité sensor.wallbox_charges.

Voici son contenu :

Ajout d’une carte qui affiche toutes les sessions de charge

<div>Sessions de charge</div> 
Dernière mise à jour : {{ state_attr('sensor.sessions_de_charge','updated_at')}} <br><br>
{% set items = state_attr('sensor.wallbox_charges', 'sessionscharge') %}
<table width='100%'>
<tbody>
{% for i in range(0, items | count, 1) %}
<tr>
<td>{{ items[i].début }} à {{ items[i].fin }} ({{ items[i].durée }})</td>
<td>{{ items[i].consommation }} kWh</td>
<td>+{{ items[i].km }} km</td>
<td>{{ items[i].coût }} €</td>
</tr>

{% endfor %}
</tbody>
</table>

Ajout d’une carte qui affiche un récapitulatif par année, mois, semaine

type: markdown
content: >-
  <div><h1>Sessions de charge</div>  {%- set default_language = 'fr' %} Dernière
  mise à jour : {{ state_attr('sensor.wallbox_charges','updated_at')}} <br><br>


  {% set items = state_attr('sensor.wallbox_charges', 'sessionscharge') %}

  {% set septjours = now() - timedelta(days=7) %}

  {% set power_semaine = namespace(value=0) %}

  {% set cout_semaine = namespace(value=0) %}

  {% set unmois = now() - timedelta(days=30) %}

  {% set power_mois = namespace(value=0) %}

  {% set cout_mois = namespace(value=0) %}

  {% set uneannee = now() - timedelta(days=365) %}

  {% set power_annee = namespace(value=0) %}

  {% set cout_annee = namespace(value=0) %}


  {% for i in range(0, items | count, 1) %}
    {% if items[i].saved_at | int >= as_timestamp(uneannee) %}
    {% set power_annee.value = power_annee.value + items[i].consommation %}
    {% set cout_annee.value = cout_annee.value + items[i].coût %}
      {% if items[i].saved_at | int >= as_timestamp(unmois) %}  
        {% set power_mois.value = power_mois.value + items[i].consommation %}
        {% set cout_mois.value = cout_mois.value + items[i].coût %}
        {% if items[i].saved_at | int >= as_timestamp(septjours) %}
          {% set power_semaine.value = power_semaine.value + items[i].consommation %}
          {% set cout_semaine.value = cout_semaine.value + items[i].coût %}        
        {% endif %}
      {% endif %}
    {% endif %}
  {% endfor %}

  </ha-alert> <ha-alert alert-type="info" title="Dernier mois : {{
  power_mois.value | int }} kWh - {{ cout_mois.value | float | round(2) }}
  &euro;"></ha-alert> <ha-alert alert-type="info" title="Dernière année : {{
  power_annee.value | int }} kWh - {{ cout_annee.value | float | round(2) }}
  &euro;"></ha-alert>


  <br> 


  {% set items = state_attr('sensor.wallbox_charges', 'sessionscharge') %}

  {% set septjours = now() - timedelta(days=7) %}

  <table width='100%'> <tbody>  {% for i in range(0, items | count, 1) %}  {% if
  items[i].saved_at | int >= as_timestamp(septjours) %} {% set datetime_obj =
  strptime(items[i].début, '%d/%m/%Y %H:%M') %}

  <tr> <td><h5>{{items[i].début }} à {{ items[i].fin }} ({{ items[i].durée
  }})</td> <td>{{
    items[i].consommation }} kWh</td> <td>+{{ items[i].km }} km</td> <td>{{
    items[i].coût }} €</td> </tr> {% endif %} {% endfor %} </tbody> </table>
    <ha-alert alert-type="success" title="Dernière semaine : {{
      power_semaine.value | int}} kWh - {{ cout_semaine.value | float | round(2)
      }}&euro;">    
style:
  .: |
    ha-card {
      margin: 0px 0px 0px 0px;
      box-shadow: none;
     }
  ha-markdown:
    $: |
      h5 {
        font-size: 15px !important;
        font-weight: normal !important;
        padding: 0px 0px 0px 8px !important;
        border-left: 3px solid #429f46;
        }

Bonus : Enregistrer les données dans un fichier CSV

Pour une utilisation future (et pour ne pas perdre les données en cas de pépin), j’ai décidé d’enregistrer chaque session de charge sans un fichier CSV. A chaque session, une ligne est ajoutée.

Voici comment j’ai réalisé cela.

J’ajoute un sensor « file » qui correspond au fichier CSV

J’utilise un fichier notify.yaml qui se trouve dans le dossier de configuration.yaml qui est déclaré dans ce fichier grâce à la commande notify: !include notify.yaml

Je déclare ce nouveau sensor avec ce code :

- name: sessions_de_charge_CSV
  platform: file
  filename: /config/www/csv/sessions_de_charge.csv
  timestamp: false

Ainsi, quand je voudrais écrire dans le fichier, il me suffira d’exécuter le service notify.sessions_de_charge_CSV

J’ajoute une action

J’ajoute une action dans l’automatisation présentée précédemment qui va écrire une ligne à chaque enregistrement d’une session de charge

service: notify.sessions_de_charge_CSV
data:
  data: {}
  message: >-
    {% set diff_seconds = now().timestamp() -
    states.sensor.wallbox_portal_added_range_min.state | as_timestamp %} {% set
    hours = (diff_seconds / 3600) | int %} {% set minutes = ((diff_seconds %
    3600) / 60) | int %} {% set sessioncharge_string = "" +
    states('sensor.wallbox_portal_added_energy') | round(2) | replace('.', ',')|
    string + "; " + (states('sensor.wallbox_portal_energy_price') | float *
    states('sensor.wallbox_portal_added_energy') | float | round(2)) | round(2)
    | replace('.', ',')| string + "; " + '%02d:%02d' | format(hours, minutes) |
    string + "; " +
    as_timestamp(states('sensor.wallbox_portal_added_range_min')) | int |
    timestamp_custom('%d/%m/%Y', true) | string + "; " +
    as_timestamp(states('sensor.wallbox_portal_added_range_min')) | int |
    timestamp_custom('%H:%M', true) | string + "; " + now().strftime('%H:%M') |
    string + "; " + states('sensor.wallbox_portal_added_range') | int | string +
    "; " + now().timestamp() | int| string %} {{ sessioncharge_string }}
enabled: true
alias: Ajouter une ligne dans le fichier sessions_de_charge.CSV

L’intégration pour exécuter le script Python

Pour une raison que je n’ai jamais compris, les fonctionnalités scripts python intégrées à HA sont archi-mini, aucun import n’est possible, je dois donc utiliser une intégration appelée pyscript.

La doc est ici.

Je passe les détails pour l’installer, c’est très simple avec HACS et tout est dans la doc.

Dans configuration.yaml, j’ai bien ces lignes :

pyscript:
  allow_all_imports: true
  hass_is_global: true

Je récupère un jeton

J’ouvre l’interface utilisateur de Home Assistant.

Dans le coin inférieur gauche, je clique sur mon nom d’utilisateur (ou l’icône du profil).

Je clique sur « Profil ».

Je fais défiler vers le bas jusqu’à la section « Jetons d’accès longue durée ». 

Je clique sur « Créer un jeton » pour générer un nouveau jeton.

Je donne un nom à mon jeton pour m’y retrouver plus facilement.

Une fois le jeton créé, je vois son contenu. Je copie la valeur du jeton, c’est-à-dire la série de caractères alphanumériques, et je la colle dans ma configuration (paragraphe suivant)

Déclaration de la plateforme qui fait le lien entre Python et le sensor

Dans configuration.yaml, j’ajoute ces lignes :

rest_command:
  send_data_to_api:
    url: 'http://homeassistant.local:8123/api/states/sensor.wallbox_charges'
    method: 'post'
    content_type: 'application/json'
    headers:
      Authorization: 'Bearer TOKEN'  # Remplacer TOKEN par le token cf paragraphe précédent
    payload: '{{ data | tojson }}'  

Il s’agit de la porte d’entrée qui sera approvisionné par le script Python (plus bas) et qui enverra les informations dans le sensor sensor.wallbox_charges.

Mon script Python

Je place le fichier wallbox_charges.py dans le dossier /config/pyscript

import datetime
import pytz
@service
def wallbox_charges(lastdata=None, action=None, prix="123", km="123", dateDebut="01/01/2000 12:00:00", valeur="123"):
    fuseau_horaire_paris = pytz.timezone("Europe/Paris")

    maintenant_timestamp = int(datetime.datetime.now().timestamp())
    maintenant_heure_paris = datetime.datetime.fromtimestamp(maintenant_timestamp, fuseau_horaire_paris)
    maintenant_formatee = maintenant_heure_paris.strftime("%d/%m/%Y %H:%M:%S")

    maintenantMoins20min = datetime.datetime.now() - datetime.timedelta(minutes=20)
    maintenantMoins20min_formatee = maintenantMoins20min.strftime("%H:%M")
    
    
    dateDebutRecue = datetime.datetime.strptime(dateDebut, '%d/%m/%Y %H:%M:%S').replace(tzinfo=fuseau_horaire_paris)
    debut_timestamp_formatee = dateDebutRecue.strftime("%d/%m/%Y %H:%M:%S")
    debut_timestamp_formatee_SansSecondes = dateDebutRecue.strftime("%d/%m/%Y %H:%M")
    
     # Transformez les chaînes en objets datetime
    maintenant_dt = datetime.datetime.strptime(maintenant_formatee, "%d/%m/%Y %H:%M:%S")
    debut_dt = datetime.datetime.strptime(debut_timestamp_formatee, "%d/%m/%Y %H:%M:%S")

    # Calculez la différence entre les objets datetime
    tempsDeCharge = maintenant_dt - debut_dt - datetime.timedelta(minutes=20)

    # Formatez la durée en heures, minutes et secondes
    heures, reste = divmod(tempsDeCharge.seconds, 3600)
    minutes, secondes = divmod(reste, 60)

    # Affichez la durée au format HH:MM:SS
    tempsDeCharge_formatee = f"{heures:02}:{minutes:02}"


    # Écrivez un message d'information dans le journal
    #log.info(action)




    if action == "enregistrer":
        valeuraajouter =  [{
                          "saved_at": maintenant_timestamp,
                          "début": debut_timestamp_formatee_SansSecondes,
                          "fin": maintenantMoins20min_formatee,
                          "durée": tempsDeCharge_formatee,
                          "consommation": valeur,
                          "km": km,
                          "coût": round(valeur * prix, 2)
                        }]
        if lastdata is not None:
            valeuraajouter = lastdata + valeuraajouter
        data =  {
                    "state": debut_timestamp_formatee_SansSecondes,  
                    "attributes": {
                      "updated_at": maintenant_dt.strftime("%d/%m/%Y %H:%M:%S"),
                      "sessionscharge": 
                      valeuraajouter
                    }
                }

    if action == "init":
        data =  {
                "state": "on",
                    "attributes": {
                      "updated_at": "14/10/2023 16:42:39",
                      "sessionscharge": [
                        {
                          "consommation": 2.14,
                          "coût": 0.43,
                          "durée": "00:27",
                          "début": "19/09/2023 20:36",
                          "fin": "21:03",
                          "km": 17,
                          "saved_at": 1695150359
                        },
                        {
                          "consommation": 23.29,
                          "coût": 4.66,
                          "durée": "04:19",
                          "début": "21/09/2023 21:06",
                          "fin": "01:25",
                          "km": 192,
                          "saved_at": 1695323159
                        },
                        {
                          "consommation": 7.68,
                          "coût": 1.54,
                          "durée": "01:23",
                          "début": "22/09/2023 08:45",
                          "fin": "10:08",
                          "km": 63,
                          "saved_at": 1695409559
                        },
                        {
                          "consommation": 23.80,
                          "coût": 4.76,
                          "durée": "04:26",
                          "début": "23/09/2023 16:57",
                          "fin": "21:23",
                          "km": 196,
                          "saved_at": 1695495959
                        }
                       ]
                    }
                }   



    # Appelez le service REST pour envoyer les données
    service_data = {
        "token": "xxxxxx",  # Remplacer par le token
        "data": data
    }

    if action == "enregistrer" or action == "init":
        # Appelez le service REST de manière asynchrone
        await hass.services.async_call('rest_command', 'send_data_to_api', service_data)
        
    # Écrivez un message d'erreur dans le journal
    #log.error("Fin script")

Ajouter deux automatisations

Une pour initialiser le sensor, l’autre pour ajouter une donnée

Initialiser les données

alias: Initialise les sessions de charge
description: ""
trigger: []
condition: []
action:
  - service: pyscript.wallbox_charges
    data:
      action: init
mode: single

Enregistrer les données

alias: Enregistre une session de charge
description: >-
  Cette automatisation se déclenche lorsque le capteur n'a pas changé de valeur
  depuis 20 minutes et n'est pas à 0
trigger:
  - platform: state
    entity_id:
      - sensor.wallbox_portal_added_range
    for:
      hours: 0
      minutes: 20
      seconds: 0
    enabled: true
condition:
  - condition: numeric_state
    entity_id: sensor.wallbox_portal_added_energy
    above: 0
  - condition: not
    conditions:
      - condition: state
        entity_id: sensor.wallbox_charges
        state: >-
          {{ as_timestamp(states('sensor.wallbox_portal_added_range_min')) | int
          |     timestamp_custom('%d/%m/%Y %H:%M:%S', true)}}
    enabled: false
action:
  - service: pyscript.wallbox_charges
    data:
      action: enregistrer
      valeur: "{{states('sensor.wallbox_portal_added_energy')}}"
      prix: "{{states('sensor.wallbox_portal_energy_price')}}"
      km: "{{states('sensor.wallbox_portal_added_range')}}"
      lastdata: "{{state_attr('sensor.wallbox_charges', 'sessionscharge')}}"
      dateDebut: >-
        {{ as_timestamp(states('sensor.wallbox_portal_added_range_min')) | int |
        timestamp_custom('%d/%m/%Y %H:%M:%S', true)}}
  - service: variable.update_sensor
    data:
      replace_attributes: false
      value: >-
        {{ as_timestamp(states('sensor.wallbox_portal_added_range_min')) | int
        |     timestamp_custom('%d/%m/%Y %H:%M:%S', true)}}
    target:
      entity_id: sensor.wallbox_charges
    enabled: false
mode: single

Pour avoir la valeur minimal de la charge, j’utilise statistic pour avoir la valeur min

Ce sensor est déclaré dans sensors.yaml

- platform: statistics
  name: "Wallbox Portal Added Range Min"
  entity_id: sensor.wallbox_portal_added_range
  state_characteristic: datetime_value_min
  max_age:
    hours: 10  
   

Résultat du stockage des infos

Carte d’affichage de toutes les sessions

<div>Sessions de charge</div> 
Dernière mise à jour : {{ state_attr('sensor.wallbox_charges','updated_at')}} <br><br>
{% set items = state_attr('sensor.wallbox_charges', 'sessionscharge') %}
<table width='100%'>
<tbody>
{% for i in range(0, items | count, 1) %}
<tr>
<td>{{ items[i].début }} à {{ items[i].fin }} ({{ items[i].durée }})</td>
<td>{{ items[i].consommation }} kWh</td>
<td>+{{ items[i].km }} km</td>
<td>{{ items[i].coût }} €</td>
</tr>

{% endfor %}
</tbody>
</table>

Carte d’affichage avec des totaux par année, mois, semaine

type: markdown
content: >-
  <div><h1>Sessions de charge</div>  {%- set default_language = 'fr' %} Dernière
  mise à jour : {{ state_attr('sensor.wallbox_charges','updated_at')}} <br><br>


  {% set items = state_attr('sensor.wallbox_charges', 'sessionscharge') %}

  {% set septjours = now() - timedelta(days=7) %}

  {% set power_semaine = namespace(value=0) %}

  {% set cout_semaine = namespace(value=0) %}

  {% set unmois = now() - timedelta(days=30) %}

  {% set power_mois = namespace(value=0) %}

  {% set cout_mois = namespace(value=0) %}

  {% set uneannee = now() - timedelta(days=365) %}

  {% set power_annee = namespace(value=0) %}

  {% set cout_annee = namespace(value=0) %}


  {% for i in range(0, items | count, 1) %}
    {% if items[i].saved_at | int >= as_timestamp(uneannee) %}
    {% set power_annee.value = power_annee.value + items[i].consommation %}
    {% set cout_annee.value = cout_annee.value + items[i].coût %}
      {% if items[i].saved_at | int >= as_timestamp(unmois) %}  
        {% set power_mois.value = power_mois.value + items[i].consommation %}
        {% set cout_mois.value = cout_mois.value + items[i].coût %}
        {% if items[i].saved_at | int >= as_timestamp(septjours) %}
          {% set power_semaine.value = power_semaine.value + items[i].consommation %}
          {% set cout_semaine.value = cout_semaine.value + items[i].coût %}        
        {% endif %}
      {% endif %}
    {% endif %}
  {% endfor %}

  </ha-alert> <ha-alert alert-type="info" title="Dernier mois : {{
  power_mois.value | int }} kWh - {{ cout_mois.value | float | round(2) }}
  &euro;"></ha-alert> <ha-alert alert-type="info" title="Dernière année : {{
  power_annee.value | int }} kWh - {{ cout_annee.value | float | round(2) }}
  &euro;"></ha-alert>


  <br> 


  {% set items = state_attr('sensor.wallbox_charges', 'sessionscharge') %}

  {% set septjours = now() - timedelta(days=7) %}

  <table width='100%'> <tbody>  {% for i in range(0, items | count, 1) %}  {% if
  items[i].saved_at | int >= as_timestamp(septjours) %} {% set datetime_obj =
  strptime(items[i].début, '%d/%m/%Y %H:%M') %}

  <tr> <td><h5>{{items[i].début }} à {{ items[i].fin }} ({{ items[i].durée
  }})</td> <td>{{
    items[i].consommation }} kWh</td> <td>+{{ items[i].km }} km</td> <td>{{
    items[i].coût }} €</td> </tr> {% endif %} {% endfor %} </tbody> </table>
    <ha-alert alert-type="success" title="Dernière semaine : {{
      power_semaine.value | int}} kWh - {{ cout_semaine.value | float | round(2)
      }}&euro;">    
style:
  .: |
    ha-card {
      margin: 0px 0px 0px 0px;
      box-shadow: none;
     }
  ha-markdown:
    $: |
      h5 {
        font-size: 15px !important;
        font-weight: normal !important;
        padding: 0px 0px 0px 8px !important;
        border-left: 3px solid #429f46;
        }

Mon objectif est de réaliser une animation via un gif animé.

Je pourrai changer de gif en fonction de l’état d’une entité.

Je vais dessiner les deux boules (une rouge une bleue)

Un petit coup de Photoshop ou autre et voici le fichier de base

Je vais créer l’animation dans Canva

Ma version de photoshop étant ancienne, je n’ai pas la fonctionnalité montage à la maison, j’utilise Canva (en ligne).

Pour éviter une marque blanche au détourage, je mets le fond de mon écran HA en fond, le résultat est :

Je vais basculer sur un fond transparent

Je n’ai pas trouvé comment faire cela avec Canva, j’utilise un outil en  ligne

• https://onlinegiftools.com/remove-gif-background

Le résultat donne 

Je fais deux autres animations

Pour avoir trois états, je génère deux autres fichiers, un plus rapide et un plus lent, donc trois fichiers au total :

J’ajoute un template qui va correspondre à la puissance consommée 

Dans mon fichier templates.yaml, j’ajoute

- name: Consommation_vitesse
  unique_id: sensor.consommation_vitesse
  state: >-
          {% if (states('sensor.linky_puissance_apparente')|float) < 400 %}
            lente
          {% elif (states('sensor.linky_puissance_apparente')|float) >4000 %}
            rapide
          {% else %}
            moyenne
          {% endif %} 

Sur le dashboard, j’ajoute une carte qui va afficher un des 3 gif animés, cela en fonction de la valeur de sensor.consommation_vitesse.

- type: image
  entity: sensor.consommation_vitesse
  tap_action:
    action: none
  style:
    width: 7%
    top: 91.6%
    left: 26.7%
  state_image:
    lente: /local/maison/Conso/lente.gif
    moyenne: /local/maison/Conso/moyenne.gif
    rapide: /local/maison/Conso/rapide.gif

A noter que l’intégration décrite ci-dessous ne peut fonctionner que si la clé USB/RS485 est le seul équipement du bus RS485 connectée au EM112. En effet (et grâce à l’aide d’Eric G.) J’ai compris qu’il ne pouvait y avoir qu’un seul équipement maitre sur le bus. Or le maitre est celui qui interroge et l’esclave celui qui répond. l’EM112 est donc esclave.

Mon idée première était de sniffer les trames de dialogues entre l’EM112 et ma Wallbox, la Wallbox étant maitre, je ne peux faire cela. Pour la beauté de l’exercice, j’ai testé avec deux maitres, cela fonctionne on retrouve des valeurs mais de temps en temps, quand les deux maitres posent une question ensemble, on se retrouve avec une erreur.

Si quelqu’un peut m’orienter vers une manière de « snifer » le bus 485 pour intercepter les informations que le EM112 envoie à une Wallbox par exemple, je suis preneur car à ce stade, je ne peux avoir une Wallbox et une Clé RS485/USB en parallèle (deux maitres).

 Matériel utilisé et drivers

L’équipement le plus cher de tout mon tableau (1.33€ sur Ali ), celle-ci fonctionne, visiblement il y a des fausses clés, j’ai peut-être eu de la chance mais ce vendeur est sérieux.

• Clé USB/RS485

Evidemment dès réception, je l’ai ouverte pour trouver une référence, c’est une YYH-256

En cherchant sur les forum, on retrouve que c’est (probablement) un fork de CH341 les drivers de ce dernier sont même utilisés.

A noter que mes recherches de drivers ont été inutiles puisque la clé est nativement reconnue sur le RaspberryPi4/HAOS que j’utilise.

Je poste ici ce schéma qui donne les circuits utilisés, à noter que le quartz a disparu, ce n’est pas un oubli à la soudure, c’est une évolution de la clé (un composant gagné, c’est un composant gagné).

Je relie la clé USB au port RS485

La clé a deux connecteurs D+ et D-, il suffit de les connecter sur les broches B+(4) et A-(5) du EM112

Je connecte la clé sur le port USB du Raspi4

Je teste immédiatement la commande  lsusb sur la ligne de commande et je constate que quand la nouvelle clé est branchée, j’ai une ligne de plus, c’est plutôt bon signe.

Je passe les soucis de ports /dev/ttyUSB0 et /dev/ttyUSB1 qui changent à chaque démarrage, j’ai solutionné et documenté la solution sur :

• Fixer les ports USB d’un Raspberry

Je note que j’utiliserai le port /dev/serial/by-id/usb-1a86_USB2.0-Ser_-if00-port0 pour me connecter à cette clé.

Je configure l’intégration Modbus qui est nativement dans HA

Dans mon fichier configuration, j’ajoute la ligne modbus: !include modbus.yaml

Et dans modbus.yaml, je déclare la clé

- name: modbus_hub
  type: serial
  #port: /dev/ttyUSB1
  port: /dev/serial/by-id/usb-1a86_USB2.0-Ser_-if00-port0
  baudrate: 9600
  bytesize: 8
  method: rtu
  parity: N
  stopbits: 1  
  retries: 5
  close_comm_on_error: false
  delay : 5
  timeout : 2
  message_wait_milliseconds : 1000

Je déclare chaque sensor 

A partir de là, je me plonge dans la documentation de Gavazzi et je vais chercher les lignes qui m’intéressent :

Pour avoir l’adresse de chaque sensor, je converti les adresses en hexa en décimal puis je déclare les 4 sensors dans modbus.yaml :

sensors:
  - name: EM112_W
    unit_of_measurement: W
    state_class: measurement
    device_class: energy
    slave: 1
    address: 4
    data_type: int32
    input_type: input
    precision: 0 
    scale: 0.1
    scan_interval: 10
    lazy_error_count : 999
    swap : word
    
  - name: EM112_A
    unit_of_measurement: A
    state_class: measurement
    device_class: current
    slave: 1
    address: 2
    data_type: int32
    input_type: input
    precision: 0
    scale: 0.001
    scan_interval: 10
    lazy_error_count : 999
    swap : word
    
  - name: EM112_VA
    unit_of_measurement: VA
    state_class: measurement
    device_class: energy
    slave: 1
    address: 6
    data_type: int32
    input_type: input
    precision: 0 
    scale: 0.1
    scan_interval: 10
    lazy_error_count : 999
    swap : word
    
  - name: EM112_kwh
    unit_of_measurement: kwh
    state_class: total_increasing
    device_class: energy
    slave: 1
    address: 16
    data_type: int32
    input_type: input
    precision: 0 
    scale: 0.1
    scan_interval: 10
    lazy_error_count : 999
    swap : word

Je vérifie le résultat

Parfait ! Il ne reste plus qu’à jouer à faire une jolie carte…

Rappel

Ne pas mettre en production en parallèle d’une Wallbox

Si quelqu’un peut m’orienter vers une manière de « snifer » le bus 485 pour intercepter les informations que le EM112 envoie à une Wallbox par exemple, je suis preneur car à ce stade, je ne peux avoir une Wallbox et une Clé RS485/USB en parallèle (deux maitres).

Bibliographie, Références

• https://www.home-assistant.io/integrations/modbus/
• https://gavazzi.se/app/uploads/2020/11/em111_em112_m1_cp.pdf

Je crée un input_boolean

Option 1 : Par configuration.yaml

Dans mon fichier configuration_yaml, je vais ajouter mon interrupteur virtuel

input_boolean:
  arrosage_automatique:
    #input_boolean.arrosage_automatique
    name: Arrosage autorisé
    icon: mdi:sprinkler-variant

Option 2 : Par l’interface graphique

Je vais dans Paramètres / Appareils et services / Entrées / Créer une entrée / Interrupteur 

Je vais personnaliser son icone

Cela se réalise dans le fichier customize.yaml qu’on doit déclarer dans le fichier configuration.yaml

Dans ce fichier customize.yaml que j’ajoute ces lignes

input_boolean.arrosage_automatique:
  templates:
    icon: >
      return (state === 'on') ? 'mdi:sprinkler-variant' : 'mdi:water-off';
    icon_color: >
      return (state === 'on') ? 'green' : 'rgb(54, 95, 140)';

Il faut un peu peur avec ses 10 connecteurs à vis et son grand écran plein de chiffres.

Pour faire quoi un EM112 ?

Je me lance dans l’acquisition d’un véhicule électrique, donc d’une Wallbox et pour éviter que le chargement de la voiture ne fasse sauter le disjoncteur quand le chauffage, le chauffeau et la machine à lavée sont en route, Wallbox conseille de placer en tête de réseau électrique (expliqué plus loin) un module de ce type. Il vérifie la consommation de l’ensemble de la maison et informe (via 3 câbles de données) la Wallbox ce qu’il lui reste à utiliser.

Attention, plusieurs versions

J’ai bien étudié le sujet avant de le commander car Carlo Gavazzi est un plaisantin, il nous a regroupé sous le même nom : EM112 plusieurs appareils aux applications et modes de dialogues bien différents.

Dans la documentation de Wallbox, j’ai lu que si on voulait utiliser le dispositif Eco-Smart qui permet d’utiliser des panneaux solaires, toutes les versions de EM112 ne sont pas compatibles.

Dans le mode d’emploi de l’EM112, on voit toutes les versions et options qui existent :

J’avais le secret espoir que la Wallbox Pulsar utilise bien le protocole Mdbus (sur port RS485) pour pouvoir un jour m’y interfacer, c’est bien cela. La version que j’ai reçue est bien en « S1 ».

Je commande un PowerBoost EM112

Dans la multitude de sites et de références, j’ai peur de faire une bétise. J’élimine donc tous les sites qui vendent un EM112 sans indication de la compatibilité avec la Wallbox Pulsar.

• A ma grande surprise, je vois sur le site de Norauto en propose une version au prix de 110€ au jour où j’ecris ce Retex. Elle est bien mentionné « pour Wallbox », j’imagine que c’est la bonne référence mais ni l’image ni la description ne donne la référence du produit vendu, j’hésite donc.
• Le site Carplug en vend un également, mentionné pour Wallbox également à 108€. Le site que je ne connais pas semble spécialisé et bien fourni. Un schéma et des vidéos illustrent le fonctionnement, bon boulot. C’est un site Belge, j’invite les amis belges à s’y interesser.
• Enfin, comme toujours, je regarde si Amazon n’a pas par hasard ce que je cherche. Et bien si, c’est encore mieux, c’est la marque Wallbox directement, impossible donc de se tromper de référence. 110€. Certain de pouvoir le renvoyer si ce n’est pas le bon ou s’il ne fonctionne pas, je passe commande.

J’ai reçu mon Power Boost EM112

Commandé dimanche, j’ai le colis dans ma boite mardi.

Il s’agit de la version EM112-DIN.AV0.1.X.SI.PFB donc parfait.

Le packaging est bien de la marque Wallbox, le module est un Carlo Gavazzi.

Je place le PowerBoost dans mon installation électrique

Voici le schéma de la doc, le PowerBoost doit être capable de mesurer la totalité de la consommation électrique de l’installation.

Je raccorde le PowerBoost à la Wallbox

Enfantin et très bien expliqué dans la doc, le bus RS485 (ModBus) est composé de 2 bornes de données D+ et D- ainsi qu’une borne de masse GND.

On connecte donc la borne 3 et la borne 5 du PowerBoost puis via un câble de 3 fils minimum, on va se connecter à la Wallbox.

Pour ceux qui ont des perturbations ou beaucoup de longueur, j’ai appris grâce à Dimitri qu’il existait des câbles Modbus pour ce type de lien, à chercher donc…

J’active la résistance de terminaison sur la Wallbox

Ne pas oublier de fermer le bus en déplaçant le petit switch sur la Wallbox

Je vérifie que la communication entre l’EM112 et la Wallbox est active

J’active le PowerBoost dans l’application Wallbox

Pour que le PowerBoost soit pris en compte et pilote bien la Wallbox, il faut le déclarer dans l’application Wallbox.

Je fais bien la mise à jour de l’application si elle m’est proposée.

Ensuite, je vais dans Upgrades

Puis sur Power Boost

Activer le Power Boost et spécifier la puissance max (32A chez moi)

La prochaine étape sera donc :

• J’intègre le Power Boost EM112 de chez Carlo Gavazzi dans Home Assistant via le port RD485 (Modbus)

Bibliographie, références

• https://support.wallbox.com/wp-content/uploads/2022/07/FR_EMS_Guide_dinstallation_Francais.pdf
• https://forums.automobile-propre.com/topic/presentation-notre-wallbox-copper-sb-25379/
• https://youtu.be/qeQpva-dja0
• https://youtu.be/ejBzP3bqMBQ
• https://www.gavazzionline.com/pdf/EM112DS.pdf
• https://www.youtube.com/watch?v=HTVpM1ZAtAA
• https://www.youtube.com/watch?v=UMen8NHo-QU

Attention, pour cette rentrée, il est nécessaire d’installer la dernière modification de delphiki (passage en pronotepy 2.12.1), sinon l’authentification ne fonctionne plus.

J’ajoute le dépôt Pronote

J’installe l’intégration

Avant toute chose, j’installe l’intégration:

Je m’identifie

Ma fille est sur Atrium (Académie Aix-Marseille), c’est les identifiants Atrium qu’il faut donc utiliser.

J’utilise le compte Parent avec le lien https://xxxxxxxg.index-education.net/pronote/ sans oublier de sélectionner Atrium dans l’ENT.

Ma page Home Assistant réalisée l’année scolaire dernière refonctionne

Pour les détails de sa réalisation, il faut se référer à ce Retex :

• Je travaille sur les cartes HA de Pronote

Comme je l’ai expliqué dans :

• Commander son chauffage avec un Sonoff 4CH Pro R2 en multi-zones

Je pilote mon chauffage sur deux zones grâce à des fils pilotes. Dans le cadre de la bascule de Jeedom vers Home Assistant, il faut donc que j’arrive à piloter ces relais avec Home Assistant.

Pour l’instant le Sonoff 4CH Pro est piloté par ESP Easy, je le basculerai bientôt sur ESP Home, mais pour l’instant, ESP Easy permet de s’interfacer avec Jeedom ET Home Assistant via MQTT.

Pour la configuration, je me réfère à ce Retex :

• Migration Jeedom vers Home Assistant, le lien des ESP sous ESP-Easy vers HA

Je pilote des relais via MQTT

Comme expliqué dans le Retex ci dessus, il est nécessaire de configurer les entités qui vont permettre de récupérer les relais dans Home Assistant, cela se réalise dans le fichier mqtt.yaml

- name: "Relais 1 Chauffage"
  unique_id: switch.chauffage.relais1
  command_topic: "Chauffage/gpio/12"
  state_topic: "Chauffage/Relais1/Relais1"
  payload_on: "1"
  payload_off: "0"
  retain: true
  device_class: outlet
  device:
      name: "Chauffage"
      identifiers: "chauffage" 
      
      
- name: "Relais 2 Chauffage"
  unique_id: switch.chauffage.relais2
  command_topic: "Chauffage/gpio/5"
  state_topic: "Chauffage/Relais2/Relais2"
  payload_on: "1"
  payload_off: "0"
  retain: true
  device_class: outlet
  device:
      name: "Chauffage"
      identifiers: "chauffage" 
      
      
- name: "Relais 3 Chauffage"
  unique_id: switch.chauffage.relais3
  command_topic: "Chauffage/gpio/4"
  state_topic: "Chauffage/Relais3/Relais3"
  payload_on: "1"
  payload_off: "0"
  retain: true
  device_class: outlet
  device:
      name: "Chauffage"
      identifiers: "chauffage" 
      
      
- name: "Relais 4 Chauffage"
  unique_id: switch.chauffage.relais4
  command_topic: "Chauffage/gpio/15"
  state_topic: "Chauffage/Relais4/Relais4"
  payload_on: "1"
  payload_off: "0"
  retain: true
  device_class: outlet
  device:
      name: "Chauffage"
      identifiers: "chauffage" 

Dans HA, ces 4 entités sont facilement récupérées 

Je crée des input_select

C’est dans le fichier configuration.yaml que je déclare les deux entités des zones en leur permettant d’avoir 4 états possibles.

input_select:
  chauffage_etage_mode:
    name: Chauffage Zone Etage - Mode
    options:
      - "Confort"
      - "Eco"
      - "Hors Gel"
      - "Off"
    icon: mdi:help-circle-outline
    
  chauffage_rdc_mode:
    name: Chauffage Zone Rez de chaussée - Mode
    options:
      - "Confort"
      - "Eco"
      - "Hors Gel"
      - "Off"
    icon: mdi:help-circle-outline

Cela m’ajoute les deux entités :

• input_select.chauffage_rdc_mode
• input_select.chauffage_etage_mode

Je personnalise des input_select

Je tente toujours de rendre agréable visuellement les tuiles du dasboard, pour cela, mettre de la couleur et mettre des beaux icones qui correspondent aux états semble indispensable.

La personnalisation se réalise en ajoutant ces lignes dans customize.yaml

input_select.chauffage_etage_mode:
  templates:
    icon: >
      if (state == 'Confort') return 'mdi:fire';
      if (state == 'Eco') return 'mdi:leaf';
      if (state == 'Hors Gel') return 'mdi:snowflake-thermometer';
      if (state == 'Off') return 'mdi:power';
      return 'mdi:help-circle-outline';  
    icon_color: >
      if (state == 'Confort') return 'yellow';
      if (state == 'Eco') return 'green';
      if (state == 'Hors Gel') return '#2196f3';
      if (state == 'Off') return 'red';      
      
input_select.chauffage_rdc_mode:
  templates:
    icon: >
      if (state == 'Confort') return 'mdi:fire';
      if (state == 'Eco') return 'mdi:leaf';
      if (state == 'Hors Gel') return 'mdi:snowflake-thermometer';
      if (state == 'Off') return 'mdi:power';
      return 'mdi:help-circle-outline';  
    icon_color: >
      if (state == 'Confort') return 'yellow';
      if (state == 'Eco') return 'green';
      if (state == 'Hors Gel') return '#2196f3';
      if (state == 'Off') return 'red';    

Je pilote les relais depuis les input_select

La correspondance entre les Zones (Etage et Rez de Chaussée) doit se faire dans Home Assistant, le choix des relais pour commander le mode des zones doit être transparent pour l’utilisateur.

Pour cela, une automatisation va être déclenchée par un changement d’état de input_select.chauffage_rdc_mode et une autre par input_select.chauffage_etage_mode.

Cette automatisation va modifier l’état des relais afin d’envoyer l’ordre qui correspond au codage du fil pilote. Cela est expliqué ici.

Automatisation Pilotage Chauffage Rez de Chaussée

alias: Pilotage Chauffage Rez de Chaussée
description: ""
trigger:
  - platform: state
    entity_id:
      - input_select.chauffage_rdc_mode
condition: []
action:
  - if:
      - condition: state
        entity_id: input_select.chauffage_rdc_mode
        state: Confort
    then:
      - service: switch.turn_off
        data: {}
        entity_id:
          - switch.chauffage_relais_3_chauffage
          - switch.chauffage_relais_4_chauffage
      - stop: ""
  - if:
      - condition: state
        entity_id: input_select.chauffage_rdc_mode
        state: Eco
    then:
      - service: switch.turn_on
        data: {}
        entity_id:
          - switch.chauffage_relais_3_chauffage
          - switch.chauffage_relais_4_chauffage
      - stop: ""
  - if:
      - condition: state
        entity_id: input_select.chauffage_rdc_mode
        state: Hors Gel
    then:
      - service: switch.turn_off
        data: {}
        entity_id:
          - switch.chauffage_relais_4_chauffage
      - service: switch.turn_on
        data: {}
        entity_id:
          - switch.chauffage_relais_3_chauffage
      - stop: ""
  - if:
      - condition: state
        entity_id: input_select.chauffage_rdc_mode
        state: "Off"
    then:
      - service: switch.turn_off
        data: {}
        entity_id:
          - switch.chauffage_relais_3_chauffage
      - service: switch.turn_on
        data: {}
        entity_id:
          - switch.chauffage_relais_4_chauffage
      - stop: ""
mode: single

Automatisation Pilotage Chauffage Etage

alias: Pilotage Chauffage Etage
description: ""
trigger:
  - platform: state
    entity_id:
      - input_select.chauffage_etage_mode
condition: []
action:
  - if:
      - condition: state
        entity_id: input_select.chauffage_etage_mode
        state: Confort
    then:
      - service: switch.turn_off
        data: {}
        entity_id:
          - switch.chauffage_relais_2_chauffage
          - switch.chauffage_relais_1_chauffage
      - stop: ""
  - if:
      - condition: state
        entity_id: input_select.chauffage_etage_mode
        state: Eco
    then:
      - service: switch.turn_on
        data: {}
        entity_id:
          - switch.chauffage_relais_2_chauffage
          - switch.chauffage_relais_1_chauffage
      - stop: ""
  - if:
      - condition: state
        entity_id: input_select.chauffage_etage_mode
        state: Hors Gel
    then:
      - service: switch.turn_off
        data: {}
        entity_id:
          - switch.chauffage_relais_2_chauffage
      - service: switch.turn_on
        data: {}
        entity_id:
          - switch.chauffage_relais_1_chauffage
      - stop: ""
  - if:
      - condition: state
        entity_id: input_select.chauffage_etage_mode
        state: "Off"
    then:
      - service: switch.turn_off
        data: {}
        entity_id:
          - switch.chauffage_relais_1_chauffage
      - service: switch.turn_on
        data: {}
        entity_id:
          - switch.chauffage_relais_2_chauffage
      - stop: ""
mode: single

Je réalise une jolie carte pour le dashboard

Voici le résultat de ce que je souhaite comme carte :

A ce stade, je ne sais pas si je garderai la liste déroulante ou les boutons / sélecteurs, les deux fonctionnent.

Code de la carte pour la zone Rez de chaussée 

type: custom:stack-in-card
mode: vertical
cards:
  - type: custom:auto-entities
    show_empty: false
    card:
      type: custom:mushroom-chips-card
      view_layout:
        grid-area: chips
      alignment: center
    card_param: chips
    filter:
      template: >
        {% set ns =
        namespace(select=[],entity="input_select.chauffage_rdc_mode") %} {% for
        opt in state_attr(ns.entity, 'options') %}
          {% set icon = iif(opt== 'Confort', 'mdi:fire', icon) %}
          {% set icon_color_select = iif(opt== 'Confort', 'yellow', icon_color_select) %}
          {% set icon = iif(opt== 'Off', 'mdi:power', icon) %}
          {% set icon_color_select = iif(opt== 'Off', 'red', icon_color_select) %}
          {% set icon = iif(opt== 'Eco', 'mdi:leaf', icon) %}
          {% set icon_color_select = iif(opt== 'Eco', 'green', icon_color_select) %}
          {% set icon = iif(opt== 'Hors Gel', 'mdi:snowflake-thermometer', icon) %}
          {% set icon_color_select = iif(opt== 'Hors Gel', 'blue', icon_color_select) %}
                {% set ns.select = ns.select + [
            {
              "type": "template",
              "icon": icon,
              "entity": ns.entity,

              "icon_color": '{{ iif(is_state("' ~ ns.entity ~ '", "' ~ opt ~ '"), "' ~ icon_color_select ~ '", "disabled") }}',
              "tap_action": {
                "action": "call-service",
                "service": "input_select.select_option",
                "service_data": {
                  "entity_id": ns.entity,
                  "option": opt
                }
              },
              "card_mod": {
                "style": 'ha-card {
                
                    {% if is_state( "' ~ ns.entity ~ '" , "' ~ opt ~ '" ) %}
                      --chip-background: rgba(var(--rgb-grey), 0.1);
                    {% else %}
                      --chip-background: rgba(var(--mush-rgb-state-entity), 0.3);
                    {% endif %}
                    
                  }'
              }
            }
          ] %}
        {% endfor %} {{ ns.select }}
  - type: entities
    entities:
      - entity: input_select.chauffage_rdc_mode

Code de la carte pour la zone de l’Etage

type: custom:stack-in-card
mode: vertical
cards:
  - type: custom:auto-entities
    show_empty: false
    card:
      type: custom:mushroom-chips-card
      view_layout:
        grid-area: chips
      alignment: center
    card_param: chips
    filter:
      template: >
        {% set ns =
        namespace(select=[],entity="input_select.chauffage_etage_mode") %} {%
        for opt in state_attr(ns.entity, 'options') %}
          {% set icon = iif(opt== 'Confort', 'mdi:fire', icon) %}
          {% set icon_color_select = iif(opt== 'Confort', 'yellow', icon_color_select) %}
          {% set icon = iif(opt== 'Off', 'mdi:power', icon) %}
          {% set icon_color_select = iif(opt== 'Off', 'red', icon_color_select) %}
          {% set icon = iif(opt== 'Eco', 'mdi:leaf', icon) %}
          {% set icon_color_select = iif(opt== 'Eco', 'green', icon_color_select) %}
          {% set icon = iif(opt== 'Hors Gel', 'mdi:snowflake-thermometer', icon) %}
          {% set icon_color_select = iif(opt== 'Hors Gel', 'blue', icon_color_select) %}
                {% set ns.select = ns.select + [
            {
              "type": "template",
              "icon": icon,
              "entity": ns.entity,

              "icon_color": '{{ iif(is_state("' ~ ns.entity ~ '", "' ~ opt ~ '"), "' ~ icon_color_select ~ '", "disabled") }}',
              "tap_action": {
                "action": "call-service",
                "service": "input_select.select_option",
                "service_data": {
                  "entity_id": ns.entity,
                  "option": opt
                }
              },
              "card_mod": {
                "style": 'ha-card {
                
                    {% if is_state( "' ~ ns.entity ~ '" , "' ~ opt ~ '" ) %}
                      --chip-background: rgba(var(--rgb-grey), 0.1);
                    {% else %}
                      --chip-background: rgba(var(--mush-rgb-state-entity), 0.3);
                    {% endif %}
                    
                  }'
              }
            }
          ] %}
        {% endfor %} {{ ns.select }}
  - type: entities
    entities:
      - entity: input_select.chauffage_etage_mode

Conclusion

Je termine ici une étape importante de l’intégration de mon chauffage à Home Assistant. Je vais maintenant m’attaquer au pilotage de ce chauffage en fonction des personnes présentes ou pas, des heures, des jours et des périodes d’absence (vacances…)

Mon objectif originel était de vouloir allumer les lumières extérieures quand le portail s’ouvre mais uniquement la nuit !

Essais

J’ai testé plusieurs intégrations :

• Sun
• WorkDay dont je parle dans le Retex Ecole demain ?
• Times of the Day

Je créé un binary_sensor Il fait nuit

Evidemment, ce binary_sensor prend deux valeurs :

• on : quand il fait nuit
• off : quand il fait jour

Les plus puristes (qui cherchent les difficultés) pourront se faire plaisir et se créer un second binary_sensor pour le « il fait jour ».

Code simplissime de ce binary_sensor, à créer dans binary_sensor.yaml en pensant à bien l’avoir déclaré dans configuration.yaml :

- platform: tod
  name: "Il fait nuit"
  unique_id: binary_sensor.nuit
  after: sunset
  after_offset: "-00:10"
  before: sunrise
  before_offset: "+00:10"

after_offset et before_offset à 10min, ce n’est pas par souci de perfection, c’est pour me souvenir la syntaxe de ce paramètre si je veux l’ajuster dans l’avenir.

• Merci @ἶჰმ#6938 pour le coup de main.

Utilisation de ce binary_sensor dans une condition

Mon objectif est de n’allumer les lumières extérieures quand le portail s’ouvre QUE quand il faut nuit, voici donc la condition ajoutée :

Je ne mets pas la condition sur la fermeture, en effet si d’aventure il fait jour entre l’ouverture et la fermeture, les lumières resteraient allumées.

• Je vérifie la taille de ma base de données

il est surprenant de voir la vitesse à laquelle la base de données se remplie.

Dans ce retex, je vais tenter d’identifier les entités qui s’enregistrent le plus, vérifier si leur enregistrement est utile et configurer recorder de HA pour limiter la taille de la base.

J’identifie les entités qui ont le plus d’enregistrements

Je vais me connecter en ligne de commande SSH et je vais interroger la base de données

cd ~/config

sqlite3 home-assistant_v2.db
.header on
.mode column
.width 50, 10, 
SELECT states_meta.entity_id, COUNT(*) AS count FROM states JOIN states_meta ON states.metadata_id = states_meta.metadata_id GROUP BY states_meta.entity_id ORDER BY count DESC LIMIT 20;

Cette commande affiche les 20 entités qui ont le plus d’enregistrements (donc les plus consommatrices de taille de base de données).

En changeant LIMIT 20 en LIMIT 200 j’ai les 200 entités qui ont le plus d’enregistrements 

Je configure recorder

• Documentation

J’ai créé un fichier recorder.yaml sans oublier de le spécifier dans configuration.yaml

Ce fichier permet d’inclure ou d’exclure tout ce que je veux enregistrer (ou pas)

Evoluant en permanence, je ne mets pas ici de copie du code, mais le fichier est consultable sur le GitHub.

En sélectionnant ainsi ce que je souhaite enregistrer, je peux maitriser la taille de la base de données.