Aide pour compter l'eau consommée à partir d'une consommation...électrique

Bonjour

je dispose d’un puit avec une pompe qui envoie l’eau dans un réservoir sous pression puis dans un système de filtrage puis mon réseau d’eau.
Cette pompe délivre 600 litres/h quand elle fonctionne (c’est à dire quand on consomme de l’eau).
Cette pompe est connectée à une prise zigbee qui remonte en MQTT sa consommation électrique instantanée. (l’ID est sensor.prise_connectee_cave_power, il est graphé par défaut par HA mais…en W) comme ceci :

Objectif :

  • Grapher ma consommation d’eau (en litre ou en m3) à partir de la consommation électrique sur 24h/1mois/1an.

Problèmes :

  • comment faire un métrique qui convertit durée de pompage+conso electrique en litres ?
  • comment grapher tout ca en litres et remettre si besoin le « compteur à 0 » chaque jour à minuit ?

Merci de votre aide :raised_hands: :heart_hands: :pray:, je suis débutant sous HA et j’ai besoin de vos lumières et de votre capacité de pédagogie pour comprendre comment faire et progresser :slight_smile:

SAlut

je suis au taf donc ton image est filtrée…
juste un truc les pompes c’est pas X watts pour Y litres ça depends des pertes de charge de ton circuit

Mais deja tu va pourvoir avancer un minimum

pour faire cela tu va avoir besoin d’entités intermédiaires.

il te faut convertir des watts en watts heures → integration

puis ensuite pour le cumul par jour par semaine par mois ou par an tu va utiliser ce que l’on appelle dans HA une serie d’utility meter

donc ton permier sensor sera defini comme cela

sensor:
  - platform: integration
    source: sensor.prise_connectee_cave_power
    name: consommation_pompe_cave

utility_meter:
  energy:
    source: sensor.consommation_pompe_cave
    cycle: daily
    name: consommation_pompe_cave_jour

pour la conversion energie vers m3 fait une petite recherche sur le forum
il y a deja eu de telles questions et c’est la que tu mettras ton coef Watts consommé / litres…

je suis pas trop vache il te faudra utiliser un template… :wink:

1 « J'aime »

Bonsoir, merci pour cette réponse.
J’ai tenté de comprendre :slight_smile:

Du coup pour l’intégration j’ai fait ceci :

Donc ca me créé un sensor.pompe_conversion_w_en_w_par_h
j’ai bon ?

Ensuite pour l’Utility Meter j’ai fait ca :

Ensuite pour la conversion en litres j’ai fait ceci dans mon template.yaml:

- sensor:
  - name: "Consommation litres d'eau"
    unit_of_measurement: "L"
    state: "{{ states('pompe_cumul_des_datas_de_w_par_h')}}"

- sensor:
  - name: "Consommation M3 d'eau"
    unit_of_measurement: "m³"
    state: "{{ states('pompe_cumul_des_datas_de_w_par_h')|float / 1000 }}"

Puis j’ai créé une carte dans lovelace et j’ai relancé HA.

Bon…Ca me donne des trucs :

type: history-graph
entities:
  - entity: sensor.prise_connectee_cave_power
  - entity: sensor.pompe_conversion_w_en_w_par_h
  - entity: sensor.pompe_cumul_des_datas_de_w_par_h
  - entity: sensor.consommation_m3_d_eau
  - entity: sensor.consommation_litres_d_eau
title: Pompe à eau 24h
hours_to_show: 24
refresh_interval: 5

Mais il y a encore cette histoire de 600l/h qu’il faut adresser et je ne vois pas comment. :thinking:

moi je t’invite a essayer d’etalonner ta pompe wh → litres
essaye de la faire fonctionner par exemple 10 minutes
ça te donnera une consommation et un volume…
et a partir de la tu es le roi du petrole

Salut,

Je me suis dit : Le plus simple, sachant que la pompe fait 600l/heure c’est de calculer avec HA combien de temps elle a été en fonction. Ca me donne une durée d’utilisation après c’est une règle de 3…
(et ca m’évite d’avoir à me faire couler un bain à minuit pendant 10 minutes et à compter les litres dans la baignoire :slight_smile: )

Donc pour avoir la durée d’utilisation j’ai ajouté un sensor comme ceci :

##Compte le temps utilisé par la pompe chaque 24h
- platform: history_stats
  name: Pompe cave ON today duree
  entity_id: sensor.prise_connectee_cave_power
  state: >
   {{ states('sensor.prise_connectee_cave_power') | float >0}}  
  type: time
  start: "{{ now().replace(hour=0, minute=0, second=0) }}"
  end: "{{ now() }}"

Bon…Mais il doit y avoir une erreur, ca reste à 0 :sob:
Pourtant {{ states(‹ sensor.prise_connectee_cave_power ›) | float >0}} passe bien à true quand la pompe fonctionne…

Qu’est ce je j’ai raté ? :slight_smile:

Salut tout le monde,
bon, j’ai découpé mon décompte de temps en deux parties :
1 - un binary sensor:

binary_sensor:
  - platform: template
    sensors:  
      etat_on_off_pompe:
        friendly_name: 'etat_de_fonctionnement_de_la_pompe_de_la_cave'
        value_template: >
          {{ states('sensor.prise_connectee_cave_power') | float > 100}}

