Intro

Dans un article précédent, je détaillais la méthode utilisée permettant de calculer le temps de filtration de la piscine, basée sur le module HACS « Pool Pump Manager », qui fonctionne très bien mais bien trop figé à mon gout. En effet nous ne pouvons pas, par exemple, modifier la répartition du temps de filtration autour de l’heure pivot figée sur 1/3 avant et 2/3 après, paramétrer l’heure pivot, changer de méthode de calcul du temps basée uniquement sur l’abaque Abacus, choisir un mode hiver.

Je vous invite quand même à le parcourir, tout n’est pas à jeter.

Pour toutes ces raisons, et ayant récemment découvert l’addon « AppDaemon », voir mon article sur ce sujet , je me suis lancé dans un développement personnel de la gestion du temps de filtration en Python.

Je n’ai pas la prétention de me déclarer « expert » en programmation et en python. C’est en fouillant sur le net que j’ai pu arriver à mes fins et aboutir à un fonctionnement satisfaisant. Il est évident que ce programme sans prétention est largement perfectible. Tous les axes d’amélioration ou d’optimisation du code seront les bienvenus en commentaire.

Mises à Jour:

Du 24/02/2022:

• Ajout d’une entité Arrêt_Forcé: Si = On cette entité force la pompe à l’arrêt quelque soit le mode. Dans mon cas je m’en sert pour délester la consommation.

Du 17/02/2022

• Ajout niveau de journalisation
• Ajout H_Pivot dans l’affichage tranche horaire « été »
• Ajout tempo (« tempo_eau ») de prise en compte de la température après demarrage de la pompe: Dans le cas d’une mesure de température en ligne, cette temporisation permet de brasser l’eau du bassin avant de prendre en compte sa température. Avant la fin de la tempo, la mesure prise en compte dans le calcul est celle de la veille (mémorisée dans « mem_temp ») . Ce temps peut être mis à 0 si la prise de mesure est effectuée directement dans l’eau du bassin, quoique brasser l’eau quelques minutes avant de commencer le prise en compte de la T° permet de mélange les eaux de surface et de fond.

Pré requis

Mes fichiers « .yaml » sont regroupés dans un dossier « config/packages ». J’utilise la directive « !include_dir_named packages » dans mon « configuration.yaml » très pratique pour organiser son HA.

Ci après un extrait du « configuration. yaml » dont la version à jour est disponible ici.

homeassistant:
  name: Crochon
  latitude: !secret latitude
  longitude: !secret longitude
  unit_system: metric
  packages: !include_dir_named packages
  external_url: !secret external-url
  internal_url: !secret internal-url

Cahier des charges

Mon cahier des charges est le suivant:

• Traitement des 4 modes de fonctionnement suivant:
  • Été: Temps de calcul fonction de la température de l’eau
  • Hiver: temps de filtration basé sur une heure de départ et une durée
  • Ma F: Force la pompe en marche
  • At F: Force la pompe à l’arrêt
• En mode Été:
  • choix du modèle de calcul du temps de filtration:
    • Mode abaque Abacus
    • Mode classique: Température divisée par 2
  • Répartition du temps de filtration autour de l’heure Pivot: 50% avant et 50% après.
  • Possibilité de choisir son heure pivot entre 11:00 et 14:00 (butées modifiables dans l’application)
  • Possibilité de minorer ou majorer par un coefficient le temps de filtration (entre 60 et 140%: c’est un choix personnel basé sur mon retour d’expérience)
  • Limiter l’heure de fin à 23:59:59.
  • Temporisation de prise en compte de la température après demarrage de la pompe
• Forçage à l’arrêt de la pompe quelque soit le mode de fonctionnement
• Affichage de la plage de filtration dans HA
• Enfin, avoir la main mise totale sur le programme, maîtriser les modifications et l’améliorer à ma convenance.

L’heure pivot représente selon moi le zénith du soleil, elle sert de de référence horaire dans ma programmation.

Abaque du mode Abacus

