Intro

Dans un article précédent, je décrivais une première version de routeur PV monté sur la base d’une mesure de puissance tiers, dans mon cas, délivrée par mon onduleur Victron, et un pilotage de Triac via esp8266 délocalisé.

Dans cette version je vous propose un montage développé sous ESP Home donc complètement intégré à HA.

Mise à Jour:

• 01/08/2023: Remplacement de de « restore_value » par « restore_mode » dans les « switch » suite à rupture dans la version 2023-07 ESPHOME.

Liste des courses:

Dans cette version vous aurez besoin à minima:

nota: les liens sont donnés à titre d’exemple, je n’ai aucune relation commerciale avec ces vendeurs

• Un ESP32

• Un module de mesure de puissance communiquant Modbus JSY-MK-194T

• Un triac RobotDyn 24A

• Un dissipateur thermique

• Une sonde de température Dallas ds18b20.

• En option, et je vous le conseille, prenez un afficheur comme celui-ci:

Vous pouvez choisir d’autres modèles, mais il vous faudra modifier le code.

Principe de fonctionnement

La pince du module JSY est connectée en tête de votre tableau électrique principal en sortie de Linky, il mesure en permanence plusieurs grandeurs électriques, mais les deux qui nous intéressent principalement sont la mesure de puissance et le sens du courant dans la pince. L’ESP interroge en permanence (toutes les 750ms) le module via un port UART sous le protocole Modbus.

Avec ces deux grandeurs, l’ESP calcule le niveau de charge du triac sur une échelle de 0 à 100%.

Par convention , la puissance injectée sur le réseau est négative et la puissance soutirée est positive.

Donc plus la puissance est négative plus on ouvre le triac, on tend vers les 100%. L’algorithme retenu est plutôt simple: S= S+P*Coeff/1000 avec S la sortie triac, P, la puissance mesurée et Coeff un coefficient de réactivité.

A chaque lecture de la puissance la sortie S vers le triac est incrémentée ou décrémentée selon le signe de la puissance mesurée. Le coefficient « Coeff » rend l’algorithme plus ou moins réactif, il faut trouver le compromis pour une plus grande réactivité sans entrer dans un système oscillatoire.

La Partie Matérielle

Schéma Electronique:

Dans le schéma électronique qui suit vous retrouverez le câblage des différents éléments, vous y trouverez également des éléments non programmés comme le Triac 2 et le relais, c’est en prévision d’extension logicielle.

Modification du refroidissement du triac

Si vous souhaitez exploiter pleinement les capacités de votre triac 24A vous devez remplacer le refroidisseur en aluminium d’origine par un refroidisseur plus important.

La modification est clairement expliquez par le prof’solaire dans cette video.

La partie logicielle:

Capteur JSY-MK-194T

Ce module communique en modbus via un port serie. Il permet de remonter de nombreuses grandeurs physiques électriques via un tore déporté, avec lequel je mesure la puissance soutirée ou injectée sur le réseau, placé directement en sortie Linky, et un tore soudé sur la carte, avec lequel je mesure la puissance soutirée par l’ECS (Ballon Eau Chaude Sanitaire).

Sur chaque Tore, vous pouvez lire, la puissance, l’intensité, la tension, la fréquence, l’énergie.

Vous remarquez que la trame Modbus lit la totalité des grandeurs physiques du JSY (14 registres), cela optimise le temps de lecture en n’envoyant qu’une seule trame Modbus, le fait de supprimer des registres, segmenterai les trames et augmenterai le temps de réponse,cela étant, je n’affiche pas toutes les grandeurs mais libre à vous de les visualiser.

J’interroge le module toutes les 750 ms, ce qui donne une réactivité du système plutôt satisfaisante, en dessous, je rencontre des erreurs de lecture.

Vous trouverez ci après le descriptif des trames modbus du capteur:

Afin que le capteur JSY soit plus réactif, il faut augmenter sa vitesse de communication à 38400 bauds qui par défaut est à 4800 bauds.

La manipulation est très bien décrite sur le site du prof’Solair. Perso, j’ai utilisé le logiciel Windows et ce convertisseur USB<->Port série. 

Codage ESP

Vous trouverez ci après le code de l’ESP, c’est en service depuis quelques semaines avec des résultats très satisfaisants.

substitutions:
  device_name: "esp176-esp32-routeur-1r"
  friendly_name: esp176
  adress_ip: "192.168.0.176"
  time_timezone: "Europe/Paris"
  
