Bonjour, voici mon 1er vrai tuto merci d’être indulgent 
Version mise à jour le 07/06/2023
Ce tuto sera amené à évoluer, n’hésitez pas à aimer le post ou apporter des suggestions
Les différentes Valeurs connues / Étapes :
-
Obtenir sa consommation soutirée du réseau instantanée (ex: Zlinky)
-
Obtenir sa production solaire instantanée ( dans mon cas le module Ecu_R de Apsystem)
Comment obtenir la valeur consommation instantanée quand la production solaire altère la valeur soutirée du réseau et que tu ne fais que de l’auto-consommation ?
Sensor(capteur) utilisés :
- un capteur qui surveille la consommation électrique en temps réel « sensor.zlinky_sinsts ».
- un capteur qui surveille la production solaire « sensor.ecu_current_power »
Cela va nous donnée la valeur la plus précise possible !
Voici un tutoriel étape par étape pour comprendre et utiliser ce code :
Créer un nouveau capteur dans Home Assistant : Pour créer ce nouveau capteur, il faut ajouter le code suivant à votre configuration Home Assistant, sous la section « sensor » :
- Valeur a modifier en fonction de votre installation :
{% set puissance_solaire_installée = 2400 %} # dans mon cas 2400 watt crête
{% set consommation_corrigee = moyenne_consommation_horssolaire * (1 + (production_solaire / ((puissance_solaire_installee - moyenne_consommation_horssolaire) / 10)) / 100) %}
- cette ligne de code calcule la consommation corrigée en fonction de la moyenne de consommation hors solaire et de la puissance solaire installée. Elle ajuste la consommation en fonction de la production solaire pour obtenir une estimation plus précise de la consommation réelle.
- le nombre « 10 » est à modifier à votre convenance il correspond à la marge d’augmentation de conso de la maison en journée (en cas de production solaire)
Exemple : si pour vous entre la nuit et la journée (hors période de grosse conso four, lave linge ect…) votre consommation électrique peux évoluer dans votre foyer pour vous jusqu’a 15% de + que hors période solaire (la nuit) Alors modifier le nombre 10 → 15 ect…
# Création de valeur moyenne statistics
sensor:
- platform: statistics
entity_id: sensor.consommation_electrique_corrigee #capteur de mesure de consommation_electrique_corrigee
name: "Moyenne consommation électrique" #nom du capteur final
#sampling_size: 576 #288
max_age:
minutes: 30
state_characteristic: mean
- platform: statistics
entity_id: sensor.zlinky_sinsts #capteur Zlinky lissé sur 1 journée avec influence de production solaire
name: "Moyenne conso zlinky" #nom du capteur final
#sampling_size: 2880 #288
max_age:
hours: 24
state_characteristic: mean
##############################################################################
### Consommation Moyenne Electrique Corrigée
##############################################################################
- platform: template
sensors:
consommation_electrique_corrigee:
friendly_name: "Consommation électrique corrigée"
unit_of_measurement: "Wh"
value_template: >-
{% set consommation_reseau = states('sensor.zlinky_sinsts')|float(default=0) %}
{% set production_solaire = states('sensor.ecu_current_power')|float(default=0) %}
{% set moyenne_consommation_horssolaire = states('sensor.moyenne_conso_zlinky')|float(default=0) %}
{% set puissance_solaire_installee = 2400 %}
{% set consommation_corrigee = 0 %}
{% set last_updated_ecu = states.sensor.ecu_current_power.last_updated %}
{% set last_updated_zlinky = states.sensor.zlinky_sinsts.last_updated %}
{% set minutes_since_update_ecu = ((as_timestamp(now()) - as_timestamp(last_updated_ecu)) / 60)|int(default=0) %}
{% set minutes_since_update_zlinky = ((as_timestamp(now()) - as_timestamp(last_updated_zlinky)) / 60)|int(default=0) %}
{% if production_solaire > 0 %}
{% if last_updated_ecu and last_updated_zlinky and minutes_since_update_ecu <= 15 %}
{% if consommation_reseau > 0 %}
{% set consommation_corrigee = production_solaire + consommation_reseau %}
{% if consommation_corrigee >= 0.5 * moyenne_consommation_horssolaire or consommation_corrigee <= 1.5 * moyenne_consommation_horssolaire %}
{% set consommation_corrigee = consommation_corrigee %}
{% else %}
{% set consommation_corrigee = moyenne_consommation_horssolaire %}
{% endif %}
{% elif consommation_reseau == 0 %}
{% set consommation_corrigee = moyenne_consommation_horssolaire * (1 + (production_solaire / ((puissance_solaire_installee - moyenne_consommation_horssolaire) / 10)) / 100) %}
{% endif %}
{% endif %}
{% elif production_solaire == 0 %}
{% if last_updated_zlinky and minutes_since_update_zlinky <= 15 %}
{% set consommation_corrigee = consommation_reseau %}
{% endif %}
{% endif %}
{{ consommation_corrigee }}
-
Configuration du capteur de statistiques pour la consommation électrique moyenne :
- Utilisation de la plateforme « statistics ».
- L’entité associée est « sensor.consommation_electrique_corrigee ».
- Nom du capteur : « Moyenne consommation électrique ».
- Les données sont limitées à la dernière demi-heures.
-
Définition du capteur de consommation électrique corrigée le + important :
-
Tout d’abord, les différentes variables nécessaires sont initialisées en récupérant les états des capteurs. Cela inclut les capteurs de consommation (sensor.zlinky_sinsts), de production solaire (sensor.ecu_current_power), et de la moyenne de consommation hors solaire (sensor.moyenne_conso_zlinky). Ces valeurs sont converties en nombres flottants pour les calculs ultérieurs.
-
La variable puissance_solaire_installee est définie pour représenter la puissance solaire installée. Cela peut être adapté à votre configuration spécifique.
-
La variable consommation_corrigee est initialement définie à 0. C’est la valeur finale qui représentera la consommation électrique corrigée.
-
Les variables last_updated_ecu et last_updated_zlinky sont définies pour obtenir le moment de la dernière mise à jour des capteurs de production solaire et de consommation. Cela permet de vérifier si les capteurs ont été mis à jour récemment.
-
Les variables minutes_since_update_ecu et minutes_since_update_zlinky sont calculées pour déterminer le temps écoulé depuis la dernière mise à jour des capteurs, exprimé en minutes.
-
La logique conditionnelle commence en vérifiant si la production solaire est supérieure à 0. Si c’est le cas, cela signifie qu’il y a de la production solaire en cours.
-
Ensuite, il est vérifié si les capteurs de production solaire et de consommation ont été mis à jour dans les 15 dernières minutes (minutes_since_update_ecu <= 15 et minutes_since_update_zlinky <= 15). Cela permet de s’assurer que les données sont récentes et fiables.
-
Si les conditions précédentes sont satisfaites, la logique continue à vérifier si la consommation réseau est supérieure à 0. Si tel est le cas, cela signifie qu’il y a de la consommation provenant du réseau électrique.
-
Dans ce cas, la variable consommation_corrigee est calculée en ajoutant la production solaire à la consommation réseau. Cela donne une estimation de la consommation totale corrigée.
-
Ensuite, il est vérifié si la valeur de consommation_corrigee est soit supérieure ou égale à 0,5 fois la moyenne de consommation hors solaire (moyenne_consommation_horssolaire), soit inférieure ou égale à 1,5 fois cette moyenne. Cette condition vise à s’assurer que la valeur corrigée reste dans une plage raisonnable par rapport à la moyenne.
-
Si la condition précédente n’est pas satisfaite, cela signifie que la consommation corrigée est anormalement élevée ou faible par rapport à la moyenne. Dans ce cas, la valeur de consommation_corrigee est réglée sur la moyenne de consommation hors solaire. Cela permet d’éviter des fluctuations extrêmes dans la consommation corrigée.
-
Si la production solaire est égale à 0, cela signifie qu’il n’y a pas de production solaire en cours. Dans ce cas, il est vérifié si le capteur de consommation a été mis à jour dans les 15 dernières minutes.
-
Si tel est le cas, la valeur de consommation_corrigee est simplement définie sur la valeur de la consommation réseau. Cela signifie que la consommation corrigée sera égale à la consommation provenant du réseau électrique uniquement, sans tenir compte de la production solaire.
-
Enfin, la valeur finale de consommation_corrigee est renvoyée, représentant la consommation électrique corrigée en fonction des conditions et des calculs effectués.
La logique globale du code vise à ajuster la consommation électrique en tenant compte de la production solaire et des conditions spécifiques pour obtenir une estimation corrigée de la consommation.
Exemple 1 : Supposons que les valeurs de
sensor.zlinky_sinstssoient :1000, 1200, 1400, 1600, 1800Supposons quesensor.ecu_current_powersoit :2000Alors, le code calcule la moyenne quotidienne de consommation d’énergie en ajoutant la production d’énergie solaire (2000 W) à la dernière valeur desensor.zlinky_sinsts(1800 W) si elle est différente inférieur ou égale/supérieur ou égale +/-50% de la moyenne zlinky, pour obtenir une nouvelle valeur de 3800 W. Ensuite, cette nouvelle valeur est ajoutée à la liste pour calculer la moyenne quotidienne de consommation d’énergie, qui est égale à2200.0W.
Exemple 2 : Supposons que les valeurs de
sensor.zlinky_sinstssoient :1000, 1200, 1400, 1600, 1800Supposons quesensor.ecu_current_powersoit :0Alors, le code calcule la moyenne quotidienne de consommation d’énergie en utilisant la dernière valeur connue desensor.moyenne consomation electrique, qui est égale à1800.0W.
Pour intégrer un capteur dans le dashboard energy il va nous faloir 3 étapes:
-
Creer le capteur « energy_exporting » qui calculera la quantité d’électricité que vous exportez vers le réseau en soustrayant votre production solaire à votre consommation électrique moyenne actuelle :
-
Creer un capteur statistics « hours_energy_exporting » qui calcule la moyenne dans heures des valeurs du capteur « energy_exporting » (cette valeur va nous afficher une valeur net et fidèle !
-
Creer une automatisation qui va aller chercher a toute les fin de chaque heure xxH59 minutes la valeurs la plus exacte et l’ajouter à la valeur précedente dans un input_number (cumul heure après heure.
-
Le capteur Finale : —> le daily_energy_exported <-----
Il va colleter les valeurs moyenne exporté de chaque heure et les renvoyé au dashboard energy (simple et efficace).
template:
- sensor: #Capteur compatible dashboard energy
# calcul power export
- name: energy_exporting
state: "{{ (max(states.sensor.ecu_current_power.state |float |round(2) - states.sensor.moyenne_consommation_electrique.state |float |round(2),0) /1000) }}"
unit_of_measurement: 'kWh'
device_class: energy
state_class: total_increasing
icon: 'mdi:flash'
unique_id: 'énergy_export'
# calcul power import (consomation live) - (production PV Live)
- name: energy_importing
state: "{{ (max(states.sensor.consommation_electrique_corrigee.state |float | round(2) - states.sensor.ecu_current_power.state |float | round(2), 0) /1000) }}"
unit_of_measurement: 'kWh'
device_class: energy
state_class: total_increasing
icon: 'mdi:flash'
##################################
### Moyenne energy hours export ##
##################################
- platform: statistics
entity_id: sensor.energy_exporting #capteur energy exporté moyenne /1h = (solaire - consommation_electrique_corrigee)
name: "hours energy exporting" #nom du capteur final
max_age:
hours: 1
state_characteristic: mean
#######################
## Automatisation ##
#######################
# Relève la valeur exportée moyenne dans l'heure et ajoute la valeur à la précédente dans un input_number
automation:
alias: "[Update] daily exporté "
description: ""
trigger:
- platform: time_pattern
minutes: "59"
condition:
- condition: template
value_template: "{{ now().minute == 59 }}"
action:
- service: input_number.set_value
data_template:
value: >-
{{ (states('input_number.daily_export') | float(0) |round(2)) + (states('sensor.hours_energy_exporting') | float(0) |round(2)) }}
target:
entity_id: input_number.daily_export
mode: single
#######################
## input_number ##
#######################
input_number:
daily_export:
name: daily_export
initial: 0
min: 0
max: 999
# Création capteur statistics energy "daily_energy_export"
- name: daily_energy_exported
state: "{{ states.input_number.daily_export.state |float(0) |round(2) }}"
unit_of_measurement: 'kWh'
device_class: energy
state_class: total_increasing
icon: 'mdi:flash'
-
Cette automatisation a pour objectif de surveiller la production solaire actuelle et de notifier l’utilisateur lorsque la production dépasse ou n’atteint pas certains seuils. La notification contiendra des informations sur la quantité d’énergie produite et des suggestions sur les appareils électroménagers pouvant être utilisés en fonction de la quantité d’énergie produite.
-
Plus précisément, l’automatisation est déclenchée chaque fois que l’état du capteur de puissance solaire actuelle change ou à 23h55 chaque jour. Il y a également des conditions pour s’assurer que la présence de l’utilisateur est détectée et que l’écart entre la production solaire actuelle et une valeur seuil prédéfinie ne dépasse pas 200 watts.
-
En fonction de la production solaire actuelle, l’automatisation déclenchera différentes actions qui incluent l’envoi de notifications avec des messages différents en fonction des seuils atteints et la mise à jour d’une entité de type « input_number » qui stockera la valeur de production solaire actuelle. Si l’automatisation est déclenchée après 23h55, la valeur stockée dans « input_number » sera réinitialisée à 0.
############################
### Input_number ###
############################
input_number:
ecu_r:
name: Ecu-R
initial: 0
min: 0
max: 10000
- id: '1679590381458'
alias: '[NOTIFY] Production Solaire'
description: ''
trigger:
- platform: state
entity_id:
- sensor.ecu_current_power
- platform: time
at: '23:55:00'
condition:
- condition: state
entity_id: binary_sensor.presence_home
state: 'on'
for:
hours: 0
minutes: 0
seconds: 0
- condition: or
conditions:
- condition: template
value_template: '{{ states(''sensor.ecu_current_power'')|float > states(''input_number.ecu_r'')|float
+ 200}}'
- condition: template
value_template: '{{ states(''sensor.ecu_current_power'')|float < states(''input_number.ecu_r'')|float
- 200}}'
action:
- choose:
- conditions:
- condition: numeric_state
entity_id: sensor.ecu_current_power
above: 451
below: 850
sequence:
- service: notify.notify
data:
title: ⚡Surproduction solaire légère
message: '⛅ Production solaire actuelle : {{ states(''sensor.ecu_current_power'')
}}wh \n ℹ️ Ideal pour : Lampe, Televiseur, Ordinateur portable'
- service: input_number.set_value
data_template:
value: '{{states(''sensor.ecu_current_power'') }}'
target:
entity_id: input_number.ecu_r
- conditions:
- condition: numeric_state
entity_id: sensor.ecu_current_power
below: 450
above: 400
sequence:
- service: notify.notify
data:
title: ⚡Production sans surplus
message: "\U0001F325️ Production solaire actuelle : {{ states('sensor.ecu_current_power')
}}wh \\n"
- service: input_number.set_value
data_template:
value: '{{states(''sensor.ecu_current_power'') }}'
target:
entity_id: input_number.ecu_r
- conditions:
- condition: numeric_state
entity_id: sensor.ecu_current_power
above: 851
below: 1300
sequence:
- service: notify.notify
data:
title: ⚡Surproduction moyenne
message: "\U0001F324️ Production solaire actuelle : {{ states('sensor.ecu_current_power')
}}wh \\n ℹ️ Ideal pour : Fer à repasser, Micro-onde, Aspirateur, Lave-linge,
Grille-pain, Bouilloire.."
- service: input_number.set_value
data_template:
value: '{{states(''sensor.ecu_current_power'') }}'
target:
entity_id: input_number.ecu_r
- conditions:
- condition: numeric_state
entity_id: sensor.ecu_current_power
above: 1300
sequence:
- service: notify.notify
data:
title: ⚡Surproduction importante
message: '☀️ Production solaire actuelle : {{ states(''sensor.ecu_current_power'')
}}wh \n ℹ️ Ideal pour : Four électrique, Chauffage, Plaque de cuisson...'
- service: input_number.set_value
data_template:
value: '{{states(''sensor.ecu_current_power'') }}'
target:
entity_id: input_number.ecu_r
- conditions:
- condition: time
after: '23:55:00'
sequence:
- service: input_number.set_value
data:
value: 0
target:
entity_id: input_number.ecu_r
mode: single
- Optimisation du code de l’automatisation