Le temps filtration est calculé suivant la courbe bleue avec un coefficient de 100%, la rouge avec un coefficient de 60% et la verte avec un coefficient de 140%. Cette formule, utilisée par Pool Pump Manager et le pluging Jeedom a été récupérée dans https://github.com/scadinot/pool.

Déclaration des entités

Les entités HA utilisées dans ce fichier doivent avoir été au préalable déclarées dans HA. Dans mon cas, elle sont regroupées dans un fichier « piscine.yaml » dont le code est disponible au téléchargement ici.

####################################################
#                                                  #
#                   PISCINE                        #
#                                                  #
####################################################

utility_meter:
# usage jour  
  energy_pisc_usage_daily:
    source: sensor.pzem_pisc_energy
    cycle: daily
    tariffs:
      - hp
      - hc
# usage semaine
  energy_pisc_usage_weekly:
    source: sensor.pzem_pisc_energy
    cycle: weekly
    tariffs:
      - hp
      - hc
# usage mois
  energy_pisc_usage_monthly:
    source: sensor.pzem_pisc_energy
    cycle: monthly
    tariffs:
      - hp
      - hc
#usage an
  energy_pisc_usage_yearly:
    source: sensor.pzem_pisc_energy
    cycle: yearly
    tariffs:
      - hp
      - hc
input_number:
  # utilisé pour simuler la température de l'eau pendant les tests
  temp_piscine:
    name: Temp Eau Simul
    min: -2
    max: 35
    unit_of_measurement: °C
    icon: mdi:thermometer

# temperature de l'eau avant arret ppe
  mem_temp_piscine:
    name: Temp Eau avant arret
    min: -5
    max: 50
    unit_of_measurement: °C
    step: 0.1
    icon: mdi:thermometer
    mode: box

# temperature de l'eau avant arret ppe
  test_mem_temp_piscine:
    name: Temp Eau avant arret Test
    min: -5
    max: 50
    unit_of_measurement: °C
    step: 0.1
    icon: mdi:thermometer
    mode: box

# tempo avant prise en compte de la température de l'eau suite à demarrage marche pompe
  tempo_circulation_eau:
    name: Tempo Circulation Eau
    min: 0
    max: 3600
    unit_of_measurement: s
    step: 0.1
    icon: mdi:timer
    mode: box

# temps utilisation cartouche chlore
  temps_cartouche_chlore:
    name: Temps cartouche Chlore
    min: 0
    max: 3600
    unit_of_measurement: h
    step: 0.1
    icon: mdi:clock
    mode: box

# Seuil 1 inferieur temperature Hors gel
  hors_gel_inf_seuil1:
    name: Temp Inf Hors-Gel Seuil 1
    min: -5
    max: 0
    unit_of_measurement: °C
    icon: mdi:thermometer
# Seuil 2 inferieur temperature Hors gel
  hors_gel_inf_seuil2:
    name: Temp Inf Hors-Gel Seuil 2
    min: -10
    max: 0
    unit_of_measurement: °C
    icon: mdi:thermometer

# Durée de filtration max en hiver
  duree_filtration_max_mode_hiver:
    name: Durée filtration en Hiver
    min: 0
    max: 15
    unit_of_measurement: h
    step: 0.1
    icon: mdi:clock
    mode: box

# Durée de filtration max en hiver
  filtration_coeff_abaque:
    name: Coeff filtration Piscine Abaque
    min: 60
    max: 140
    unit_of_measurement: "%"
    step: 1.0
    icon: mdi:percent
    mode: box

input_datetime:
  heure_pivot_pisc:
    name: Heure Pivot
    has_date: false
    has_time: true

  heure_ouv_volet_pisc:
    name: Heure Ouv Volet Auto
    has_date: false
    has_time: true

  heure_ferm_volet_pisc:
    name: Heure Ferm Volet Auto
    has_date: false
    has_time: true

  heure_ma_pump_pisc_hiv:
    name: Heure Ma Pompe Pisc Hiv
    has_date: false
    has_time: true