esphome:
  name: ${device_name}
  platform: ESP32
  board: esp32dev
  project:
    name: "rem81.esp176-esp32-routeur"
    version: "1.0.0"
  on_boot:
    priority: 800
    # Force mode auto et tempok au demmarrage
    then: 
      - switch.turn_on: modeauto
      - binary_sensor.template.publish:
          id: tempok
          state: ON

wifi:
  networks:
    - ssid: !secret wifi
      password: !secret mdpwifi
  reboot_timeout: 5min

  manual_ip:
    static_ip: ${adress_ip}
    gateway: 192.168.0.254
    subnet: 255.255.255.0

# Enable logging
logger:
  baud_rate: 0
  level: DEBUG
#  logs:
#    modbus.component: INFO
# Enable Home Assistant API
api:

ota:

web_server:
  port: 80

# Protocole afficheur
i2c:
  sda: GPIO21 
  scl: GPIO22
  scan: True
  id: bus_a

# Protocole du JSK
uart:
  id: mod_bus
  tx_pin: 17
  rx_pin: 16
  baud_rate: 38400
  stop_bits: 1
#  debug:
#    direction: BOTH
#    dummy_receiver: false
#    after:
#      timeout: 150ms
#    sequence:
#      - lambda: |-
#          UARTDebug::log_string(direction, bytes);

modbus:
#flow_control_pin: 5
  #send_wait_time: 200ms
  id: modbus1

modbus_controller:
  - id: jsymk
    ## the Modbus device addr
    address: 0x1
    modbus_id: modbus1
    update_interval: 0.75s
    command_throttle: 50ms
    
    # setup_priority: -10

globals:
   - id: increment
     type: float
     restore_value: no
     initial_value: '0'
   - id: striac
     type: float
     restore_value: yes

# Sonde Temperature Dallas
dallas:
  - pin: GPIO27 #
    update_interval: 60s

# Informations supplementaires sur le WIFI
#text_sensor:
#  - platform: wifi_info
#    ip_address:
#      name: ${friendly_name}_ESP IP Address
#    ssid:
#      name: ${friendly_name}_ESP Connected SSID
#    bssid:
#      name: ${friendly_name}_ESP Connected BSSID
#    mac_address:
#      name: ${friendly_name}_ESP Mac Wifi Address
#    scan_results:
#      name: ${friendly_name}_ESP Latest Scan Results


binary_sensor:
#Etat de la connection
  - platform: status
    name: "${friendly_name}_Status"

  - platform: template
    name: "${friendly_name} Temp Ok"
    id: tempok

# Input Number
number:
  # Seuil Min/Max sortie triac
  - platform: template
    name: "${friendly_name} P Max"
    id: pmax
    optimistic: true
    restore_value: true
    mode: box
    min_value: 50
    max_value: 100
    unit_of_measurement: "%"
    step: 1

  - platform: template
    name: "${friendly_name} P Min"
    id: pmin
    optimistic: true
    restore_value: true
    mode: box
    min_value: 0
    max_value: 25
    unit_of_measurement: "%"
    step: 1

# Seuil MAX temperature
  - platform: template
    name: "${friendly_name} T Max"
    id: tmax
    optimistic: true
    restore_value: true
    mode: box
    min_value: 0
    max_value: 75
    unit_of_measurement: "C°"
    step: 0.1

# Coeff Réactivité
  - platform: template
    name: "${friendly_name} Coeff R"
    id: coeff_r
    optimistic: true
    restore_value: true
    mode: box
    min_value: 0
    max_value: 1000
    unit_of_measurement: ""
    step: 0.1


sensor:  

# tension de l'alimentation
  - platform: modbus_controller
    modbus_controller_id: jsymk
    id: Tension
    #name: "${friendly_name} Tension JSYMK"
    address: 0x0048
    unit_of_measurement: "V"
    register_type: holding
    value_type: U_DWORD
    accuracy_decimals: 1
    filters:
      - multiply: 0.0001
    register_count: 1
    response_size: 4

# Intensité traversant le tore
  - platform: modbus_controller
    modbus_controller_id: jsymk
    id: Itore
    name: "${friendly_name} I_ECS JSYMK"
    address: 0x0049
    unit_of_measurement: "A"
    register_type: holding
    value_type: U_DWORD
    accuracy_decimals: 1
    filters:
      - multiply: 0.0001
    register_count: 1
    response_size: 4

