Définir dynamiquement la durée de déclenchement d'un schelly

Bonjour à tous,

J’utilise depuis quelques jours l’intégration « Solar optimizer » de @Jean-Marc_Collin :muscle: pour mon chauffe eau électrique.
L’intégration fonctionne bien, cependant comment gérer les jours de mauvais temps quand le chauffe eau n’aura pas fonctionné de la journée.

Etant un utilisateur tout récent de Home assistant,et qu’il faut bien mettre les mains dans le cambouis pour apprendre, j’essaie donc de répondre à cette problématique.

A ce jour :

  • j’ai un capteur qui relève le temps total quotidien (un float) de fonctionnement de mon chauffe eau.
    il se remet à 0 à 6H15.
  • j’ai une automatisation qui récupère à 20H30, la valeur du capteur, sachant la durée de fonctionnement minimum quotidienne du chauffe eau (1h30), je fais la difference entre la durée minimum et la durée du jour, si le réultat est négatif, je mets 0, si c’est positif j’indique la valeur à 0,5 pret (soit une 1/2H) et je la copie dans un input_number

J’en arrive à mon point de blocage…
Maintenant que j’ai ma durée de fonctionnement pour les HC, comment je peux l’utiliser dans un automatisme ?

En espérant avoir été clair :wink:
Merci

Ci-dessous ce que j’ai fait

Le capteur qui recupère le temps de fonctionnement

- platform: history_stats
  name: Fonctionnement chauffe eau aujourd'hui
  entity_id: switch.chauffe_eau_switch_0
  unique_id: sensor_fonctionnement_chauffe_eau _aujourdhui
  state: "on"
  type: time
  #start: "{{ today_at() }}"
  start: "{{ now().replace(hour=6).replace(minute=15).replace(second=0)}}"
  end: "{{ now() }}"

La MAJ de mon input number à 20H30

alias: Maj durée fonctionnement chauffe eau HC
description: Maj de la durée fonctionnement HC
trigger:
  - platform: time
    at: "20:30:00"
condition: []
action:
  - service: input_number.set_value
    data:
      value: >-
        {% if  1.5 -
        states('sensor.fonctionnement_chauffe_eau_aujourd_hui')|round(1,
        'ceil')> 0 %}   {{ (1.5
        -states('sensor.fonctionnement_chauffe_eau_aujourd_hui')|round(1,'ceil'))|float
        }}  {% else %}  {{(0.0)|float}} {% endif %}
    target:
      entity_id: input_number.duree_chauffe_eau_hc
mode: single

L’automatisme qui déclencherait le chauffe en HC si nécessaire, mais comment y ajouter la valeur de mon input_number (avec conversion en heures et minutes) ?

alias: Démarrage Chauffe eau HC
description: ""
trigger:
  - platform: time
    at: "04:00:00"
condition:
  - condition: numeric_state
    entity_id: input_number.duree_programmee_chauffe_eau_hc
    above: 0
action:
  - service: switch.turn_on
    target:
      entity_id: switch.chauffe_eau_switch_0
    data: {}
mode: single

J’ai le même soucis et je fais systèmatiquement un cycle la nuit en heure creuse. Au mieux il ne fait rien car l’eau à chaiuffer dans la journée, au pire il chauffe pour compléter ce qui manque.

Merci @Jean-Marc_Collin
Effectivement avec la sonde qui coupera à la température atteinte souhaitée, c’est tout aussi simple :upside_down_face:
J’ai donc programmé un cycle en HC qui se déclenchera si la durée de fonctionnement est inférieure à 1H30 sur la journée

1 « J'aime »

Salut @patBrid

Dans ton automatisation après avoir allumer le cumulus tu mets une action attendre de la durée de ton input number et ensuite une action éteindre le cumulus.
Bien sur il va falloir traduire ton 0,5 (par exemple) en minutes ou en heure et minutes (je ne sais pas si on peut mettre plus de 60 dans les minutes, jamais testé)

Merci @Tochy
Je vais regarder de ce coté là

bon… j’en suis là
J’ai un message d’erreur
« Message malformed: expected float for dictionary value @ data[‹ action ›][1][‹ delay ›][‹ hours ›] »
Le format des valeurs n’est pas bon, je ne vois pas trop

L’idée (prise à @Pulpy-Luke)…imaginons que le temps de fonctionnement est de 1,5 soit 1H30
je multiplie cette valeur par 60, résultat égal 90
1 - pour les heures je divise par 60 et récupère le quotient soit 1
2- pour les minutes je fais le modulo, je recupère le reste soit 30