input_boolean:
  # Force la Ppe de filtration à l’arrêt
  piscine_arret_force:
    name: Piscine Arret Forcé
    icon: mdi:head-snowflake

  # EV appoint Piscine en mode automatique
  ev_eau_piscine:
    name: Ev Piscine
    icon: mdi:water
  
  # Volet Piscine en mode automatique
  volet_piscine_auto:
    name: Volet Piscine (Auto=1)
    icon: mdi:garage

  #cde eclairage piscine
  eclairage_piscine:
    name: Eclairage piscine
    icon: mdi:car-light-high

  # Calcul du hors gel- Mémoire de mise en hors gel
  hors_gel_valid:
    name: Valid Hors Gel Piscine (si=1)
    icon: mdi:snowflake-alert

  # Calcul du temps de filtration selon Abaque Abacus sinon mode classique
  calcul_mode_abaque:
    name: Cacul mode Abaque (si=1)
    icon: mdi:chart-bar

# selection du mode de fonctionnement de la filtration
input_select:

  mode_fonctionnement_piscine:
    name: Mode Fonct Piscine
    options:
      - "Ete"
      - "Hiver"
      - "Ma F"
      - "At F"
    icon: mdi:pool
# sert aux tests AppDaemon
  mode_fonctionnement_piscine_test:
    name: Mode Fonct Piscine
    options:
      - "Ete"
      - "Hiver"
      - "Ma F"
      - "At F"
    icon: mdi:pool
############################  Input text    
input_text:
  # Affiche la periode de Filtration
  piscine_periode_filtration:   
    name: Periode Filtration
  test_piscine_periode_filtration:   
    name: Test Periode Filtration
  
############################  Sensor
sensor:
  # Affichage du temps de fonctionnement de la pompe ce jour
  - platform: history_stats
    name: Ma Ppe Piscine Jour
    entity_id: binary_sensor.ppe_piscine_en_marche
    state: "on"
    type: time
    start: "{{ now().replace(hour=0).replace(minute=0).replace(second=0) }}"
    end: "{{ now() }}"

  # Affichage du temps de fonctionnement de l'électrovanne appoint d'eau ce jour
  - platform: history_stats
    name: Ev Eau tps ouverture jour
    entity_id: switch.cde_ev_eau
    state: "on"
    type: time
    start: "{{ now().replace(hour=0).replace(minute=0).replace(second=0) }}"
    end: "{{ now() }}"
    
  # Affichage du temps de fonctionnement de l'électrovanne appoint d'eau sur 7 jours
  - platform: history_stats
    name: Ev eau sur 7j
    entity_id: switch.cde_ev_eau
    state: 'on'
    type: time
    end: "{{ now().replace(hour=0, minute=0, second=0) }}"
    duration:
      days: 7
    
template:
  - sensor:
    - name: "Heure pivot Soleil"
      unique_id: "heure_pivot_soleil"
      state: >
        {{ as_timestamp(state_attr("sun.sun", "next_noon")) | timestamp_custom('%H %M')}}
      icon: mdi:weather-sunset

    - name: "Energie Piscine Jour"
      unique_id: "energy_pisc_daily" 
      state: >-
        {% set p = states('sensor.energy_pisc_usage_daily_hp') | float(default=0) | round(2) %}
        {% set o = states('sensor.energy_pisc_usage_daily_hc') | float(default=0) | round(2) %}
        {{ (o + p) | round(2) }}
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total"  

    - name: "energy_pisc_weekly"
      state: >-
        {% set p = states('sensor.energy_pisc_usage_weekly_hp') | float(default=0) | round(2) %}
        {% set o = states('sensor.energy_pisc_usage_weekly_hc') | float(default=0) | round(2) %}
        {{ (o + p) | round(2) }}
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total"  

    - name: "energy_pisc_monthly"
      state: >-
        {% set p = states('sensor.energy_pisc_usage_monthly_hp') | float(default=0) | round(2) %}
        {% set o = states('sensor.energy_pisc_usage_monthly_hc') | float(default=0) | round(2) %}
        {{ (o + p) | round(2) }}
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total"  

    - name: "energy_pisc_yearly"
      state: >-
        {% set p = states('sensor.energy_pisc_usage_yearly_hp') | float(default=0) | round(2) %}
        {% set o = states('sensor.energy_pisc_usage_yearly_hc') | float(default=0) | round(2) %}
        {{ (o + p) | round(2) }}
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total"  

  # Recopie pression filtre lu dans esphome dans un template
    - name: "pression_piscine_p"
      state: '{{ states("sensor.pression_filtre") |float(default=0) | round(2) }}'
      unit_of_measurement: "Bars"

  - binary_sensor:
    # Si la puissance electrique est superieure à 500w, on considere que la pompe est en fonctionnement
    # ou tester le switch de la ppe de filtration si pas de mesure de puissance
    # {{ is_state('switch.ppe_filtration', 'on') }}
    - name: "ppe_piscine_en_marche"
      state: >-
        {{states.sensor.pzem_pisc_puissance.state | float(default=0) > 500}}

  # Calcul en fonction de la position du soleil
  # Sun Azimtuh est calculé dans Meteo
    - name: "soleil_volet_piscine"
      state: >-
        {% set a=states('sensor.sun_azimuth_2')|float(default=0) %}
        {{ (a>97) and (a<290) }}

