Depuis un moment je suis passé sur Home Assistant pour gérer ma domotique. En fonction des prises connectées, toutes ne donne pas la consommation énergétique de la journée mais additionne continuellement les datas.

Alors oui, en fonction de votre prise, il est possible de réinitialiser le soir pour repartir à 0 le lendemain typiquement avec les prises nous – A1Z zigbee

Dans la doc, c’est précisé :

Mais bon, sans savoir comment utiliser l’information on part sur du compliqué :/

Si vous utilisez Zigbee2MQTT voici comment procéder

on clique sur la prise connectée et on arrive (sur à propos)

C’est bien jolie, je sais comment reset manuellement mais si tous les soirs/nuits il faut reset …. c’est compliqué.

La solution que je vais proposer et de mettre en place un petit script PHP permettant de réaliser cette action automatiquement. Comme ça plus de souci.

Solution 2 – Un script

Pour ce faire je vais utiliser ce client => https://github.com/php-mqtt/client

<?php

require_once 'vendor/autoload.php';


use PhpMqtt\Client\MqttClient;
use PhpMqtt\Client\ConnectionSettings;

$server   = '192.168.1.10'; // Serveur MQTT
$port     = 1883; // Port MQTT
$username = '*********';  // Nom d'utilisateur MQTT.
$password = '*********';    // Mot de passe MQTT.
$clientId = 'test-publisher';



$connectionSettings = ( new ConnectionSettings() )
	->setUsername( $username )
	->setPassword( $password );

$mqtt = new MqttClient( $server, $port, $clientId );

$devices = array(
	'prise1',
	'prise2',
);

try {
	$mqtt->connect( $connectionSettings, true );

	// Message de réinitialisation
	$message = json_encode(
		array(
			'reset' => 0,
		)
	);
	foreach ( $devices as $device ) {
		$topic = 'zigbee2mqtt/' . $device . '/set';

		// Publier le message de réinitialisation sur le topic.
		$mqtt->publish( $topic, $message, 0 );
	}

	// Se déconnecter du serveur MQTT.
	$mqtt->disconnect();

	echo "La réinitialisation de la somme de l'énergie consommée a été effectuée avec succès.";
} catch ( Exception $e ) {
	echo 'Erreur : ' . $e->getMessage();
}

Cet exemple montre comment on peut reset a 0 plusieurs prises. On se connecte au serveur MQTT et on va boucler sur nos prises afin de publier notre message de réinitialisation sur le bon topic.

Ensuite il reste à réaliser une tâche automatique via votre serveur (un con)

2 0 * * * php /chemin_vers_votre_fichier/reset.php
# Par exemple ici : à 00h02 minutes tous les jours

Cette solution vous oblige a avoir un serveur sur lequel vous pouvez exécuter des crons. Via Home Assistant ce n’est pas possible.

Mince, comment je peux faire ? Je n’ai pas de serveur, je sais pas de quoi tu me parles, je veux rester côté Home Assistant.

Pas de souci 🙂 il y a toujours des solutions.

Solution 3 – Tout côté Home Assistant

J’utilise une prise nous – A1Z zigbee pour mon Bonzaï vu qu’il a droit a une lampe dédié.

Voici les entités de l’appareil :

Si vous avez cette prise, vous devriez avoir la même chose (sauf le last seen si vous ne l’avez pas activé). Bien penser à contrôler et activer les entités masquées côté Home Assistant (Paramètres / Appareils et services / votre intégration : dans mon cas MQTT)

Jusque là, rien d’extraordinaire, on pose simplement les bases histoire qu’on soit tous au même niveau.

Explications de ce qu’on va faire

La prise nous donne l’information global sur la consommation grâce à cette entité : sensor.bonzai_energy

On aura également besoin : sensor.bonzai_power

le « bonzai » : correspond au nom de la prise que vous avez donné côté Zigbee2MQTT

Les 2 entités sont les seules qu’on va utiliser => top car tout le monde devrait les avoir. (Bien évidemment, si vous utilisez une autre prise connectée, le nom de l’entité sera surement différente, par exemple avec mes prises tapo, le nom serait sensor.bonzai_today_energy et sensor.bonzai_current_power)

Maintenant qu’on connait les sensors qui vont nous être utile, il faut réfléchir à comment les manipuler pour faire ce qu’on souhaite.