alias: Chauffe eau HC 1
description: ""
trigger:
  - platform: time
    at: "04:00:00"
condition:
  - condition: numeric_state
    entity_id: input_number.duree_programmee_chauffe_eau_hc
    below: 2
action:
  - service: switch.turn_on
    target:
      entity_id: switch.chauffe_eau_switch_0
    data: {}
  - delay:
      hours: {{ ((states("input_number.duree_programmee_chauffe_eau_hc")|int(0)*60) / 60) | int(0) }}
      minutes: {{ ((states("input_number.duree_programmee_chauffe_eau_hc")|int(0)*60) % 60) | int(0) }}
      seconds: 0
      milliseconds: 0
  - service: switch.turn_off
    target:
      entity_id: switch.chauffe_eau_switch_0
    data: {}
mode: single

Tu peux tester avec des valeurs en dur.
PAr contre mieux que des automatisations qui reste en attente pendant des heures, tu peux utiliser les timers

Exemple un peu brut dans une automatisation :

  • une valeur input_number.radiateur_ceramique qui donne le temps de fonctionnement
  • input_boolean.radiateur_ceramique que j’utilise pour l’affichage et comme déclencheur du timer
  • sensor.chevet1_suite_action et sensor.chevet2_suite_action comme basculement du changement de input_boolean.radiateur_ceramique à on/off/on/off etc
alias: Timer céramique
description: ""
trigger:
  - platform: state
    entity_id:
      - input_boolean.radiateur_ceramique
    to: "off"
    id: inputoff
    from: "on"
  - platform: state
    entity_id:
      - input_boolean.radiateur_ceramique
    id: inputon
    from: "off"
    to: "on"
  - platform: state
    entity_id:
      - input_number.radiateur_ceramique
    id: numberedit
  - platform: state
    entity_id:
      - timer.radiateur_ceramique
    id: timeroff
    to: idle
  - platform: state
    entity_id:
      - timer.radiateur_ceramique
    id: timeron
    to: active
  - platform: state
    entity_id:
      - sensor.chevet1_suite_action
      - sensor.chevet2_suite_action
    id: button
    to: hold
condition: []
action:
  - choose:
      - conditions:
          - condition: trigger
            id:
              - inputon
        sequence:
          - service: timer.start
            data:
              duration: "{{states('input_number.radiateur_ceramique') | int(0) *60 }}"
            target:
              entity_id: timer.radiateur_ceramique
      - conditions:
          - condition: trigger
            id:
              - inputoff
        sequence:
          - service: timer.finish
            target:
              entity_id: timer.radiateur_ceramique
            data: {}
      - conditions:
          - condition: trigger
            id:
              - timeroff
        sequence:
          - service: switch.turn_off
            data: {}
            target:
              entity_id: switch.radiateur_ceramique_power
          - service: input_boolean.turn_off
            data: {}
            target:
              entity_id: input_boolean.radiateur_ceramique
      - conditions:
          - condition: trigger
            id:
              - timeron
        sequence:
          - service: switch.turn_on
            data: {}
            target:
              entity_id:
                - switch.radiateur_ceramique_power
          - service: switch.turn_on
            data: {}
            target:
              entity_id:
                - switch.radiateur_ceramique_oscillation_h
          - service: switch.turn_on
            data: {}
            target:
              entity_id:
                - switch.radiateur_ceramique_oscillation_v
      - conditions:
          - condition: trigger
            id:
              - numberedit
        sequence:
          - service: timer.start
            data:
              duration: "{{states('input_number.radiateur_ceramique') | int(0) *60 }}"
            target:
              entity_id: timer.radiateur_ceramique
          - service: timer.finish
            metadata: {}
            data: {}
            target:
              entity_id: timer.radiateur_ceramique
      - conditions:
          - condition: trigger
            id:
              - button
        sequence:
          - service: input_boolean.toggle
            data: {}
            target:
              entity_id: input_boolean.radiateur_ceramique