# Commande du volet roulant via un Cover

cover:
  - platform: template
    covers:
      volet_piscine:
        device_class: garage
        friendly_name: "Piscine"
        value_template: >-
          {% if is_state('binary_sensor.volet_piscine_ferme', 'on') %}
            closed
          else:
            open
          {% endif %}        
        open_cover:
          - service: script.volet_piscine_ouverture
        close_cover:
          - service: script.volet_piscine_fermeture   
        icon_template: >-
          {% if is_state('binary_sensor.volet_piscine_ferme', 'on') %}
            mdi:garage
          {% else %} 
            mdi:garage-open
          {% endif %}

Addon Appdaemon

Cet Addon, pour ceux qui ne connaissent pas, permet d’écrire des programmes en Python très élaborés, je décrit son installation dans cet article.

Vous trouverez ci après les fichiers « .yaml » et « .py » à installer dans « votre AppDaemon. »

Code de « filtration_piscine.yaml »

La dernier version du fichier « filtration_piscine.yaml » est téléchargeable ici.

# Version du 24/02/2022
Piscine:
  class: FiltrationPiscine
  module: filtration_piscine
# Capteurs
  temperature_eau: sensor.temp_piscine
# Selection du mode fonctionnement de la filtration
  mode_de_fonctionnement: input_select.mode_fonctionnement_piscine
# Heure pivot autour de laquelle le temps de filtration est réparti (50/50)
  h_pivot: input_datetime.heure_pivot_pisc
# Heure de début de filtration en hiver
  h_debut_hiver: input_datetime.heure_ma_pump_pisc_hiv
# Durée de la filtration en hiver
  duree_hiver: input_number.duree_filtration_max_mode_hiver
# Coefficient du temps de filtration entre 60 et 140%
  coef: input_number.filtration_coeff_abaque
# Validation de mode de calcul avec Abaque sinon c'est la méthode classique (T°/2)
  mode_calcul: input_boolean.calcul_mode_abaque
# Temps circulation de l'eau avant prise en compte mesure température
# dans le cas où la mesure de température de l'eau se trouve sur le circuit de pompage
  tempo_eau: input_number.tempo_circulation_eau
# Memoire de la temperature de l'eau avant arret
  mem_temp: input_number.mem_temp_piscine
# Arret forcé filtration- Bloque la filtration si = 1
  #arret_force: input_boolean.piscine_arret_force # à utiliser par défaut
  arret_force: input_boolean.mem_delestage


# Actionneurs
  # Switch de commande de la pompe
  cde_pompe: switch.cde_pompe_filtration
  # Affichage dans HA des horaires filtration
  periode_filtration: input_text.piscine_periode_filtration

Code de « filtration_piscine.py »

La dernière version du fichier « filtration_piscine.py » est téléchargeable ici.

# Version du 24/02/2022
import hassapi as hass
import datetime
from datetime import timedelta
import time

