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

Les capteurs Wallbox

Je décortique l’entité Wallbox Portal Added Energy

Voici les données relevées

L’unité est le kWh donc nous sommes bien une quantité d’énergie. Il s’agit de la quantité d’énergie injectée dans le véhicule lors de la dernière charge.

Je ne branche pas le véhicule à la Wallbox tous les jours, je constate donc que quand je ne fais rien, le portail Wallbox garde la dernière valeur, de la dernière charge.

Le reset de cette quantité d’énergie doit se faire à l’heure à laquelle j’ai branché le véhicule. Je ferai attention les prochains jours.

Dans le graphique ci dessus, je vois que le 3 octobre, 5 octobre et le 7 octobre, entre 20h30 et 21h, la valeur est réinitialisée à 0.

Ensuite la Wallbox attend que la première plage horaire de charge arrive, 2h10 chez moi.

La Wallbox s’arrête seule quand le véhicule lui confirme qu’il a assez mangé, il est configuré sur 80% de la batterie pour les trajets quotidiens.

Les plateaux à 17.3kWh, à 22,18kWh, 23.86kWh et 23.43kWh vont me permettre d’afficher sur une carte HA la dernière quantité d’énergie injectée dans le véhicule… parfait.

Je décortique l’entité Wallbox Portal Added Range

Voici les données relevées

L’unité est le km. J’en déduis donc que c’est l’estimation du nombre de km ajoutés à chaque charge.

Je ne sais pas trop comment la Wallbox peut savoir cela, je pensais que c’était propre au véhicule et évidemment à la conduite, ce doit être une estimation.

Le fonctionnement de ces données est identique à l’entité précédente, je conclue immédiatement que je vais pouvoir ajouter sur la carte HA le dernier nombre de km ajoutés dans le véhicule… parfait.

Je décortique l’entité Wallbox Portal Charging Power

Voici les données relevées

L’unité est kW, c’est donc la puissance consommée par la Wallbox pour charger le véhicule.

On constate que c’est assez variable, cela est calculé par l’EM112 placé en début d’installation qui informe la Wallbox de combien d’énergie elle peut disposer, cela en fonction des autres équipements qui sont déjà allumés dans l’installation.

Je vais pouvoir ajouter cette information sur la carte HA, peut-être les dernière 24h car en principe, on n’est pas devant l’écran quand la charge est en cours.

Je décortique l’entité Wallbox Portal Charging Speed

Cette entité est toujours à zéro sur mon système, je ne dois pas utiliser ce mode. Peut être que cela est disponible en tri-phasé ou avec des équipements supplémentaires Je ne sais pas, comme la (mini, archi-mini) doc de l’intégration ne dit rien, je laisse tomber, je vais même désactiver cette entité.

Je décortique l’entité Wallbox Portal Cost

Cette entité est toujours à zéro sur mon système, je pensais y trouver le coût de la dernière charge. Je laisse tomber, je n’en ai pas besoin, je ferai moi-même la multiplication. Je désactive l’entité.

Je décortique l’entité Wallbox Portal Current Mode

Cette entité s’actualise mais toujours à la même valeur : 1, je ne dois utiliser que le Mode 1, de quoi, je n’en sais rien, comme cela ne m’apporte rien, je le désactive.

Je décortique les entités Wallbox Portal Depot Price et Wallbox Portal Energy Price

Ces entités me donne le prix du kWh, je l’ai fixé à 0.20€ dans la configuration, il me donne donc en permanence 0.20€.

Je ne comprends pas trop ce que veut dire Depot Price, je ne vais conserver que Energy Price.

Je vais le garder que si un jour j’affine cette valeur, je le ferai dans l’application Wallbox et si tout va bien, cela arrivera dans HA. Je suis surpris que Wallbox ne permette pas de mettre un prix pour les Heures Creuses et un prix pour les HP, peut être une évolution un jour.

Je décortique l’entité Wallbox Portal Discharged Energy