mode: queued
max: 3
```

merci @Pulpy-Luke, je vais essayer de comprendre ton code :wink:

Tu aurais pu tout simplement mettre ça :

hours: 0
minutes: {{ (states("input_number.duree_programmee_chauffe_eau_hc")|int(0)*60) | int(0) }}

90 minutes c’est légal (pas besoin de module et / 60)

Merci @Jean-Marc_Collin
Je m’étais imaginé que l’on ne pouvez dépasser 59 dans les parametres du delay…

Par contre je me prends une erreur

alias: Chauffe eau HC
description: ""
trigger:
  - platform: time
    at: "04:00:00"
condition:
  - condition: numeric_state
    entity_id: input_number.duree_chauffe_eau_hc
    below: 10
action:
  - service: switch.turn_on
    target:
      entity_id: switch.chauffe_eau_switch_0
    data: {}
  - delay:
      hours: 0
      minutes: "{{ (states('input_number.duree_chauffe_eau_hc')*60) | float }}"
      seconds: 0
      milliseconds: 0
  - service: switch.turn_off
    target:
      entity_id: switch.chauffe_eau_switch_0
    data: {}
mode: single

Pour le test, j’ai mis 0.2 pour l’input_number.duree_chauffe_eau_hc, et je teste avec les secondes (ca va plus vite pour les test :grinning:)

soit j’ai cette erreur dans les log

avec

seconds: "{{ states('input_number.duree_chauffe_eau_hc')*60 | int }}"

soit cette erreur au moment de l’enregistrement

image

avec

  seconds: {{ states('input_number.duree_chauffe_eau_hc')*60 | float}}

Salut

Il faut mettre ton sensor en float ou int avant de le multiplier

minutes: "{{ (states('input_number.duree_chauffe_eau_hc') |float *60 }}"

et si tu a besoin que ce soit un int en resultat tu rajoute un |int sur le tout

Ps: Outils de dev/modele permet de tester tout ça

Hello @Tochy
Impec…ca fonctionne, merci

Merci à tous ceux qui m’ont aidé, cela fonctionne desormais

et pour ceux que ca pourrait interesser…
un petit recap, je suis parti du principe que le chauffe eau doit fonctionner minimum 2H/j

L’entrée qui comptabilise le temps de fonctionnement du chauffe eau dans la journée est remise à zéro à 6H15, car le chauffe eau peut fonctionner entre 4H et 6H, si la journée précédente a été trop nuageuse

- platform: history_stats
  name: Fonctionnement chauffe eau aujourd'hui
  entity_id: switch.chauffe_eau_switch_0
  unique_id: sensor_fonctionnement_chauffe_eau _aujourdhui
  state: "on"
  type: time
  #start: "{{ today_at() }}"
  start: "{{ now().replace(hour=6).replace(minute=15).replace(second=0)}}"
  end: "{{ now() }}"

En début de soirée, je calcule le temps nécessaire pour le fonctionnement en HC (si durant la journée il a fonctionné 2h ou plus je renvoie 0, sinon je calcule la difference) et je l’injecte dans un input_number

alias: Maj durée fonctionnement chauffe eau HC
description: Maj de la durée fonctionnement HC
trigger:
  - platform: time
    at: "20:30:00"
condition: []
action:
  - service: input_number.set_value
    data:
      value: >-
        {% if  2 -
        states('sensor.fonctionnement_chauffe_eau_aujourd_hui')|round(1,
        'ceil')> 0 %}   {{ (2
        -states('sensor.fonctionnement_chauffe_eau_aujourd_hui')|round(1,'ceil'))|float
        }}  {% else %}  {{(0.0)|float}} {% endif %}
    target:
      entity_id: input_number.duree_chauffe_eau_hc
mode: single

l’automatisme des HC du chauffe eau qui verifie si celui doit démarrer en HC et dans ce cas il se base sur le temps manquant calculé précédent

alias: Chauffe eau HC
description: ""
trigger:
  - platform: time
    at: "04:00:00"
condition:
  - condition: numeric_state
    entity_id: input_number.duree_chauffe_eau_hc
    above: 0
action:
  - service: switch.turn_on
    target:
      entity_id: switch.chauffe_eau_switch_0
    data: {}
  - delay:
      hours: 0
      minutes: "{{ states('input_number.duree_chauffe_eau_hc') |float *60 }}"
      seconds: 0
      milliseconds: 0
  - service: switch.turn_off
    target:
      entity_id: switch.chauffe_eau_switch_0
    data: {}
mode: single


Alors effectivement comme me le faisait très justement remarquer @Jean-Marc_Collin, avec la sonde du chauffe eau tout ceci n’est peut-être pas forcement nécessaire pour ce type d’appareil, mais cela peut être utile pour d’autres.