# Variables globales
# Saisir ici les memes modes que dans HA 
TAB_MODE = ["Ete", "Hiver", "At F", "Ma F"]
# Niveau de JOURNALISATION (log): 0=rien ou 1 =info ou 2=debug 
JOURNAL=2 
# RAZ du flag fin_tempo
FIN_TEMPO = 0

# Fonction de calcul du temps de filtration selon Abaque Abacus 
def duree_abaque(Temperature_eau):
    #Advanced calculation method using an abacus.
    #D = a*T^3 + b*T^2 + c*T +d
    #T est forçèe a 10°C minimum
    #Formule découverte dans: https://github.com/scadinot/pool
    #Filtration en heures
    temperature_min: float = max(float(Temperature_eau), 10)
    duree = (
            0.00335 * temperature_min ** 3
            - 0.14953 * temperature_min ** 2
            + 2.43489 * temperature_min
            - 10.72859
    )
    return duree

# Fonction de calcul du temps de filtration "Classique" 
def duree_classique(Temperature_eau):
    #Methode classique temperature / 2
    temperature_min: float = max(float(Temperature_eau), 10)
    duree = temperature_min / 2
    duree_m = min(float(duree), 23)
    return duree

# Fonction de Convertion Int en heure "HH:MM:SS"
def en_heure(t):
    h = int(t)
    # On retire les heures pour ne garder que les minutes.
    t = (t - h) * 60 # 0.24 * 60 = temps_restant en minutes.
    m = int(t)
    # On retire les minutes pour ne garder que les secondes.
    t = (t - m) * 60
    s = int(t)
    return "{:02d}:{:02d}:{:02d}".format(h, m, s)

########## Programme principal ###################
class FiltrationPiscine(hass.Hass): 
    def initialize(self):
        global JOURNAL, DUREE_TEMPO, FIN_TEMPO
        message_notification= "Initialisation AppDaemon Filtration Piscine."
        self.notification(message_notification,0)
        self.log(message_notification, log="error_log")
        self.notification("Journal Notif niveau:"+str(JOURNAL),0)
        self.listen_state(self.change_temp,self.args["temperature_eau"])
        self.listen_state(self.change_mode,self.args["mode_de_fonctionnement"])
        self.listen_state(self.change_coef,self.args["coef"])
        self.listen_state(self.ecretage_h_pivot,self.args["h_pivot"])
        self.listen_state(self.change_mode_calcul,self.args["mode_calcul"])
        self.listen_state(self.change_etat_pompe,self.args["cde_pompe"])
        self.listen_state(self.change_arret_force,self.args["arret_force"])
        self.run_every(self.touteslesxminutes, "now", 5 * 60)
        
        # initialisation de la temporisation avant recopie temperature
        DUREE_TEMPO=float(self.get_state(self.args["tempo_eau"]))
        self.notification("Duree tempo:"+str(DUREE_TEMPO),2)
        nom_entité=self.args["cde_pompe"]
        self.tempo=self.run_in(self.fin_temporisation_mesure_temp, DUREE_TEMPO,entité=nom_entité)
        # Arret de la pompe sur initalisation
        self.turn_off(self.args["cde_pompe"])

# Appelé sur changement de temperature
    def change_temp(self, entity, attribute, old, new, kwargs):
        global JOURNAL
        if new!= "unavailable":
            self.notification('Appel traitement changement Temp.',2)
            self.traitement(kwargs)
# Appelé sur changement de mode de fonctionnement
    def change_mode(self, entity, attribute, old, new, kwargs):
        global JOURNAL, FIN_TEMPO
        FIN_TEMPO = 0
        self.notification('Appel traitement changement Mode.',2)
        self.traitement(kwargs)
# Appelé sur changement de coefficient
    def change_coef(self, entity, attribute, old, new, kwargs):
        global JOURNAL
        self.notification('Appel traitement changement Coef.',2)
        self.traitement(kwargs)
