Gestion d'un véhicule électrique Renault

Introduction et objectifs

Les véhicules électriques ont beaucoup d'avantages, que ce soit leur expérience de conduite, leur sobriété en termes d'émissions de CO2 (sous réserve que l'énergie qui les propulse soit produite de manière décarbonée) ou leur coût au kilomètre. Cependant, cela vient avec des inconvénients inconnus des véhicules thermiques :

Une autonomie moindre, et une durée d'attente bien supérieure pour "faire le plein", et une forte variabilité des coûts de l'énergie en fonction du contexte.
Un vieillissement prématuré de la batterie si celle-ci est constamment trop chargée. Les constructeurs conseillent en général de se limiter à 80% quand c'est possible.

Pour ces raisons, il est nécessaire pour l'utilisateur de développer des stratégies pour minimiser les risques de panne sèche, minimiser le nombre et la durée des arrêts aux bornes de recharge et maximiser la durée de vie de la batterie. Cela passe par la combinaison de deux éléments fondamentaux :

L'accès aux informations du véhicule en temps réel, à distance.
La possibilité d'automatiser certaines actions en fonction du contexte.

Pour cela, les constructeurs proposent généralement des applications mobiles dédiées à leurs véhicules. Cependant, celles-ci sont parfois peu pratiques, incomplètes et ne permettent pas de grandes possibilités d'automatisation.

Nous allons nous intéresser au cas des véhicules électriques de Renault, habituellement contrôlée par l'application My Renault. En plus de construire un dashboard dédié portant un maximum d'informations du véhicule, nous allons ajouter les possibilités suivantes :

Stopper une charge en cours. Aussi incroyable cela puisse paraître, ce n'est plus possible depuis peu dans l'application My Renault.
Définir le pourcentage maximal de charge du véhicule, chose actuellement possible uniquement sur l'écran du véhicule.
Définir la programmation de charge en fonction de la position du véhicule.

⚠️

Les instructions qui suivent sont probablement compatibles avec de multiples véhicules électriques Renault, qui utilisent la même API, mais ont été testées uniquement sur Mégane E-Tech, il pourrait donc y avoir des choses à adapter.

👍

Il est à noter que toutes les automatisations proposées dans ce tutoriel ont été intensivement déboguées, améliorées et testées par votre serviteur pendant plusieurs semaines en condition réelles sur ce même véhicule.

Intégration du véhicule dans Home Assistant

Pour intégrer le véhicule dans Home Assistant, rien de plus simple : il suffit d'ajouter l'intégration Renault (non-officielle) et de connecter ses services en suivant les instructions de la page. Vous retrouverez alors directement votre véhicule avec un grand nombre de capteurs, ainsi que son emplacement.

Vous pouvez d'ores et déjà commencer à jouer avec, pour vous faire un joli dashboard.

⚠️

Attention cependant, l'API de Renault étant générique et commune à plusieurs véhicules, certains contrôles et capteurs ne fonctionneront pas forcément avec le vôtre, y compris certains boutons.

Maintenant, entrons dans le vif du sujet !

Stopper une charge en cours

Autrefois, il était possible de stopper une charge en cours via My Renault.

Aujourd'hui, cela semble impossible, que ce soit depuis l'application ou depuis l'API. Ne cherchez donc pas sur Home Assistant à activer le contrôle d'arrêt de la charge, cela ne fonctionnera simplement pas. Il est donc nécessaire de trouver un moyen détourné.

Après diverses expérimentations, le seul moyen fonctionnel de pouvoir stopper une charge est de programmer une charge hebdomadaire de 1 minute minimum. En effet, en forçant à 0 minute, ou en désactivant tous les jours de la semaine, le véhicule passe en mode de charge instantanée, soit exactement l'opposé de ce que l'on souhaite.

Pour réaliser cela, nous allons tout d'abord réaliser un script qui permettra de :

Modifier le programme de la charge personnalisée
Forcer le mode de charge en "personnalisée".

Rendez-vous sur la page des scripts de votre installation Home Assistant, puis cliquez sur Ajouter un script.

Dans ce script, nous allons tout d'abord ajouter un appel à un service de l'intégration Renault. Pour cela, on ajoute une action Appeler un service.

On sélectionne alors le service Renault: Update charge schedule, le véhicule dans la case Vehicle, et on ajoute la configuration suivante dans l'éditeur Schedules:

- id: 1
  activated: true
  monday: null
  tuesday: null
  wednesday: null
  thursday: null
  friday: null
  saturday: null
  sunday:
    startTime: T03:30Z
    duration: 1

Configuration YAML de l'appel au service de programmation de charge

On demande ainsi au véhicule de ne charger qu'une minute à 3h30 (heure locale) le dimanche. C'est un moindre mal.

À noter que si vous ne souhaitez pas perdre vos programmes habituels lorsque le script est appelé, il faudra les ajouter désactivés avec un ID différent (jusqu'à 5 pour une Mégane E-Tech, mais dépend du véhicule).
Par exemple, j'ai un programme sur mes heures creuses de 23h30 à 7h30 chaque jour. Je remplace donc la configuration ci-dessus par :

- id: 1
  activated: false
  monday:
    startTime: T23:30Z
    duration: 480
  tuesday:
    startTime: T23:30Z
    duration: 480
  wednesday:
    startTime: T23:30Z
    duration: 480
  thursday:
    startTime: T23:30Z
    duration: 480
  friday:
    startTime: T23:30Z
    duration: 480
  saturday:
    startTime: T23:30Z
    duration: 480
  sunday:
    startTime: T23:30Z
    duration: 480
- id: 2
  activated: true
  monday: null
  tuesday: null
  wednesday: null
  thursday: null
  friday: null
  saturday: null
  sunday:
    startTime: T03:30Z
    duration: 1

Configuration YAML de l'appel au service de programmation de charge

Ainsi, si je retourne dans mon véhicule ou sur son application, mon programme habituel est toujours accessible, désactivé.

Après l'appel au service, on ajoute un délai de 1 seconde, puis on va forcer le mode de charge sur instantanée. Pourquoi cela ? Car si le mode de charge est déjà sur "personnalisée" au moment de l'appel du script, alors la modification de programme ne sera pas prise en compte par le véhicule.

=> On fait donc un "va-et-vient" instantanée, personnalisée.

⚠️

Il est important d'ajouter entre chaque appel à l'API un délai de 1 seconde, car trop spammer l'API de Renault vous fera bannir quelques minutes/heures.

Pour ajouter l'action, on choisit une action de type Appareil, on sélectionne le véhicule, puis l'action Modifier l'option <véhicule> Mode de charge, et on sélectionne always_charging.

⚠️

2 modes instantanés apparaissent : always et always_charging. Le premier n'a pas d'effet sur la Mégane E-Tech.

On rajoute à nouveau un délai de 1 seconde, puis on choisit une action de type Appareil, on sélectionne le véhicule, puis l'action Modifier l'option <véhicule> Mode de charge, et on sélectionne schedule_mode.

Optionnellement, on peut choisir d'envoyer une notification à un téléphone pour prévenir de l'arrêt de la charge.

Vous retrouverez ci-dessous un aperçu de la séquence :

Configuration du script d'arrêt de la charge

Et la configuration correspondante pour mon cas :

alias: Mégane E-Tech arrêt de la charge
sequence:
  - service: renault.charge_set_schedules
    data:
      vehicle: 6a04fd328a617b19e5b357d57b8f7c89
      schedules:
        - id: 1
          activated: false
          monday:
            startTime: T23:30Z
            duration: 480
          tuesday:
            startTime: T23:30Z
            duration: 480
          wednesday:
            startTime: T23:30Z
            duration: 480
          thursday:
            startTime: T23:30Z
            duration: 480
          friday:
            startTime: T23:30Z
            duration: 480
          saturday:
            startTime: T23:30Z
            duration: 480
          sunday:
            startTime: T23:30Z
            duration: 480
        - id: 2
          activated: true
          monday: null
          tuesday: null
          wednesday: null
          thursday: null
          friday: null
          saturday: null
          sunday:
            startTime: T03:30Z
            duration: 1
  - delay:
      hours: 0
      minutes: 0
      seconds: 1
      milliseconds: 0
  - device_id: 6a04fd328a617b19e5b357d57b8f7c89
    domain: select
    entity_id: 7776649953a58672889b4d87d281d6d8
    type: select_option
    option: always_charging
  - delay:
      hours: 0
      minutes: 0
      seconds: 1
      milliseconds: 0
  - device_id: 6a04fd328a617b19e5b357d57b8f7c89
    domain: select
    entity_id: 7776649953a58672889b4d87d281d6d8
    type: select_option
    option: schedule_mode
mode: single
icon: mdi:ev-station

Configuration YAML du script d'arrêt de la charge

Le script est prêt à être utilisé. On peut donc dès lors l'associer à un bouton, qui sera utilisable dans un dashboard.

Pour cela, on crée une entrée de type bouton dans la section Entrées.

Ensuite, on crée une automatisation dans la section Automatisations.

Le déclencheur sera un appui sur le bouton, et l'action l'appel au script que nous avons défini dans cette section.

Ce qui donnera en YAML :

alias: Mégane E-Tech - Arrêt manuel de la charge
description: ""
trigger:
  - platform: state
    entity_id:
      - input_button.megane_e_tech_arret_de_la_charge_custom
condition: []
action:
  - service: script.megane_e_tech_arret_de_la_charge
    data: {}
mode: single

Configuration YAML de l'automatisation de l'arrêt manuel de charge

Ce bouton pourra dès lors remplacer avantageusement celui non fonctionnel de l'intégration Renault.

Définir le pourcentage maximal de charge du véhicule

Définition de la charge cible

S'il y a bien quelque chose dont ont l'habitude les utilisateurs de véhicules électriques, c'est de limiter le pourcentage de charge de leur batterie quand ils n'en ont pas besoin, afin d'en augmenter drastiquement la durée de vie. En général, un utilisateur chargera jusqu'à 80% pour ses trajets quotidiens, et à 100% uniquement pour les longs trajets, pour repousser le premier passage à la borne et maximiser le temps de charge à domicile, moins cher.

Chez Renault, il n'est possible de choisir ce niveau de charge maximal qu'à l'intérieur du véhicule. Ainsi, si vous rentrez de voyage, programmez votre véhicule à charger la nuit et vous rendez compte une fois au lit que vous n'avez pas rabaissé la limite de charge, vous êtes bon pour un petit tour gratuit dans le garage pour les mieux lotis, ou dehors pour les autres, pour faire 2 actions sur un écran.

Nous vous expliquons dans cette section comment faire tout cela en restant bien au chaud sous la couette.

Voici la stratégie globale que nous allons adopter :

Régler la charge max du véhicule sur 100% dans le véhicule et ne jamais y toucher.
Ajouter une commande numérique (ou slider) allant de 0 à 100% qui nous servira d'entrée pour notre pourcentage cible
Automatiser le démarrage et l'arrêt de la charge en fonction de cette commande et de la charge actuelle du véhicule.

En bonus, nous ajouterons également une estimation du temps restant jusqu'à la valeur cible.

On commence donc par aller dans son véhicule, et dans la section configuration, on active la charge à 100% de manière permanente.

Dans Home Assistant, on va dans la section Entrées.

On crée alors une entrée de type Nombre, qu'on nommera par exemple Mégane E-Tech charge cible, allant de 0 à 100.

Ajouté à un dashboard en l'ajoutant par entité, cela donnera le visuel ci-dessous.

Il nous faut maintenant déterminer si la charge doit être lancée ou arrêtée. Pour cela, on va créer une nouvelle entrée.

Cette entrée représentera la charge restante et elle vaudra donc à chaque instant (pourcentage cible) - (pourcentage actuel). Si cette valeur est inférieure à 0, alors il faut arrêter la charge. Si elle est supérieure à 0, il faut la continuer ou la reprendre.

Cette entrée aura un second rôle : celle de pallier à l'indisponibilité de la valeur du pourcentage actuel, qui arrive quand les serveurs de Renault sont indisponibles, ce qui arrive plusieurs fois par jour pendant quelques secondes/minutes. Si c'est le cas, alors on maintiendra la valeur de l'entrée.

On choisit le type Template pour cette nouvelle entrée, puis Modéliser un capteur.

On choisit comme nom par exemple Mégane E-Tech charge restante, et :

Unité de mesure : %
Classe d'appareil : Batterie
Classe d'état : Mesure

Le modèle d'état est le suivant, en remplaçant <vehicule_name> par l'identifiant de votre véhicule dans les entités de l'intégration Renault. Dans notre expérience, il s'agit de la plaque d'immatriculation du véhicule en minuscules, mais ce n'est pas une règle absolue. Vous pouvez utiliser l’auto-complétion dans l'éditeur pour trouver la bonne valeur.

{% if has_value('sensor.<vehicle_name>_batterie') %}
  {{ (states('input_number.megane_e_tech_charge_cible') | int) - (states('sensor.<vehicle_name>_batterie') | int) }}
{% elif has_value('sensor.megane_e_tech_charge_restante') %}
  {{ states('sensor.megane_e_tech_charge_restante') }}
{% else %}
  -1
{% endif %}

Modèle d'état du capteur de charge restante

Le else final permet de gérer le cas où le serveur est indisponible alors que l'entrée n'a pas encore été initialisée.

Automatisation de l'arrêt de la charge

On va maintenant pouvoir créer des automatisations basées sur la valeur définie à la section précédente. On se rend donc dans la section correspondante.

Commençons par l'arrêt de la charge. On va appeler le script d'arrêt de la charge créé dans la section Stopper une charge en cours quand la charge restante est inférieure à 0 depuis au moins 3 secondes.

💡

Ajouter la contrainte depuis au moins 3 secondes permet d'éviter de spammer les appels des automatisations, et donc les appels d'API Renault lorsqu'on est en train de manipuler le slider de batterie cible.

On crée donc une nouvelle automatisation, qu'on nomme par exemple Mégane E-Tech - Arrêt de la charge.

On ajoute un déclencheur de type Entité/État numérique.

On sélectionne Mode inférieur/Nombre Fixe et En dessous de 0, pendant 3 secondes.

Comme action, on appelle le service défini précédemment.

On valide, et l'automatisation est fonctionnelle : si vous sélectionnez un objectif de charge de 80%, alors la charge s'arrêtera quand la batterie atteindra exactement 81%.

💡

On n'arrête pas la charge lorsque le pourcentage est exactement égal à la cible, mais strictement supérieur, afin de mieux gérer le cas de la charge à 100%. En effet, la batterie continue encore à charger un peu après que la jauge du véhicule a numériquement atteint 100%, et il serait dommage de se priver de ce surplus quand on veut maximiser son autonomie.

La configuration de l'automatisation est finalement la suivante :

alias: Mégane E-Tech - Arrêt de la charge
description: Arrête la charge lorsque la cible est atteinte
trigger:
  - platform: numeric_state
    entity_id:
      - sensor.megane_e_tech_charge_restante
    for:
      hours: 0
      minutes: 0
      seconds: 3
    below: 0
condition: []
action:
  - service: script.megane_e_tech_arret_de_la_charge
    data: {}
mode: single

💡

Si vous possédez une prise connectée, vous pouvez coupler la programmation de l'arrêt de charge à l'extinction de celle-ci en ajoutant une action dans le script d'arrêt, si possible quelques secondes après l'arrêt de la charge du véhicule afin que les échanges d'information entre l'alimentation et le véhicule se terminent correctement.

Automatisation du démarrage de la charge

On sait maintenant arrêter automatiquement une charge au-delà d'un certain pourcentage. Maintenant, nous allons voir comment faire pour automatiser le démarrage de la charge.

Tout d'abord, nous devons définir un scénario simple ou plus complexe, qui correspond à nos usages.

Pour ce guide, nous détaillerons le scénario suivant :

Lorsque le véhicule est au domicile, la charge se fera pendant les heures creuses locales, de 23h30 à 7h30.
Lorsque le véhicule est au domicile "chez papa", la charge se fera durant les heures creuses locales, de 0h00 à 8h00.
Lorsque le véhicule est hors de l'une de ces deux zones, la charge se fera de manière instantanée.

⚠️

La position du véhicule se met à jour uniquement lors de l'arrêt du véhicule et cela peut prendre une ou deux minutes avant qu'elle soit connue de Home Assistant. Si cela est problématique pour vous, vous pouvez préférer vous baser sur la position d'un téléphone rafraîchie plus rapidement.

Évidemment, la charge ne se lancera que si la cible de charge est inférieure à la charge actuelle de la batterie.

Afin d'éviter d'écrire ce qu'on appelle communément un "spaghetti de code", on va définir des scripts pour ces 3 actions.

On se rend donc dans la section des Scripts.

On crée un script Mégane E-Tech - Charge instantanée. Celui-ci envoie la commande Modifier l'option <véhicule> Mode de charge vers always_charging (voir section Stopper la charge pour plus de détails).
On crée un script Mégane E-Tech - Heures creuses domicile (voir détails ci-dessous)
On crée un script Mégane E-Tech - Heures creuses chez papa (voir détails ci-dessous)

Pour ces deux derniers scripts, on va commencer par fabriquer le "payload" qu'on va utiliser pour envoyer le programme de charge à la voiture (voir section Stopper la charge pour plus de détails sur l'appel au service en question). Pour chaque appel à ce service, nous souhaitons que tous les programmes soient persistants afin de pouvoir continuer de passer manuellement de l'un à l'autre depuis la voiture ou l'application My Renault.

On définit donc un "payload" avec 3 entrées :

Une entrée correspondant aux heures creuses du domicile,
Une entrée correspondant aux heures creuses de chez papa,
Une entrée pour l'arrêt de la charge (définie et expliquée dans la section Stopper la charge)

Le "payload" général sera donc le suivant :

- id: 1
  activated: <value>
  monday:
    startTime: T23:30Z
    duration: 480
  tuesday:
    startTime: T23:30Z
    duration: 480
  wednesday:
    startTime: T23:30Z
    duration: 480
  thursday:
    startTime: T23:30Z
    duration: 480
  friday:
    startTime: T23:30Z
    duration: 480
  saturday:
    startTime: T23:30Z
    duration: 480
  sunday:
    startTime: T23:30Z
    duration: 480
- id: 2
  activated: <value>
  monday:
    startTime: T00:00Z
    duration: 480
  tuesday:
    startTime: T00:00Z
    duration: 480
  wednesday:
    startTime: T00:00Z
    duration: 480
  thursday:
    startTime: T00:00Z
    duration: 480
  friday:
    startTime: T00:00Z
    duration: 480
  saturday:
    startTime: T00:00Z
    duration: 480
  sunday:
    startTime: T00:00Z
    duration: 480
- id: 3
  activated: <value>
  monday: null
  tuesday: null
  wednesday: null
  thursday: null
  friday: null
  saturday: null
  sunday:
    startTime: T03:30Z
    duration: 1

Payload générique du service de programmation de charge

Dans ce "payload", j'ai remplacé toutes les valeurs des champs activated par <value>. En effet, la valeur devra être mise à true ou à false en fonction du script.

Script d'activation des heures creuses du domicile
- 1: true
- 2: false
- 3: false
Script d'activation des heures creuses de chez papa
- 1: false
- 2: true
- 3: false
Script d'arrêt de la charge (défini dans la section Stopper la charge, à modifier)
- 1: false
- 2: false
- 3: true

💡

A noter que ces configurations multiples pourraient être remplacées par une unique fonction avec un paramètre décidant lequel des 3 activer, mais il s'agit d'un usage plus avancé, et cette façon de faire est amplement suffisante pour un scénario avec si peu de possibilités.

En résumé, nous avons donc 4 scripts :

Mégane E-Tech - Arrêt de la charge
Mégane E-Tech - Charge instantanée
Mégane E-Tech - Heures creuses domicile
Mégane E-Tech - Heures creuses chez papa

💡

N'oubliez pas de mettre des actions de notification sur ces scripts si vous voulez être informés en temps réel des changements d'état du véhicule.

Ces scripts nous seront utiles pour les automatisations à venir. Allons donc dans la section Automatisations.

On crée une nouvelle automatisation, que l'on nomme par exemple Mégane E-Tech - Gestion activation charge.

Cette automatisation sera potentiellement déclenchée quand :

La charge restante devient strictement supérieure à -1 pendant 3 secondes
Le véhicule entre dans la zone Maison
Le véhicule sort de la zone Maison
Le véhicule entre dans la zone Chez papa
Le véhicule sort de la zone Chez papa

Insistons bien sur le mot potentiellement, car ces déclencheurs ne doivent avoir l'effet escompté si et seulement si la charge restante devient strictement supérieure à -1 pendant 3 secondes. Ainsi, quel que soit le déclencheur de l'automatisation, on va devoir s'assurer que cette condition est bien vraie avant d'effectuer la moindre action.

Cela se traduit de la façon suivante dans Home Assistant :

Conditions de déclenchement des scripts d'activation de la charge

Si l'automatisation est déclenchée et que la condition ci-dessus est vraie, alors on va se baser sur l'état de la voiture pour savoir que faire, selon l'algorithme suivant :

Si le véhicule est dans la zone Maison, appeler le script Mégane E-Tech - Heures creuses domicile
Sinon
- Si le véhicule est dans la zone Chez papa, appeler le script Mégane E-Tech - Heures creuses chez papa
- Sinon
  - Appeler le script Mégane E-Tech - Charge instantanée

Ce qui donne visuellement :

Logique d'appel des scripts d'activation de la charge

L'automatisation en YAML donne ceci :

alias: Mégane E-Tech - Gestion activation charge
description: Gestion de l'activation de charge de la Mégane E-Tech
trigger:
  - platform: numeric_state
    entity_id:
      - sensor.megane_e_tech_charge_restante
    for:
      hours: 0
      minutes: 0
      seconds: 3
    above: -1
  - platform: zone
    entity_id: device_tracker.<vehicle_name>_emplacement
    zone: zone.home
    event: enter
  - platform: zone
    entity_id: device_tracker.<vehicle_name>_emplacement
    zone: zone.chez_papa
    event: enter
  - platform: zone
    entity_id: device_tracker.<vehicle_name>_emplacement
    zone: zone.home
    event: leave
  - platform: zone
    entity_id: device_tracker.<vehicle_name>_emplacement
    zone: zone.chez_papa
    event: leave
condition:
  - condition: numeric_state
    entity_id: sensor.megane_e_tech_charge_restante
    above: -1
action:
  - if:
      - condition: zone
        entity_id: device_tracker.<vehicle_name>_emplacement
        zone: zone.home
    then:
      - service: script.megane_e_tech_heures_creuses_domicile
        data: {}
    else:
      - if:
          - condition: zone
            entity_id: device_tracker.<vehicle_name>_emplacement
            zone: zone.chez_papa
        then:
          - service: script.megane_e_tech_heures_creuses_chez_papa
            data: {}
        else:
          - service: script.megane_e_tech_charge_instantanee
            data: {}
mode: single

Vous voilà enfin libérés de toute action manuelle pour gérer la charge de votre véhicule !

💡

Vous pouvez également ajouter dans les scripts la modification de la cible de charge, par exemple pour alterner entre 80% et 100% en fonction du contexte. Attention cependant, cela signifie que dans certaines conditions, l'automatisation ci-dessus pourra être appelée 2 fois de suite, le comportement est à vérifier expérimentalement.

Estimation du temps de charge restant

Comme votre véhicule est désormais réglé de manière permanente sur une cible de charge à 100%, le temps de charge restant renvoyé par la voiture correspond toujours au temps restant avant une charge complète, et pas au temps restant avant la charge jusqu'à votre cible.

Nous allons donc créer une nouvelle valeur dynamique que l'on pourra importer dans un dashboard, qui nous permettra d'estimer ce temps.

Pour cela, nous allons faire une estimation purement linéaire : Si la batterie est actuellement à 60%, que je veux charger jusqu'à 80%, et que le véhicule annonce 1h de charge restante, la charge restante jusqu'à notre cible sera estimée à (100-80)/(100-60)*1h, c'est-à-dire 30 minutes. En cas de charge rapide, cette estimation est inexacte, car la vitesse de charge diminue au cours du temps, mais en cas de charge lente, qui correspond à la majorité des usages, cette estimation est réaliste.

Nous allons donc créer une nouvelle entrée de type Template.

On la nommera par exemple Mégane E-Tech temps de charge restant.

On choisit les options suivantes :

Unité de mesure : min
Classe d'appareil : Durée
Classe d'état : Mesure

On définit alors le modèle d'état suivant :

{%
  set variables = {
    "total_left_duration": states('sensor.<vehicle_name>_temps_de_charge_restant'),
    "curr_battery": states('sensor.<vehicle_name>_batterie'),
    "target_battery": states('input_number.megane_e_tech_charge_cible'),
    "total_left_charge": 100 - states('sensor.<vehicle_name>_batterie') | float,
    "target_left_charge": states('input_number.megane_e_tech_charge_cible') | float - states('sensor.<vehicle_name>_batterie') | float
    }
%}

{% if variables.curr_battery | int >= 100 or
  variables.total_left_duration | int <= 0 or
    variables.target_battery <= variables.curr_battery -%}
  {{ 0 }}
{%- else -%}
  {{ (variables.total_left_duration | float * (variables.target_left_charge/variables.total_left_charge)) | int }}
{%- endif %}

Modèle d'état de l'estimation de temps de charge restant

On peut alors utiliser cette entrée en tant que capteur dans un dashboard. Voici un exemple de ce que cela peut donner :

Temps restant cible et temps restant à 100%

Vous êtes désormais prêts à affronter la route sans (presque) jamais passer par My Renault et à customiser votre dashboard comme bon vous semble !

Exemple de dashboard

Voici un exemple de dashboard utilisant l'intégration Renault et les activateurs et valeurs créées lors de ce tutoriel, à savoir :

Le slider de batterie cible
Le temps de charge restant jusqu'à la cible
L'action d'arrêt de la charge fonctionnel

Celui-ci intègre aussi une prise connectée (uniquement au domicile) qui permet de mesurer la puissance et la consommation.

Conclusion

Grâce à Home Assistant, il est possible, au-delà de la domotique, de suivre et gérer son véhicule électrique au-delà de ce que proposent les applications des constructeurs.

On regrettera cependant que ces derniers (notamment les puissants constructeurs historiques tels que Renault) ne proposent pas des applications plus complètes, ou des intégrations officielles pour tendre la main aux communautés de l'Open Source.

Aller plus loin

On peut imaginer de multiples scénarios pour améliorer les automatisations de la charge du véhicule.

Par exemple, un producteur d'énergie solaire pourrait très bien déclencher la charge du véhicule lorsqu'il produit a minima une certaine quantité d'énergie, et l'arrêter quand ce n'est pas le cas. Cela nécessiterait probablement de définir un minimum de temps de production au-delà ou en-dessous du seuil et un minimum de temps de chargement pour le véhicule pour déclencher les automatisations, pour éviter les arrêts et reprises de charge intempestives.

Un utilisateur ayant souscrit à une offre type EDF Tempo et ayant accès aux prévisions du lendemain (par exemple via un module ZLinky de chez Lixee) peut également essayer d'optimiser le coût de sa recharge en fonction des prix en cours et à venir.