Le principe est simple

• Si sensor.bonzai_power dépasse une certaine puissance
• Alors on va garder en mémoire la valeur de sensor.bonzai_energy
• En fin de journée, on pourra facilement reprendre la valeur sensor.bonzai_energy en enlevant la valeur qu’on a gardé en mémoire et cela nous donnera la consommation de la journée

Personnellement, je préfère cette solution pour plusieurs raisons :

• elle permet de tout centraliser sur Home Assistant,
• de ne pas réinitialiser tous les jours la prise,
• d’y rajouter des automatisations (par exemple : Si bonzai_power dépasse une certaine puissance => notification sur mon téléphone, idem lorsque la puissance tombe à 0),
• conserver le fonctionnement classique de la prise et de la consommation totale,
• et ce système est déclinable pour tous les appareils (par exemple : machine à laver et cycle de lavage, j’ai ce système en place afin de savoir quand la machine tourne ce qui me permet de prendre les mesures, me notifier et idem lorsque la machine se termine)

Le début

Avant de débuter :
J’utilise la dernière syntaxe (yaml) en date pour la création des sensors, templates, etc. Donc si vous avez un souci, pensez bien à réadapter soit l’ancienne soit la nouvelle. De plus j’utilise des fichiers/dossiers séparés.
Encore une fois, bien faire attention pour coller avec votre structure.

input_boolean: !include_dir_merge_named input_booleans/
input_number: !include_dir_merge_named input_numbers/
input_select: !include_dir_merge_named input_selects/
input_text: !include_dir_merge_named input_texts/
input_datetime: !include_dir_merge_named input_datetimes/

template: !include_dir_merge_list templates/

Maintenant que tout est clair, on peut commencer.

Il nous faut un binary_sensor

- binary_sensor:
  - state: "{{ states('sensor.bonzai_power') | float(default = 0) > 4 }}"
    name: is_bonzai_running
    unique_id: is_bonzai_running
    icon: mdi:flower
    device_class: running
    delay_off: "0:02:00"

Cela va nous servir simplement pour avoir un état de notre allumage : on/off grâce au device_class: running. Il y a d’autres façon de faire mais autant utiliser les device_class disponible, surtout que côté Home Assistant on aura une intégration parfaite.

La state est simple : si la puissance du bonzai dépasse 4 alors on passe sur on sinon c’est off. sensor.bonzai_power correspond au watt donc dans l’idée c’est si on dépasse 4 watt alors on passe à on.

delay_off c’est tout aussi simple, il faut que notre state soit dans notre cas inférieure à 4 pendant 2 minutes pour considérer qu’on est off. L’intérêt ici c’est si y’a des variations sur la puissance et éviter des faux positifs (il faut bien connaitre l’appareil qu’on utilise pour ajuster au mieux la valeur).

Pourquoi 4 ? C’est totalement arbitraire 🙂 Dans mon cas, je pourrais aussi mettre 5 ou 9n etc. du moment que je suis en dessous du max. Ici c’est surtout de ce dire à partir de combien de watt je considère le sensor comme activé ? On aurait pu très bien mettre 1 et dire si c’est + que 1 alors active toi et si c’est moins donc 0 pendant 2 minutres alors au stop.
Cette valeur est encore plus importante quand l’objectif est de mesurer un appareil dont la puissance fluctue comme une machine à laver. Par exemple la mienne pendant un cycle peut rester à 3 watt pendant 3 minutes avant de remonter et continuer le cycle.

Enuite on va avoir besoin d’un input_number

bonzai_current_power_frozen:
  name: Bonzai Current Power Frozen
  min: 0
  max: 20
  step: 1
  unit_of_measurement: "kwh"
  icon: mdi:lightning-bolt
  mode: box

Cette entité va être utilisé pour garder en mémoire la valeur « kwh » lorsque is_bonzai_running passera de off à on.

On peut configurer un max en prenant une petite marge : dans mon cas la lumière dépasse pas 12W mais je prends la dizaine suppérieur.

On peut déjà mettre en place notre automatisation pour dire : quand is_bonzai_running passe sur on alors initialise bonzai_current_power_frozen avec la valeur en kwh du bonzaï.