# Appelé sur changement de mode de calcul
    def change_mode_calcul(self, entity, attribute, old, new, kwargs):
        global JOURNAL
        self.notification('Appel traitement changement mode de calcul.',2)
        self.traitement(kwargs)
# Appelé sur changement arret forcé
    def change_arret_force(self, entity, attribute, old, new, kwargs):
        global JOURNAL
        self.notification('Appel traitement sur arret force.',2)
        self.traitement(kwargs)
# Appelé sur changement d'état de la pompe de filtrage
    def change_etat_pompe(self, entity, attribute, old, new, kwargs):
        global JOURNAL, FIN_TEMPO ,DUREE_TEMPO
        nom_entité=self.args["cde_pompe"]
        FIN_TEMPO = 0
        if new=="on":
            self.tempo=self.run_in(self.fin_temporisation_mesure_temp, DUREE_TEMPO,entité=nom_entité)
        else:
            cle_tempo = self.tempo
            if cle_tempo != None:
                cle_tempo = self.tempo
                self.tempo = self.cancel_timer(cle_tempo)

        self.notification('Appel traitement changement etat pompe.',2)
        self.traitement(kwargs)
# Appelé sur fin temporisation suit à demarrage de la pompe
    def fin_temporisation_mesure_temp(self,kwargs):
        global JOURNAL, FIN_TEMPO 
        FIN_TEMPO = 1
        self.notification('Fin temporisation circulation eau.',2)
        self.traitement(kwargs)

# Ecretage Heure pivot entre h_pivot_min et h_pivot_max
    def ecretage_h_pivot(self, entity, attribute, old, new, kwargs):
        h_pivot= new
        h_pivot_max="14:00:00"
        h_pivot_min="11:00:00"
        if h_pivot>h_pivot_max:
            self.set_state(self.args["h_pivot"], state = h_pivot_max)
        if h_pivot<h_pivot_min:
            self.set_state(self.args["h_pivot"], state = h_pivot_min)
        self.traitement(kwargs)

# Appelé toutes les x minutes
    def touteslesxminutes(self, kwargs):
        global JOURNAL
        self.notification('Appel traitement toutes les x mn.',2)
        self.traitement(kwargs)

    def traitement(self, kwargs):
        global JOURNAL, FIN_TEMPO
        h_locale=time.strftime('%H:%M:%S', time.localtime())
        Mesure_temperature_eau = float(self.get_state(self.args["temperature_eau"]))
        Mem_temperature_eau = float(self.get_state(self.args["mem_temp"]))
        mode_de_fonctionnement = self.get_state(self.args["mode_de_fonctionnement"])
        arret_force = self.get_state(self.args["arret_force"])
        pompe = self.args["cde_pompe"]
        pivot= self.get_state(self.args["h_pivot"])
        coef=float(self.get_state(self.args["coef"]))/100
        mode_calcul= self.get_state(self.args["mode_calcul"])
        periode_filtration=self.args["periode_filtration"]

        # Flag FIN_TEMPO
        self.notification("Flag fin tempo= "+str(FIN_TEMPO),2)

        #  Mode Ete
        if mode_de_fonctionnement == TAB_MODE[0]:
            # Temporisation avant prise en compte de la mesure de la temperature
            # sinon on travaille avec la memoire de la temperature avant arret de la pompe
            # mémorise la température eau de la veille.
            if FIN_TEMPO == 1:
                Temperature_eau=Mesure_temperature_eau
                self.set_value(self.args["mem_temp"], Mesure_temperature_eau)
            else:
                Temperature_eau=Mem_temperature_eau

            if mode_calcul == "on": # Calcul selon Abaque
                temps_filtration = (duree_abaque(Temperature_eau)) * coef
                nb_h_avant = en_heure(float(temps_filtration / 2))
                nb_h_apres = en_heure(float(temps_filtration / 2))
                # nb_h_avant = en_heure(float(temps_filtration / 3)) Répartition 1/3-2/3
                # nb_h_apres = en_heure(float(temps_filtration / 3*2))
                nb_h_total = en_heure(float(temps_filtration))
                self.notification("Duree Filtration Mode Abaque: "+ str(temps_filtration)[:6]+" h",2)
            
            else: # Calcul selon méthode classique
                temps_filtration = (duree_classique(Temperature_eau))*coef
                nb_h_avant = en_heure(float(temps_filtration / 2))
                nb_h_apres = en_heure(float(temps_filtration / 2))
                nb_h_total = en_heure(float(temps_filtration))
                self.notification("Duree Filtration Mode Classique: "+ str(temps_filtration)[:6]+" h",2)

            # Calcul des heures de début et fin filtration en fontion
            # du temps de filtration avant et apres l'heure pivot
            # Adapte l'heure de début de filtration à l'heure actuelle
            # Limitation de la fin de filtration à 23:59:59
            h_maintenant = timedelta(hours=int(h_locale[:2]), minutes=int(h_locale[3:5]), seconds=int(h_locale[6:8]))
            h_pivot = timedelta(hours=int(pivot[:2]), minutes=int(pivot[3:5]))
            h_avant_t = timedelta(hours=int(nb_h_avant[:2]), minutes=int(nb_h_avant[3:5]), seconds=int(nb_h_avant[6:8]))
            h_apres_t = timedelta(hours=int(nb_h_apres[:2]), minutes=int(nb_h_apres[3:5]), seconds=int(nb_h_apres[6:8]))
            h_total_t = timedelta(hours=int(nb_h_total[:2]), minutes=int(nb_h_total[3:5]), seconds=int(nb_h_total[6:8]))
            h_max_t = timedelta(hours=23, minutes=59, seconds=59)

            h_debut = h_pivot - h_avant_t
            h_fin= h_pivot + h_apres_t