# Puissance traversant le tore
  - platform: modbus_controller
    modbus_controller_id: jsymk
    id: puecs
    name: "${friendly_name} P_ECS JSYMK"
    address: 0x004A
    unit_of_measurement: "W"
    register_type: holding
    value_type: U_DWORD
    accuracy_decimals: 1
    filters:
      - multiply: 0.0001
    register_count: 1
    response_size: 4

# Energie lue dans le tore
  - platform: modbus_controller
    modbus_controller_id: jsymk
    id: energietore
    name: "${friendly_name} Energie ECS JSYMK"
    address: 0x004B
    unit_of_measurement: "kWh"
    register_type: holding
    value_type: U_DWORD
    accuracy_decimals: 1
    filters:
      - multiply: 0.0001
    register_count: 1
    response_size: 4

# Energie lue dans le tore
  - platform: modbus_controller
    modbus_controller_id: jsymk
    id: fptore
    #name: "${friendly_name} FP Tore JSYMK"
    address: 0x004C
    register_type: holding
    value_type: U_DWORD
    accuracy_decimals: 1
    filters:
      - multiply: 0.0001
    register_count: 1
    response_size: 4

# Energie NEG lue dans le tore
  - platform: modbus_controller
    modbus_controller_id: jsymk
    id: energietoren
    name: "${friendly_name} Energie ECS Neg JSYMK"
    address: 0x004D
    unit_of_measurement: "kWh"
    register_type: holding
    value_type: U_DWORD
    accuracy_decimals: 1
    filters:
      - multiply: 0.0001     
    register_count: 1
    response_size: 4 
# Sens du courant dans la pince
  - platform: modbus_controller
    modbus_controller_id: jsymk
    id: senspince
    #name: "${friendly_name} Sens_Pince JSYMK"
    address: 0x004E
    register_type: holding
    value_type: U_DWORD
    bitmask: 0X00010000
    filters:
      - multiply: 1
    register_count: 1
    response_size: 4
# Sens du courant dans le tore
  - platform: modbus_controller
    modbus_controller_id: jsymk
    id: senstor
    #name: "${friendly_name} Sens_Tore JSYMK"
    address: 0x004E
    register_type: holding
    value_type: U_DWORD
    accuracy_decimals: 0
    bitmask: 0X01000000
    filters:
      - multiply: 1
    register_count: 1
    response_size: 4

# Fréquence de l'alimentation  
  - platform: modbus_controller
    modbus_controller_id: jsymk
    id: frequence
    #name: "${friendly_name} Frequence JSYMK"
    address: 0x004F
    unit_of_measurement: "hz"    
    register_type: holding
    value_type: U_DWORD
    accuracy_decimals: 1
    filters:
      - multiply: 0.01
    register_count: 1
    response_size: 4

# tension de l'alimentation
  - platform: modbus_controller
    modbus_controller_id: jsymk
    id: Tension2
    #name: "${friendly_name} U_Reseau JSYMK"
    address: 0x0050
    unit_of_measurement: "V"
    register_type: holding
    value_type: U_DWORD
    accuracy_decimals: 1
    filters:
      - multiply: 0.0001
    register_count: 1
    response_size: 4
    
# Intensité lue dans la pince
  - platform: modbus_controller
    modbus_controller_id: jsymk
    id: Ireseau
    #name: "${friendly_name} I_Reseau JSYMK"
    address: 0x0051
    unit_of_measurement: "A"
    register_type: holding
    value_type: U_DWORD
    accuracy_decimals: 1
    filters:
      - multiply: 0.0001
    register_count: 1
    response_size: 4

# puissance lue dans la pince
  - platform: modbus_controller
    modbus_controller_id: jsymk
    id: pureseau
    #name: "${friendly_name} P_Reseau JSYMK"
    address: 0x0052
    unit_of_measurement: "W"
    register_type: holding
    value_type: U_DWORD
    accuracy_decimals: 1
    filters:
      - multiply: 0.0001
    register_count: 1
    response_size: 4 
    on_value:
      then:
        - lambda: |-
            if ( id(senspince).state == 1 ) {
              id(pureseau1).publish_state( id(pureseau).state *-1);
            } else {
              id(pureseau1).publish_state( id(pureseau).state );
            }
        - lambda: id(afincrement).publish_state( id(increment) );
        - script.execute: calcul_injectionv2
        - script.execute: etat_production 
        - lambda: id(afstriac).publish_state( id(striac) );
    