alias: Update Bonzai Current Power Frozen
description: ""
trigger:
  - platform: state
    entity_id:
      - binary_sensor.is_bonzai_running
    from: "off"
    to: "on"
    id: auto__bonzai__current_power
condition:
  - condition: trigger
    id:
      - auto__bonzai__current_power
action:
  - service: input_number.set_value
    metadata: {}
    data:
      value: "{{ states('sensor.bonzai_energy')}}"
    target:
      entity_id: input_number.bonzai_current_power_frozen
mode: single

A ce stade, des que is_bonzai_running passera de OFF à ON, l’automatisation s’activera et mettra à jour la valeur du début de journée. Dans mon cas la lumière du bonzai s’allume vers 7h30, donc mon automatisation s’active a ce moment pour récupérer la valeur sensor.bonzai_energy et mettre à jour bonzai_current_power_frozen.

Astuce : en gardant ce principe, on peut ajouter une autre automatisation pour envoyer une notification sur le téléphone lorsque is_bonzai_running passe a ON. Dans mon cas, j’en ai une pour OFF vers ON => le bonzaï est allumé et une autre ON vers OFF => le bonzaï est eteint.

On pourrait par exemple avoir ce type de rendu :

L’énergie début du cycle ne bouge pas pendant la journée : fixe sur la valeur du début. Et changera uniquement chaque jour.

Le milieu

Maintenant qu’on a réussi a conserver la valeur au début du cycle on peut calculer la différence entre fin et début pour obtenir la consommation de la journée.

On peut :

• soit à la fin de l’éclairage récupérer les valeurs : fin – debut et obtenir la consommation
• soit obtenir la consommation en temps réel

Le plus intéressant c’est la consommation en temps réel. On va donc créer un sensor.

- sensor:
    - name: "bonzai_current_energy"
      unique_id: "bonzai_current_energy"
      icon: mdi:lightning-bolt
      unit_of_measurement: "kwh"
      state: >
        {% set debut = states('input_number.bonzai_current_power_frozen') | round(2) %}
        {% if debut > 0 %}
            {% set fin = states('sensor.bonzai_energy') | round(2) %}
            {% set cycle = fin - debut %}
            {{ (cycle) | round(2) }}
        {% else %}
            0
        {% endif %}

On va lui donner un petit nom, une icone et une unité de mesure.

La state va être notre valeur qu’on va obtenir avec : la valeur de début qu’on a sauvegardé (bonzai_current_power_frozen) et le total qu’on a notre prise (bonzai_energy). Il reste plus qu’à soustraire et on obtient la consommation de la journée.

On pense bien a vérifier que la valeur de début soit bien suppérieur à 0 pour faire notre calcul sinon ba c’est 0 la consommation de la journée.

Une fois ceci en place, vous avez le système qui devrait correctement fonctionner.

On peut y rajouter plusieurs améliorations :

• un reset de notre valeur sauvegardé lorsque la lumière s’éteint

alias: Reset Bonzaï Power
description: ""
trigger:
  - platform: time
    at: "23:55:00"
    id: auto__bonzai__reset_power
condition:
  - condition: trigger
    id:
      - auto__bonzai__reset_power
  - condition: state
    entity_id: binary_sensor.is_bonzai_running
    state: "off"
action:
  - service: input_number.set_value
    metadata: {}
    data:
      value: 0
    target:
      entity_id: input_number.bonzai_current_power_frozen
mode: single

Sensiblement la même automatisation qu’avant mais avec 2-3 changements. On va estimer qu’à 23h55 on peut reset la puissance bonzai_current_power_frozen pour 0. On pense bien à rajouter une petite condition pour dire si binary_sensor.is_bonzai_running est bien sur off

L’intérêt ici c’est de remettre à 0 la valeur car on pourrait imaginer qu’on stop l’éclairage 1 jour sur 2 et côté Home Assistant, on aurait la valeur de début même si pas de lumière jusqu’au prochain éclairage de mise à jour de la valeur.

• une notification sur le téléphone à la fin de la journée pour par exemple donner la consommation en kwh et le montant en euro (en fonciton de votre tarif).

Si des articles sur Home Assistant vous intéresse (et par la suite des inter-actions avec l’arduino, les ESP, etc.), n’hésitez pas à le dire :), à laisser un commentaire, noter et partager l’article.

Partage :

Facebook

Twitter