#            if h_debut<h_maintenant:
#                h_debut=h_maintenant
#                h_fin=h_maintenant+h_total_t
#                h_fin= min(h_fin,h_max_t)
            h_fin= min(h_fin,h_max_t)
            message_notification= "Nb h_avant_t: "+str(h_avant_t)+"/Nb h_apres_t: "+str(h_apres_t)+"/Nb h_total_t: "+str(h_total_t)
            self.notification(message_notification,1)
            message_notification="h_debut: "+str(h_debut)+"/h_pivot: "+str(h_pivot)+"/h_fin: "+str(h_fin) 
            self.notification(message_notification,1)
            # Affichage plage horaire
            affichage_texte =str(h_debut)[:5]+"/"+str(h_pivot)[:5]+"/"+str(h_fin)[:5]
            self.set_textvalue(periode_filtration,affichage_texte)

            # Marche pompe si dans plage horaire sinon Arret
            if self.now_is_between(str(h_debut),str(h_fin)):
                ma_ppe=1
            else:
                ma_ppe=0

# Notifications de debug
            message_notification="Mode de fonctionnement: "+mode_de_fonctionnement
            self.notification(message_notification,2)
            message_notification=" Temp Eau= "+str(Temperature_eau)
            self.notification(message_notification,2)
            message_notification="h_pivot= "+str(pivot)
            self.notification(message_notification,2)
            message_notification="coef= "+str(coef)
            self.notification(message_notification,2)

        #  Mode hiver Heure de Début + Une durée en h 
        elif mode_de_fonctionnement == TAB_MODE[1]:
            h_debut_h= self.get_state(self.args["h_debut_hiver"])
            duree= self.get_state(self.args["duree_hiver"])
            duree_h=en_heure(float(duree))
            h_debut_t = timedelta(hours=int(h_debut_h[:2]), minutes=int(h_debut_h[3:5]), seconds=int(h_debut_h[6:8]))
            duree_t = timedelta(hours=int(duree_h[:2]), minutes=int(duree_h[3:5]))
            h_fin_f = h_debut_t + duree_t
            # Affichage plage horaire
            affichage_texte =str(h_debut_h)[:5]+"/"+str(h_fin_f)[:5]
            self.set_textvalue(periode_filtration,affichage_texte)

            message_notification="h_debut_h"+str(h_debut_h)+"-Duree H:"+str(duree_h)+"-H fin:"+str(h_fin_f)
            self.notification(message_notification,2)
            # Marche pompe si dans plage horaire sinon Arret
            if self.now_is_between(str(h_debut_h),str(h_fin_f)):
                ma_ppe=1
            else:
                ma_ppe=0

        # Mode Arret Forcé
        elif mode_de_fonctionnement == TAB_MODE[2]:
            ma_ppe=0
            text_affichage = "At manuel"
            self.set_textvalue(periode_filtration,text_affichage)

        # Mode Marche Forcée
        elif mode_de_fonctionnement == TAB_MODE[3]:
            ma_ppe=1
            text_affichage = "Ma manuel"
            self.set_textvalue(periode_filtration,text_affichage)
            
        # Mode Inconnu: revoir le contenu de Input_select.mode_de_fonctionnement
        else:
            message_notification="Mode de fonctionnement Piscine Inconnu: "+mode_de_fonctionnement
            self.notification(message_notification,0)

        # Calcul sortie commande pompe filtration
        # Arret pompe sur arret forcé
        if arret_force=="on":
            self.turn_off(pompe) 
            self.notification("Att sur Delestage",1)
            text_affichage = "At delestage"
            self.set_textvalue(periode_filtration,text_affichage)
        else:
            if ma_ppe==1:
                self.turn_on(pompe)
                self.notification("Ma Pompe",1)
            else:
                self.turn_off(pompe)
                self.notification("Arret Pompe",1)

    # Fonction Notification
    # message =  Texte à afficher
    # niveau = niveau de journalisation 0,1,2
    def notification(self,message,niveau):
        global JOURNAL
        heure = str(self.time())[:8]
        if niveau <= JOURNAL:
            message_notification= format(heure)+": "+ message
            self.log(message_notification, log="piscine_log")
            #self.call_service('notify/telegram', message=message_notification)
            #self.call_service('persistent_notification/create', message=message_notification)

