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:

• 26/03/2024 – V1.2.0: Ajout calcul relais de suproduction
• 25/03/2024 – V1.1.0: Nettoyage du code: Suppression Switch val routeur et Pmin
• 01/08/2023 – V1.0.0: 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.

• Un relais de délestage de surproduction:
  • Un SSR

• Ou un relais Tout ou Rien 5V:

• Vous pouvez aussi acheter ce type de platine comprenant l’alimentation 220, le relais: voir mon article sur à ce sujet

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 bon 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.2.0"
  on_boot:
    priority: 800
    # Force mode auto et temperature ok au demarrage
    then: 
      - switch.turn_on: modeauto
      - binary_sensor.template.publish:
          id: temperatureok
          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
  # level: INFO

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"

# Temperature triac OK
  - platform: template
    name: "${friendly_name} Temp Ok"
    id: temperatureok

# Validation du routeur à déclarer dans HA
  - platform: homeassistant
    name: "Validation Routeur"
    entity_id: "input_boolean.inter_validation_routeur"
    id: val_routeur    

# Input Number
number:
  # Seuil 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

# 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: 10
    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

# FP 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 );
            }

    
# 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: temperatureok
                state: ON
        # Sinon attendre 60s avant retour à la normal
          else:
            - binary_sensor.template.publish:
                id: temperatureok
                state: OFF
            - delay: 60s
 
switch:
  - platform: gpio
    name: "${friendly_name} Relais"
    pin: GPIO5
    id: relais

  - 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_routeur).state ? "OK" : "NOK");
      it.printf(0,2,"Tp=%0.1fc", id(temp_triac).state);
      it.printf(10,2,"Etat=%s", id(temperatureok).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: 1s
    then:
      - script.execute: calcul_injection

  - interval: 2s
    then:
      - script.execute: etat_production 

# Script activation relais si le triac est au max pendant x sec
  - interval: 60s
    then:
      - script.execute: calcul_relais_surprod      

# ------------------------  Scripts
script:
# 
# ------------------------ Calcul puissance injection 
  - id: calcul_injection
    mode: single
    then:
      - lambda: |-
         id(increment) = id(pureseau1).state*id(coeff_r).state/1000*-1;
 
      - lambda: |-
         id(striac) = id(striac)+id(increment);            
               
          if (!isnan(id(striac))) {
            id(striac) = id(striac)+id(increment);
          }else{
            id(striac)=0;
            }

          if (id(striac) <= 0){
            id(striac) = 0;
          } else if(id(striac)>=id(pmax).state){
            id(striac) = id(pmax).state;
          }        
      - logger.log:
          format: "Log S Triac %f - Increment %f"
          args: [ 'id(striac)', 'id(increment)' ]
          level: "info"
      

      # Si Routeur Validé et mode auto et temperature ok alors on active le triac
      - if: 
          condition:
            and:
              - binary_sensor.is_on: val_routeur
              - switch.is_on: modeauto
              - binary_sensor.is_on: temperatureok
        

          then:
              - light.turn_on:
                  id: gradateur
                  brightness: !lambda |-
                    return id(striac)/100 ;
              - logger.log:
                  format: "Log Auto OK STriac %f - Increment %f"
                  args: [ 'id(striac)', 'id(increment)' ]
                  level: "info"         

      # Si mode routeur devalidé ou temp NOK alors on désactive le triac 
      - if: 
          condition:
            and:
              - switch.is_on: modeauto
              - or:
                - binary_sensor.is_off: val_routeur
                - binary_sensor.is_off: temperatureok                    
                   
          then:
            - lambda: |-
                id(striac) = 0;
                id(increment) = 0;
            - light.turn_off: gradateur
            - logger.log:
                format: "Log Auto NOk STriac %f - Increment %f"
                args: [ 'id(striac)', 'id(increment)' ]
                level: "info"                         


      # Si mode routeur manu
      - if: 
          condition:
            and:
              - switch.is_off: modeauto
          then:
            - lambda: |-
                id(striac) = 0;
                id(increment) = 0;
            - logger.log:
                format: "Log Manu STriac %f - Increment %f"
                args: [ 'id(striac)', 'id(increment)' ]
                level: "info"                         
    # Affichage STriac et Increment
      - lambda: |-
            id(afstriac).publish_state( id(striac) );
            id(afincrement).publish_state( id(increment) );

      - logger.log:
          format: "Log Fin STriac %f - Increment %f"
          args: [ 'id(striac)', 'id(increment)' ]
          level: "info"

# -------------------------------------------  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

# Calcul du relais de surproduction
  - id: calcul_relais_surprod
    mode: single
    then:
     # Si sortie triac > pmax-5%, ce qui signifie que le triac est au max sans effet, pendant plus de 30s
     # alors on active le relais
     # si triac <= 0 alors on desactive le relais
      - if: 
          condition:
            - lambda: 'return id(striac)>=id(pmax).state-5;'
          then:
            - delay: 30s
            - switch.turn_on: relais
            - logger.log: "Relais Activé"
      - if: 
          condition:
            - lambda: 'return id(striac)<=0;'
          then:
            - switch.turn_off: relais
            - logger.log: "Relais Désctivé"
      
    
    

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:

• L’interrupteur de validation du routeur: Déclaré et programmé dans HA
• Définir le seuil PMAX pour ne pas trop solliciter le TRIAC
• Définir le coefficient R (Réactivité)
• Définir la Température MAX du triac
• Le relais de délestage
• 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, voir cet article.
• 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ée 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:

Le fonctionnement routeur est validé par un input_number déclaré dans HA.

La validation du routeur 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.

Plus simplement, vous pouvez le valider entre le levé et le couché du soleil.

Relais Delestage:

Dans mon programme, j’utilise le GPIO5 mais d’autres GPIO sont disponibles pour cet usage, cet article les décrits parfaitement.

Toutes les minutes, on teste si le triac est au maximum pendant plus de 30s alors on active le relais de délestage sinon on le désactive

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’incrementCapture d’écran du 2024-03-26 11-28-57
• 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 15:45 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.