Le > 100 c’est parce que la pompe consomme toujours quelques watt même au repos et…1300W en fonctionnement donc si c’est >100 on sait qu’elle pompe à fond :slight_smile:

2 - le sensor qui utilise le binary sensor (il doit y avoir plus élégant mais bon…)

##Compte le temps en HEURES utilisé par la pompe chaque 24h
- platform: history_stats
  name: Pompe cave ON today duree
  entity_id: binary_sensor.etat_on_off_pompe
  state: 'on' 
  type: time
  start: "{{ now().replace(hour=0, minute=0, second=0) }}"
  end: "{{ now() }}"

Et miracle ca fonctionne :slight_smile:

Je mets tout ca ici pour que ca puisse éventuellement servir à d’autres :slight_smile:

Merci pour le partage.

Je conseille aussi d’aller voir côté Powercalc . Ce composant a plein de méthode de calculer l’énergie consommée.

A première vu il manque la facilité de convertir une durée de fonctionnement en nombre de Litres, mais ce serait une bonne idée de suggérer au dévelopeur de prévoir ce genre de cas.

@jrvrcd à raison.
Maintenant, tout dépand de la précision que tu veux sur ta consommation.
Ta pompe est plus que probablement un pompe centrifuge.
Une telle pompe à une courbe de fonctionnement avec en ordonnée « La hauteur manométrique » (on peut dire la pression) et en abscisse le débit.
En gros, lorsque ta pompe débite son débit maximal, elle est à une pression nulle.
Et inversément, lorsque la pompe est à pression max, elle ne débite plus.
Très facile à démontrer avec une petite pompe d’aquarium (qui ont des hauteur manométrique de l’ordre de 2 mètres)
Aussi, ta pompe fonctionne entre ces deux extrêmes (débit nul et débit max)
Le régime réel de ta pompe est donc fonction de la géométrie de ton installation.
Et pour être plus ou moins proche du débit horaire réel de ta pompe, l’idée du « dépotage » de @jrvrcd est judicieuse.
Petite question: Ou as-tu trouvé l’info des 600 litres / heure ?
@+ Guy

Bonjour et merci pour le partage.

Je souhaite également réaliser des observation sur le volume passé par la pompe en fonction de sa consommation électrique via un capteur SCT013 ; mon but étant de compter la quantité de fuel consommé par ma chaudière.

As-tu pu continuer ton projet et obtenir le volume « pompé » quand bien même tu utiliserais un débit horaire théorique ?

Devant la quantité incroyable de post du forum, je n’ai pas réussi a en ressortir un qui serait approprié, @jrvrcd, aurais tu des liens ou des mots clés de recherche ?

Salut

J’essaye de vous faire travailler un peu et pas vous donner la solution ton faite

Template… c’est grace a cela que vous pourrez faire vos calculs.

1 « J'aime »

Je suis adepte de la méthode également, merci pour la carotte ;p

J’ai pu à la lecture de plusieurs post, celui-ci y compris mais avant de tomber dessus, m’établir une liste d’intégration :

  • Je pars du courant mesuré pour le convertir en binaire,
  • compte le temps « on »,
  • log le tout avec history_stats pour avoir la valeur de TEMPS
  • log les cumul de temps avec les utility_meter (heure, jour, mois, année)
  • et converti l’affichage par un template comme proposé avec un débit horaire théorique (à étalonner en effet)
binary_sensor:
  - platform: threshold
    name: chaudiere_en_chauffe
    entity_id: sensor.mysensor_dht22_sct_013_00_32_4
    upper: 0.20
# historique sur le temps de chauffe de la chaudière
- platform: history_stats
  name: chauffe_on
  entity_id: binary_sensor.chaudiere_en_chauffe
  state: "on"
  type: time
  start: "{{ now().replace(hour=0).replace(minute=0).replace(second=0) }}" 
  end: "{{ now() }}"
# sotckage de l'info avec totalisation (ici annuelle)
utility_meter:
  chauffe_annee:
    source: sensor.chauffe_on
    cycle: yearly
# conversion de la donnée de TEMPS de chauffe annuelle en VOLUME 
sensor:
  - platform: template
    sensors:
      volume_fuel_consomme_annee:
        friendly_name: "volume_de_fuel_consomme_sur_annee"
        value_template: >
          {{ states('input_number.debit_pompe_gicleur')|float * states('sensor.chauffe_annee')|float | round(1) }}

Cela semble fonctionnel mais ne peux pas réellement vérifier avant le remplissage de la cuve.

Je trouve les étapes un peu nombreuses et j’ai longtemps hésiter sur/entre les history_stats et utility_meter.
Pouvez vous me dire si j’ai bien procédé ou s’il n’y a pas plus simple ?

De memoire il y a une integration qui te permets de calculer la consommation d’une lampe basée sur son temps de fonctionnement
j’utilise pas donc j’ai pas en memoire le nom de cette integration

fait une recherche sur temps de fonctionnement avec ça tu devrais trouver je pense
mais sinon ta demarche est celle qui me semble la plus logique

Merci pour la piste et le mot clef !