# Energie lue dans la pince
  - platform: modbus_controller
    modbus_controller_id: jsymk
    id: energiepince
    #name: "${friendly_name} Energie Reseau JSYMK"
    address: 0x0053
    unit_of_measurement: "kWh"
    register_type: holding
    value_type: U_DWORD
    accuracy_decimals: 1
    filters:
      - multiply: 0.0001
    register_count: 1
    response_size: 4

# Energie lue dans le tore
  - platform: modbus_controller
    modbus_controller_id: jsymk
    id: fppince
    #name: "${friendly_name} FP Pince JSYMK"
    address: 0x0054
    register_type: holding
    value_type: U_DWORD
    accuracy_decimals: 1
    filters:
      - multiply: 0.0001
    register_count: 1
    response_size: 4

# Energie NEG lue dans le tore
  - platform: modbus_controller
    modbus_controller_id: jsymk
    id: energienegpince
    #name: "${friendly_name} Energie ECS Neg JSYMK"
    address: 0x0055
    unit_of_measurement: "kWh"
    register_type: holding
    value_type: U_DWORD
    accuracy_decimals: 1
    filters:
      - multiply: 0.0001     
    register_count: 1
    response_size: 4 
    
# Informations WI_FI
  - platform: wifi_signal # Affiche le signal WiFi strength/RSSI en dB
    name: "${friendly_name} WiFi Signal dB"
    id: wifi_signal_db
    update_interval: 60s
    entity_category: "diagnostic"

  - platform: copy # Affiche le signal WiFi strength en %
    source_id: wifi_signal_db
    name: "${friendly_name} WiFi Signal Percent"
    filters:
      - lambda: return min(max(2 * (x + 100.0), 0.0), 100.0);
    unit_of_measurement: "Signal %"
    entity_category: "diagnostic"

############### TEMPLATE  ######################"
# Affichage dans HA et sur l'afficheur
  - platform: template
    name: "${friendly_name} Pu Reseau"
    id: pureseau1
    unit_of_measurement: "W"
    state_class: "measurement"  
 
  - platform: template
    name: "${friendly_name} Increment"
    id: afincrement
    unit_of_measurement: ""
    accuracy_decimals: 2
    state_class: "measurement"

  - platform: template
    name: "${friendly_name} Sortie Triac"
    id: afstriac
    unit_of_measurement: "%"
    state_class: "measurement"  
    accuracy_decimals: 2

# Sonde Temperature radiateur
  - platform: dallas
    address: 0xeb012112e461b128
    name: "${friendly_name} Temp triac"
    id: temp_triac
    filters:
      - filter_out: NAN
    on_value:
      then:
        if:
          condition:
            lambda: 'return id(temp_triac).state < id(tmax).state;'
        # Si Temp Triac inferieur au seuil alors OK
          then:
            - binary_sensor.template.publish:
                id: tempok
                state: ON
        # Sinon attendre 60s avant retour à la normal
          else:
            - binary_sensor.template.publish:
                id: tempok
                state: OFF
            - delay: 60s
 
switch:
  - platform: gpio
    name: "${friendly_name} Relais"
    pin: GPIO5
    id: relais

  - platform: template
    name: "${friendly_name} Validation Router"    
    id: val_router
    optimistic: true
    restore_mode: RESTORE_INVERTED_DEFAULT_OFF

  - platform: template
    name: "${friendly_name} Mode Auto"    
    id: modeauto
    optimistic: true
    restore_mode: always_on

  - platform: restart
    name: "${friendly_name} Restart"

output:
#LEDS --------------------------------------
  - id: led_conso
    platform: gpio
    pin: GPIO32
    
  - id: led_injec
    platform: gpio
    pin: GPIO25
# Pilotage du Dimmer ------------------------
  - platform: ac_dimmer
    id: ecs
    gate_pin: GPIO33
    method: leading
    zero_cross_pin:
      number: GPIO34 
      mode:
        input: true
      inverted: yes
    min_power: 5%

light:
  - platform: monochromatic
    name: "${friendly_name}+STriac"
    output: ecs
    id: gradateur
    default_transition_length: 50ms

# Affichage
display:
  - platform: lcd_pcf8574
    dimensions: 20x4
    address: 0x27
    update_interval: 2s
    lambda: |-
      it.printf(0,0,"Pr=%0.0fW",id(pureseau1).state);
      it.printf(10,0,"Pe=%0.0fW ",id(puecs).state);
      it.printf(0,1,"Tr=%0.1f%%",id(striac));
      it.printf(10,1,"Val:%s", id(val_router).state ? "OK" : "NOK");
      it.printf(0,2,"Tp=%0.1fc", id(temp_triac).state);
      it.printf(10,2,"Etat=%s", id(tempok).state ? "OK" : "NOK");
      it.printf(0,3,"Mode=%s", id(modeauto).state ? "Auto" : "Manu");
      it.printf(10,3,"Inc=%0.1f ",id(increment));     