Interfaces

Interface simplifiée

Le minimum syndical vous permettant d’effectuer des essais.

type: entities
entities:
  - entity: input_select.mode_fonctionnement_piscine
  - entity: sensor.temp_piscine
  - entity: input_number.mem_temp_piscine
  - entity: input_datetime.heure_pivot_pisc
  - entity: input_boolean.calcul_mode_abaque
  - entity: input_number.filtration_coeff_abaque
  - entity: input_number.tempo_circulation_eau
  - entity: switch.cde_pompe_filtration
  - entity: input_text.piscine_periode_filtration
  - entity: input_datetime.heure_ma_pump_pisc_hiv
  - entity: input_number.duree_filtration_max_mode_hiver
  - entity: binary_sensor.ppe_piscine_en_marche
  - entity: sensor.pzem_pisc_puissance
  - entity: sensor.ma_ppe_piscine_jour
title: Piscine
show_header_toggle: false
state_color: true

Dwain Lovelace

Personnellement, j’utilisé l’intégration HACS « Dwain lovelace », voir mon article sur cette excellente intégration HACS.

La dernière version est disponible au téléchargement ici. Vous pouvez adapter les cartes à votre environnement.

Et Pool_pump-Manager?

Et bien si vous aviez suivi mon article https://domo.rem81.com/home-assistant-gestion-piscine-filtration-poolpump/ et migré vers ce mode de gestion du temps de filtration avc AppDaemon, vous pouvez supprimer:

• le HACS Pool_Pump_Manager
• Les automatimes « « calcul fonctionnement pompe » et « mémorisation température avant arret »
• Prendre la dernière version de l’automatisme « hors_gel »

Conclusion

Cet article va surement évolué dans le temps, il reste quelques améliorations ou évolutions à apporter.

N’hésitez pas à me laisser en commentaire, des critiques négatives ou positives constructrices sur le sujet.

Liste des publications en lien avec cet article:

1. Filtration avec « AppDaemon » ou avec « Pool Pump Manager« 
2. Mesure de puissance électrique
3. Mise à niveau automatique
4. Mesure du pH
5. Régulation du Ph
6. Mise Hors Gel
7. Mesure de pression