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 :
Je préviens tout de suite, ce Retex n’est qu’à vocation pédagogique, je le rédige pour partager une méthodologie, à savoir que j’ai réalisé cette fonctionnalité différemment depuis, donc je n’ai pas ce process en prod.
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.
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
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)
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.
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")
Une pour initialiser le sensor, l’autre pour ajouter une donnée
alias: Initialise les sessions de charge
description: ""
trigger: []
condition: []
action:
- service: pyscript.wallbox_charges
data:
action: init
mode: single
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
<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) }}
€"></ha-alert> <ha-alert alert-type="info" title="Dernière année : {{
power_annee.value | int }} kWh - {{ cout_annee.value | float | round(2) }}
€"></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)
}}€">
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é.
Un petit coup de Photoshop ou autre et voici le fichier de base
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 n’ai pas trouvé comment faire cela avec Canva, j’utilise un outil en ligne
Le résultat donne
Pour avoir trois états, je génère deux autres fichiers, un plus rapide et un plus lent, donc trois fichiers au total :
 |
 |
 |
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).
Pour pouvoir indiquer à mes automatisations ou scripts si j’autorisais ou pas l’arrosage automatique, je voulais créer un switch “virtuel”, qui n’a de lien avec aucune entité (donc pas un template) et qui conserve son état à la relance de Home Assistant (persistant).
Voici la bête :
Il faut un peu peur avec ses 10 connecteurs à vis et son grand écran plein de chiffres.
J’avais supprimé en juillet dernier l’intégration Pronote, je repars donc tout neuf pour réactiver tout cela pour la rentrée de septembre.
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. Lire la suite
Comme je l’ai expliqué dans :
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.
Mon objectif originel était de vouloir allumer les lumières extérieures quand le portail s’ouvre mais uniquement la nuit !
J’ai testé plusieurs intégrations :
Evidemment, ce binary_sensor prend deux valeurs :
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.
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.
Comme évoqué dans le retex
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. Lire la suite