#interval:

#  - interval: 0.5s
#    then:

     #  - script.execute: 

# ------------------------  Scripts
script:
# 
# ------------------------ Calcul puissance injection V2
  - id: calcul_injectionv2
    mode: single
    then:
      - lambda: |-
         id(increment) = id(pureseau1).state*id(coeff_r).state/1000*-1;
 
      - lambda: |-
         id(striac) = id(striac)+id(increment);            

      - logger.log:
          format: "Log S Triac= %f"
          args: [ 'id(striac)']

      - lambda: |-
          if (id(striac) <= 0){
            id(striac) = 0;
          } else if(id(striac)>=id(pmax).state){
            id(striac) = id(pmax).state;
          }

      # Si mode routeur validé et mode auto et temp OK alors on active le triac et Sortie Triac superieur au mini
      - if: 
          condition:
            and:
              - switch.is_on: val_router
              - switch.is_on: modeauto
              - binary_sensor.is_on: tempok
              - lambda: 'return id(striac) >= id(pmin).state;'
          then:
              - light.turn_on:
                  id: gradateur
                  brightness: !lambda |-
                    return id(striac)/100 ;
      # Si mode routeur devalidé ou temp NOK alors on désactive le triac 
      - if: 
          condition:
              or:
                - switch.is_off: val_router
                - binary_sensor.is_off: tempok                    
          then:
            - lambda: |-
                id(striac) = 0;
                id(increment) = 0;
            - light.turn_on:
                id: gradateur
                brightness: !lambda |-
                  return id(0) ;  

# -------------------------------------------  Pilotage led
  - id: etat_production
    mode: single
    then:
     - if: 
         condition:
           sensor.in_range:
              id: pureseau1
              below: 50
              above: -50
         then:
           - output.turn_on: led_conso
           - output.turn_on: led_injec
                
     - if: 
         condition:
           sensor.in_range:
             id: pureseau1
             above: 50
         then:
           - output.turn_off: led_injec
           - output.turn_on: led_conso

     - if: 
         condition:
           sensor.in_range:
             id: pureseau1
             below: -50
         then:
          - output.turn_off: led_conso
          - output.turn_on: led_injec

Paramètres:

Vous pouvez régler:

• La puissance maximum que peut délivrer le triac. Je l’ai limité à 80% ce qui correspond à 2000 W dans mon cas (Ballon ECS de 300l). Pour l’estimer au mieux, passer en mode MANUEL et augmenter progressivement la sortie triac tout en visualisant l’intensité absorbée par l’ECS, perso je me limite à 10/11A. Au delà le triac monte trop en température.
• la puissance minimum: Valeur en dessous laquelle le triac ne donne rien
• le coefficient R (réactivité): Voir explication dans « Principe de Fonctionnement ».
• la température maximum du refroidisseur du triac: Si supérieure à ce seuil, met la sortie triac à 0%.

Vous pouvez piloter:

• Le relais: Je ne l’utilise pas pour l’instant
• La validation du routeur: dans mon cas, c’est un automatisme qui valide la routeur quand la charge des batteries est quasi à 100%
• Un mode Manuel/Auto: Manuel vous donne la possibilité de piloter la sortie triac.
• Le triac.

Grandeurs physiques:

Vous retrouverez:

• Dans mon cas j’affiche la température de l’ECS, mesurée avec un autre ESP.
• La puissance soutirée ou injectée sur le réseau.
• La puissance et l’intensité de l’ECS.
• La valeur de l’incrément.
• La sortie Triac.
• L’énergie soutirée par l’ECS sur le réseau.
• L’énergie économisée par le routeur par jour et totale. L’énergie par jour est calculé dans une entrée HA: voir mon article https://domo.rem81.com/2022/06/06/ha-compteur-de-service-utility-meter/.
• L’état du binary-sensor: température Ok.
• La température du triac.

Automatisation:

La validation du router dépend de votre configuration: Si votre installation solaire ne comporte pas de batteries, vous pouvez vous inspirer de cet article https://domo.rem81.com/2022/11/25/ha-gestion-eau-chaude-sanitaire/. Depuis cet article, mon installation PV a évoluée avec l’ajout de batteries de stockage, depuis leur mise en service je valide le routeur lorsque les batteries sont chargées.Voici le code de cette automatisation pour information:

alias: 01-2-4 ECS Validation Routeur sur Absorption V2
description: float alors routeur ECS Actif
trigger:
  - platform: time_pattern
    minutes: /1
condition: []
action:
  - choose:
      - conditions:
          - condition: numeric_state
            entity_id: sensor.mp2_status_bus_ve
            above: 3
            below: 6
            enabled: true
          - condition: state
            entity_id: input_boolean.ecs_av_pv
            state: "off"
          - condition: numeric_state
            entity_id: sensor.mp2_pc_ac_couplet_on_l1
            above: 1000
          - condition: numeric_state
            entity_id: sensor.mp2_niveau_charge_batteries
            above: input_number.mp2_seuil_validation_routeur
            enabled: false
        sequence:
          - service: input_boolean.turn_on
            data: {}
            target:
              entity_id: input_boolean.ecs_av_pv
          - service: switch.turn_on
            data: {}
            target:
              entity_id:
                - switch.esp176_validation_router
          - service: notify.telegram
            data:
              message: >-
                Bus VE={{states('sensor.mp2_affichage_status_bus_ve')}}
                {{-"\n"-}}SOC={{states('sensor.mp2_niveau_charge_batteries')}}%
                {{-"\n"-}}{{states("sensor.date_time") }}
              title: Validation Routeur ECS
      - conditions:
          - condition: not
            conditions:
              - condition: numeric_state
                entity_id: sensor.mp2_status_bus_ve
                above: 3
                below: 6
            enabled: true
          - condition: state
            entity_id: input_boolean.ecs_av_pv
            state: "on"
          - condition: numeric_state
            entity_id: sensor.mp2_niveau_charge_batteries
            below: input_number.mp2_seuil_devalidation_routeur
            enabled: false
        sequence:
          - service: input_boolean.turn_off
            data: {}
            target:
              entity_id: input_boolean.ecs_av_pv
          - service: switch.turn_off
            data: {}
            target:
              entity_id:
                - switch.esp176_validation_router
          - service: notify.telegram
            data:
              message: >-
                Bus VE={{states('sensor.mp2_affichage_status_bus_ve')}}
                {{-"\n"-}}SOC={{states('sensor.mp2_niveau_charge_batteries')}}%
                {{-"\n"-}}{{states("sensor.date_time") }}
              title: De-Validation Routeur ECS
mode: single
trace:
  stored_traces: 10

Affichage Local:

Localement j’affiche:

• Pr: Puissance sur le réseau (sortie Linky)
• Pe: Puissance Absorbée par le ballon ECS
• Tr: Valeur pilotage triac
• Val: Routeur Validée
• Tp: Température triac
• Etat: OK si Température Triac inférieur au seuil sinon NOK
• Mode: Automatique ou Manuel
• Inc: Valeur de l’increment
• LED Rouge et Jaune allumées: Puissance Réseau entre -50 et 50 W
• LED Rouge allumée et Jaune éteinte: On rejette plus de 50 W sur le réseau
• LED Rouge éteinte et Jaune allumée: On soutire plus de 50 W sur le réseau
• LED Verte allumée: Coffret sous tension

Résultats:

La courbe ci dessous (extraite de Graphana) illustre l’efficacité et la réactivité du routeur. Ce jour là, à partir de 16:40 l’ECS ne chauffe plus, il a atteint ses 70°C, conclusion: on injecter sur le réseau.

Le graphique suivant illustre les économies réalisées en kWh, les jours à 0 sont dû à un faible ensoleillement, dans mon cas je privilégie la charge des batteries avant de router vers l’ECS.

Liens vers des routeurs à monter soi-même:

Bien entendu cette liste est non exhaustive, si vous avez d’autres liens, n’hésiter pas à me les transmettre, je les ajouterai.

• Le Prof’Solaire.
• Association P’TIWATT (celui que j’ai longtemps utilisé)
• Le Routeur/Dimmer de Cyril
• Les bidouilleurs Solaire
• pvrouteur pour les nuls
• F1ATB
• MaxPv
• Mk2PVrouter

Conclusion

Un routeur solaire de plus! Celui ci est complément intégré à Home Assistant, et en plus il coûte pas trop cher. N’hésitez par me faire par de vos remarques.