L’unité est en kWh, je ne vois pas pourquoi on pourrait utiliser la Wallbox pour décharger une batterie. J’imagine que cette fonctionnalité est prévue quelque part, je ne l’ai pas vue. Sur certains chargeurs de piles, on a un bouton pour décharger les piles avant de les charger, c’est peut-être cette logique, cette entité me donne 0 en permanence, je vais la désactiver à ce stade.

Je décortique les entités Wallbox Portal Max Available Power et Wallbox Portal Max. Charging Current

L’unité est en A et les affichent en permanence 32A, c’est la valeur configuré dans ma Wallbox (je suis en monophasé). Je les désactivent, cela n’apporte rien à la carte HA.

Je décortique l’entité Wallbox Portal State of Charge

Cette entité qui est en % n’affiche rien chez moi. Peut etre utile en tri-phasé, je ne sais pas, je la désactive.

Je décortique l’entité Wallbox Portal Status Description

Entité particulièrement importante, elle me donne l’état de la Wallbox, c’est elle qui va rendre mon écran intéressant.

A ce stade, j’ai repéré 5 états que je vais utiliser pour faire de beaux logos d’état de la Wallbox

• Scheduled
• Ready
• Waiting for car demand
• Disconnected
• Charging

Bilan de ces analyses

Voici ce que je garde pour les exploiter 

Les Contrôles Wallbox

Je décortique l’entité Wallbox Portal Pause Resume

Elle a deux valeurs :

• Désactivée soit Pause
• Activée soit Resume (Reprise)

J’ai testé cela, c’est assez pratique. Par exemple, on branche le véhicule, la charge ne démarre pas car nous sommes hors de la plage de charge (=heures creuses chez moi), on appuie sur Reprise et la charge démarre. J’imagine que si on est en charge, si on appuie sur Pause, cela doit couper la charge mais je n’ai pas testé.

Un bouton sur le Dashboard peut être sympa et pratique.

Je décortique l’entité Wallbox Portal Locked Unlocked

Cette entité n’a pas d’intérêt pour moi, elle doit servir pour les Wallbox partagées dans des co-pro par exemple ou chacun vient la déverrouiller avec une carte RFID pour s’en servir.

Elle est toujours sur Déverrouillé, je la désactive.

Je décortique l’entité Wallbox Portal Max. Charging Current

C’est un curseur qui va de 0 à la valeur max du courant configuré.

Elle n’a d’intérêt que si on n’utilise pas de EM112 en tête d’installation et qu’on veut réduire la consommation de la Wallbox pour laisser un peu de place à d’autres équipements.

Chez moi, c’est configuré sur 32A et je n’y touche jamais, je désactive cette entité.

Bilan de ces analyses

Voici ce que je garde pour les exploiter

Je crée de belles images pour les états de la Wallbox

A noter que je n’en ai pas trouvé, nulle-part sur le web. Alors je lance mon vieux Photoshop et c’est parti…

Je ne dépose pas les images mais si vous les réutilisez, je ne demande rien, juste d’indiquer la source.

Je vais créer une carte pour afficher l’état de la Wallbox

Comme expliqué plus haut, la Wallbox peut prendre 5 états.

• Scheduled
• Ready
• Waiting for car demand
• Disconnected
• Charging

Ces états sont fournis par entité : Wallbox Portal Status Description

La carte sera donc

type: image
entity: sensor.wallbox_portal_status_description
style:
  width: 100%
  top: 50%
  left: 50%
state_image:
  Scheduled: /local/maison/Wallbox/Scheduled.png
  Ready: /local/maison/Wallbox/Ready.png
  Waiting for car demand: /local/maison/Wallbox/Waiting-for-car-demand.png
  Disconnected: /local/maison/Wallbox/Disconnected.png
  Charging: /local/maison/Wallbox/Charging.png

A noter que j’ai placé les 5 fichiers png dans le dossier /config/www/maison/Wallbox

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

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