Après trois générations de planning ratées, j’ai fini par laisser Home Assistant décider seul quand faire tourner le moteur de ma piscine. Résultat : un calcul thermique automatique, et une sécurité fuite qui ne laisse plus rien passer.
Une piscine, c’est un moteur qui doit tourner assez longtemps pour filtrer correctement l’eau, sans pour autant tourner pour rien. Pendant des mois, j’ai géré ça avec le planning intégré de l’application du fabricant, complètement déconnecté du reste de la maison. Le jour où j’ai remplacé les trois relais fictifs de mon dashboard par du vrai matériel, j’ai enfin pu faire ce qu’un développeur fait naturellement avec une règle statique qui ne convient plus : la remplacer par une fonction.
Le contexte
Trois contraintes structuraient le projet. D’abord, pas de budget démesuré : la piscine (14m³, traitement au sel) avait déjà ses sondes pH, température et ORP installées par un système tiers, que je n’ai jamais touché. Ensuite, pas d’heures creuses EDF chez moi, donc aucune raison économique de filtrer la nuit : autant concentrer la marche du moteur sur les heures les plus chaudes de la journée, quand l’eau en a le plus besoin. Enfin, l’existant côté dashboard était du pur théâtre : trois interrupteurs input_boolean fictifs, posés en attendant d’avoir du vrai matériel derrière.
Le matériel choisi a été un Shelly Pro 3, un relais trois canaux WiFi installé dans le local technique. Un canal pour le moteur de filtration, un pour l’éclairage, un pour l’électrolyseur au sel. Un capteur de fuite Zigbee (device class moisture) posé au sol du local complète le dispositif : c’était initialement un capteur générique, que j’ai renommé et rattaché à sa propre zone une fois le projet piscine officialisé.
L’implémentation
Calculer la durée de marche plutôt que la fixer en dur
Le cœur du système, c’est un capteur template qui calcule chaque jour combien d’heures le moteur doit tourner, en fonction de la température de l’eau. Plutôt que de se baser sur la température instantanée (sensible aux variations ponctuelles, un nuage qui passe ou un prélèvement d’échantillon), je m’appuie sur un maximum glissant sur 24h, avec repli sur la valeur instantanée si l’historique n’est pas encore disponible :
template:
- sensor:
- name: "Objectif de marche piscine"
unique_id: piscine_objectif_marche_moteur
default_entity_id: sensor.piscine_objectif_marche_moteur
unit_of_measurement: "h"
state: >
{% set t = states('sensor.piscine_temperature_max_24h')
| float(states('sensor.exterieur_piscine_temperature') | float(20)) %}
{% if t >= 30 %}
16
{% elif t > 28 %}
{{ [ (t / 2 + 2), 16 ] | min }}
{% else %}
{{ [ t / 2, 8 ] | max }}
{% endif %}
Trois paliers : au-delà d’un certain seuil de température, la durée plafonne à 16h. Entre deux seuils intermédiaires, elle évolue proportionnellement à la température, toujours plafonnée. En dessous, un plancher minimal garantit que le moteur tourne quand même un minimum d’heures chaque jour, parce qu’un électrolyseur au sel a besoin d’un débit d’eau régulier pour maintenir son taux de traitement, indépendamment de la météo.
Un bloc de marche unique centré sur le pic thermique
Autre changement de philosophie : au lieu de créneaux fixes hérités de l’ancien planning, le moteur tourne désormais en un seul bloc, centré sur le milieu d’après-midi (l’heure la plus chaude typique). L’heure de démarrage se déduit simplement de l’objectif calculé : plus l’objectif est long, plus tôt le moteur démarre. L’automation d’allumage se contente de vérifier les conditions et de démarrer, sans jamais couper elle-même :
automation:
- alias: "Piscine - Allumage planning"
trigger:
- platform: time_pattern
minutes: "/5"
condition:
- condition: numeric_state
entity_id: sensor.exterieur_piscine_temperature
above: 10
- condition: state
entity_id: binary_sensor.piscine_fuite_eau
state: "off"
- condition: template
value_template: >
{{ now() >= (states('sensor.piscine_heure_demarrage_moteur') | as_datetime) }}
- condition: numeric_state
entity_id: sensor.duree_fonctionnement_piscine_moteur_jour
below: states('sensor.piscine_objectif_marche_moteur') | float
action:
- service: switch.turn_on
target:
entity_id: switch.piscine_moteur
La coupure au quota, elle, vit dans une automation séparée qui compare en continu la durée déjà effectuée à l’objectif du jour. Séparer clairement « qui démarre » de « qui coupe » a simplifié le code : plus aucune notion de fenêtre fermée à faire respecter activement, juste une condition de démarrage d’un côté et une condition d’arrêt de l’autre.
Utilise un capteur statistics avec une fenêtre glissante pour lisser une mesure bruitée (température, luminosité), et garde en parallèle un compteur « depuis minuit » séparé pour tout ce qui doit réellement se remettre à zéro chaque jour. Les deux ne se comportent pas pareil et confondre les deux casse la logique de reset.
Les pièges rencontrés
Le premier vrai bug est resté invisible plusieurs jours : l’heure de démarrage affichée dans mes notifications sortait décalée de deux heures. La cause était bête, un template qui convertissait un timestamp en chaîne de caractères sans repasser explicitement par le fuseau horaire local avant le formatage, donc l’affichage restait en UTC. Les automations de démarrage et de coupure, elles, comparaient déjà des objets datetime correctement localisés en interne : seul l’affichage humain était faux. Une bonne piste de debug en général, séparer ce qui pilote la logique de ce qui sert juste à l’affichage.
Deuxième piège, plus subtil : une fausse alerte « fuite terminée » qui partait régulièrement alors qu’il n’y avait jamais eu de fuite réelle. Le capteur Zigbee fait des micro-coupures de connexion toutes les dix à quinze minutes, quelques secondes chaque fois, et revient systématiquement à l’état « sec » après une reconnexion. Un simple filtre de stabilité (attendre trois minutes avant de valider un changement d’état) ne suffisait pas : une reconnexion reste stable largement plus de trois minutes. Le vrai correctif a été d’exiger une transition venant explicitement d’un état « fuite détectée » avant d’envoyer la notification de fin d’alerte, pas juste un retour à l’état « sec » depuis n’importe quel état précédent.
Le troisième piège est une leçon plus générale : j’ai ajouté puis retiré le jour même une sécurité logicielle censée couper l’électrolyseur si le moteur ne tournait pas. Une fois vérifié que le câblage électrique du local technique n’alimente physiquement l’électrolyseur que lorsque le moteur tourne, cette automation dupliquait une sécurité déjà assurée matériellement, tout en perturbant l’usage normal (l’état logique du relais reste « actif » en continu côté Shelly, ce qui est parfaitement normal puisque c’est le câblage qui fait le vrai filtrage). La bonne réaction face à un capteur ou un relais dont l’état logique semble « anormal » : vérifier d’abord si une sécurité physique existe déjà, avant d’en coder une par-dessus.
Sur la logique de seuils elle-même, un principe vaut la peine d’être rappelé : dès qu’une automation coupe puis peut relancer un équipement autour d’une valeur mesurée, mieux vaut prévoir un écart entre le seuil de coupure et le seuil de relance (une hystérésis) plutôt qu’un seuil unique. Sans ça, une mesure qui oscille légèrement autour de la limite déclenche des cycles marche/arrêt à répétition, usants pour le matériel et illisibles dans l’historique.
Depuis la 2026.7 : ce qui ne demande plus de YAML
Home Assistant 2026.7 (sortie début juillet 2026) a changé la donne sur un point précis : l’éditeur d’automatisation graphique propose désormais par défaut des triggers et des conditions orientés intention, plutôt que les primitives techniques habituelles. Concrètement, pour une règle simple comme « si la température de l’eau dépasse un seuil, envoie une notification », ou une logique basique de marche du moteur au-delà d’une certaine température, il suffit aujourd’hui de choisir directement un trigger de type seuil dans l’éditeur, sans se préoccuper de l’entity_id exact ni de son état brut. Ces triggers gèrent aussi tout seuls les états unknown ou unavailable du capteur, un piège qui demandait auparavant d’ajouter des conditions supplémentaires en YAML.
Pour autant, tout le système décrit plus haut ne bascule pas comme par magie dans l’éditeur graphique. La logique d’hystérésis autour de l’électrolyseur et de l’ORP, avec un écart volontaire entre seuil de coupure et seuil de relance pour éviter les cycles courts, ainsi que la coordination entre plusieurs conditions (fuite, quota horaire, heure de démarrage calculée), reste plus lisible et plus robuste écrite en YAML. Le bon réflexe reste donc de commencer par l’éditeur graphique pour les cas simples de seuil ou de notification, et de ne passer en YAML que lorsque la logique le justifie vraiment, comme ici pour l’hystérésis. Le YAML n’a rien perdu de sa pertinence, il n’est simplement plus la seule porte d’entrée.
Bilan et pour aller plus loin
Le système tourne maintenant sans intervention manuelle depuis plusieurs semaines, avec un rapport Telegram qui synthétise l’état de la piscine plusieurs fois par jour. Deux angles morts restent identifiés et non traités. D’abord, si le capteur de fuite tombe en panne ou perd sa connexion Zigbee (pile à plat, coupure réseau), aucune automation ne se déclenche : tout est filtré sur un état « on » strict, sans garde-fou sur perte de capteur. Ensuite, la sécurité hivernage empêche bien un démarrage forcé sous un certain seuil de température, mais rien ne coupe activement le moteur si la température chute pendant qu’il tourne déjà. Un scénario rare vu la lenteur d’évolution de la température de l’eau, mais qui mérite un filet de sécurité si je veux dormir tranquille l’hiver prochain.
FAQ
Pourquoi ne pas avoir gardé le planning intégré de l’application du fabricant ?
Parce qu’il ne pouvait pas croiser la sécurité fuite ni s’adapter à la température de l’eau : un planning figé, sans aucun lien avec le reste de la maison.
Comment le système sait-il combien de temps faire tourner le moteur ?
Un capteur template calcule un objectif quotidien à partir de la température de l’eau, avec un plancher minimal et un plafond pour éviter les extrêmes.
Que se passe-t-il si une fuite est détectée ?
Le moteur est coupé immédiatement, une alerte se répète tant que la fuite persiste, et un interlock empêche tout redémarrage tant que le capteur reste actif.
L’électrolyseur est-il piloté par Home Assistant ?
Non, il est sécurisé physiquement par le câblage électrique du local technique : il ne reçoit du courant que lorsque le moteur tourne réellement.
Que faire si le capteur de fuite tombe en panne ?
Actuellement rien d’automatique : c’est un angle mort connu, sans garde-fou sur perte de capteur pour l’instant.
Stack utilisée
- Shelly Pro 3 (relais WiFi trois canaux)
- Home Assistant (automations, template sensors, history_stats, statistics)
- Capteur de fuite Zigbee (intégration zigbee2mqtt)
- Bot Telegram pour les notifications et rapports
- Sondes pH / température / ORP piscine (système tiers existant, non touché)









