Home Assistant et Modbus pour votre pompe à chaleur

Alors, qu’est-ce qu’on bricole aujourd’hui !? Home Assistant permet de récupérer des informations avec le vénérable protocole Modbus. Si l’on couple ça aux possibilités offertes par une pompe à chaleur de la marque Dimplex comme la nôtre, ça devient vite très intéressant.

Grâce à cette intégration un peu magique, on peut remonter des dizaines d’informations de sa pompe à chaleur afin de déchiffrer son fonctionnement et conserver un peu d’historiques dans Home Assistant…

Le Modbus, c’est quoi au juste ?

Le Modbus est un protocole de communication qui date de plusieurs décennies déjà et qui refuse de prendre sa retraite… Il permet à différents appareils de discuter entre eux via différentes possibilités : le RS485 pour Modbus RTU ou du TCP/IP pour Modbus TCP (celui qu’on utilise ici). Concrètement, c’est une façon simple et robuste pour de nombreux appareils électroniques du monde industriel, comme la régulation d’une pompe à chaleur, d’échanger des données ou de se faire piloter. Probablement, vous ne le savez pas, mais ça existe sur beaucoup d’équipements : onduleurs, bornes de recharge, chauffage…

Home Assistant prend en charge le Modbus nativement, sans avoir besoin d’extensions exotiques sorties d’on ne sait pas où sur Internet. Il suffit d’un peu de configuration et d’un accès aux bons registres Modbus (oui, on les trouve après la lecture de beaucoup de documentations généralement…) pour commencer à récupérer et envoyer des informations. Un jeu d’enfant, ou du moins un truc amusant pour les gens pas tout câblé comme les autres qui aiment ce type de passe-temps 🤓…

Modbus avec Dimplex

Dans les éléments très importants pour débuter avec le Modbus, il est nécessaire de se documenter sur toutes les valeurs et positions possibles de l’intégration. Cela signifie que, dans notre cas, Dimplex publie une documentation en ligne avec toutes les valeurs. On appelle ça les « registres ».

Les documentations Dimplex sont très (très) complètes et sont disponibles en ligne en suivant ce lien. Il est important de comprendre que les valeurs peuvent varier en fonction du contexte et que de trouver les bonnes informations peut vite prendre beaucoup de temps dans le cas d’un système complexe, comme une pompe à chaleur.

Les informations fournies par Dimplex permettent de connaitre l’utilité du registre, sa position identifiée par un nombre, le type de données, si c’est une valeur qu’on peut uniquement lire ou si on peut aussi l’écrire pour la modifier (R/W) et pour finir son unité (par exemple des degrés Celsius).

Découverte de l’intégration

Ce n’est pas habituel, mais je vais commencer par vous montrer le résultat dans l’interface d’Home Assistant. On regardera ensuite seulement comment ça se configure. Histoire de vous donner un peu envie de bricoler aussi et de vous lancer dans la découverte de ces possibilités, que ça soit avec une pompe à chaleur ou des équipements Modbus en général…

températures de consigne

Dans la documentation, il est facile de trouver les registres qui nous permettent de trouver les consignes données par la régulation de la pompe à chaleur. Les consignes sont les « valeurs », dans notre cas, une température en degré Celsius, que doit atteindre la pompe à chaleur pour répondre à un besoin en eau chaude, comme le chauffage ou l’eau chaude sanitaire.

Dans cette première capture d’écran, nous pouvons voir le graphique historique de la température à laquelle la pompe à chaleur doit chauffer l’eau chaude sanitaire (en bleu) et la température de retour de l’eau de chauffage. Dans le cas de cette pompe à chaleur, il s’agit du circuit de chauffe principal.

Donc on voit que l’eau chaude doit être configurée à 48°C et que la valeur est fixe. Cependant, la valeur du circuit de chauffe principal varie dans la journée. Pourquoi me direz-vous, ben on va voir ça au chapitre suivant !

Température extérieure

Notre pompe à chaleur Dimplex utilise une régulation connectée à un thermostat extérieur. Cela permet à la pompe à chaleur de calculer la température de retour idéal en fonction des différentes courbes de chauffe. Je ne suis pas un spécialiste en PAC, mais en gros, la courbe de chauffe est calculée par la régulation en fonction de la puissance de chauffe que vous avez configurée et de la température extérieure. Plus il fait froid dehors, plus la température de consigne du circuit de chauffe primaire de notre PAC sera élevée.

Il existe d’autres moyens de réguler sa pompe à chaleur, il est possible d’utiliser un thermostat central placé à un endroit stratégique de la maison ou de fixer la courbe de chauffe pour qu’elle ne fluctue pas en fonction de température. Bref, dans mon cas, c’est la température extérieure et la puissance que je configure sur la PAC qui fait fluctuer la consigne du circuit de chauffe.

Donc, pour donner du sens à la consigne de chauffe, nous pouvons ajouter au graphique historique la valeur du thermostat extérieur avec la courbe en rouge sur le schéma. On constate que la température augmente en journée, principalement entre 12 h et 16 h. La consigne de chauffage baisse doucement avant de remonter quand la température extérieure recommence à baisser.

Température de l’eau chaude sanitaire

Maintenant que l’on a vu les températures de consigne de chauffe et comment la courbe est influencée par la température extérieure ou la puissance réglée de la PAC, nous pouvons commencer avec la première température réelle : l’eau chaude sanitaire.

En vert, nous pouvons trouver désormais la température réelle de l’eau chaude sanitaire. Alors, on peut constater la première spécialité de notre installation : celle-ci ne suit pas la température de consigne. Mais pourquoi donc me direz-vous ? C’est assez simple, notre pompe à chaleur est configurée pour ne pas produire d’eau chaude sanitaire en dehors des heures d’ensoleillement… C’est-à-dire que, sur la régulation de la PAC, j’ai configuré des heures de blocage où elle n’est pas autorisée. On constate qu’elle peut produire de l’eau chaude uniquement à partir de 10h30, moment à partir duquel l’ensoleillement est suffisant à notre domicile pour couvrir toute la puissance électrique de notre pompe à chaleur avec notre énergie solaire.

Température du circuit de chauffe principal

Un des derniers éléments que j’ai ajouté au graphique historique d’Home Assistant étant la température du circuit de chauffe primaire. C’est-à-dire la vraie température à laquelle la pompe à chaleur travaille pour respecter les deux consignes que l’on a vues plus haut.

Cette nouvelle courbe affichée en violet permet de voir comment fonctionne la pompe à chaleur pour respecter les valeurs de consigne. Avec ce graphique on peut découvrir ce qu’on appelle l’hystérésis : l’hystérésis est une marge de tolérance autour de la température cible de retour qui évite à la pompe à chaleur de s’allumer et s’éteindre sans arrêt. Plutôt que de réagir au moindre écart, on définit une plage de tolérance, ce qui permet d’optimiser son fonctionnement et d’éviter qu’elle ne joue les yoyos énergivores.

Un autre élément que l’on constate c’est que le circuit de chauffage (le collecteur) est fermé durant la nuit dans la plupart des pièces de notre logement. Ce qui entraine le phénomène de courbe très plate jusqu’à ce que les collecteurs s’ouvrent à nouveau le matin (vers 5h) pour chauffer les pièces. C’est un mécanisme que je vous explique dans un autre article où j’ai repris le contrôle de notre chauffage au sol avec l’aide des produits d’Homematic IP : les profils de chauffage.

État de fonctionnement de la pompe à chaleur

Maintenant que j’ai fini de m’amuser avec les températures, je me suis intéressé à autre chose : l’état de fonctionnement de la pompe à chaleur. C’est-à-dire que l’on peut récupérer en Modbus toujours les indications sur ce que fait la PAC à un moment donné pour bien comprendre son fonctionnement. Avec cette information que l’on trouve dans la documentation Dimplex, on peut savoir si la PAC chauffe l’eau sanitaire, le chauffage ou… ne fait rien ! Hyper intéressant pour comprendre l’ensemble de son système de chauffage et croiser les informations avec les températures dans les pièces :

En gros, dans mon cas, j’ai récupéré toutes les informations que je voyais passer. C’est un peu plus compliqué que récupérer une température. Mais en gros, ça permet de savoir quand la PAC ne fait rien, chauffe l’eau sanitaire, dégivre ou allume la pompe de circulation.

Si l’on zoome sur une période un peu plus précise, l’information deviendra un peu plus claire que sur l’image d’une vue 24h comme je vous présente ci-dessus.

Dans cette image ci-dessus, on peut constater quand la pompe à chaleur est éteinte (Off) et quand elle produit de l’eau chaude sanitaire (Hot water) en rouge/orange.

Si on regarde un peu plus tard dans la soirée, on peut constater les différents cycles liés au chauffage en rose. En gros, on peut voir que la PAC chauffe une fois par heure.

On peut ensuite mixer cette information avec les courbes historiques de températures que l’on a vues dans les chapitres précédents et nous gagnons ainsi une très belle vision du fonctionnement de sa pompe à chaleur : la température extérieure baisse (en rouge), la consigne de chauffe augmente (en jaune) et la pompe à chaleur chauffe toujours plus chaud le circuit de chauffe primaire (en bleu). Il est simple ensuite de croiser l’information entre le premier et le diagramme de fonctionnement et l’historique des températures.

L’hystérésis se charge ensuite d’éviter d’enclencher trop souvent la PAC et produit ces petites vagues bleues. Elle va chauffer plus fort que la consigne et attendre de baisser suffisamment en dessous de celle-ci avant de démarrer à nouveau la PAC.

Configurer le Modbus dans Home Assistant

Maintenant que je vous ai bien donné envie de vous amuser aussi, vous allez me demander comment tout cela se configure dans Home Assistant n’est-ce pas petit malin ?! Allez, étant donné que je suis de bonne humeur, je vais tout vous partager… vous me paierez un café à l’occasion. Pour débuter, je pars du principe que vous avez déjà installé un mode Home Assistant comme File Editor et que ce n’est pas la première fois que vous éditez le fichier de configuration.yaml principal de ce dernier.

Configuration de base

Pour configurer le Modbus, vous n’avez pas besoin d’installer une intégration supplémentaire. Il suffit d’éditer la configuration dans le fichier configuration.yaml. Pour débuter, vous devez ajouter une section « modbus » :

modbus:
  - name: "dimplex_modbus"
    type: tcp
    host: "x.x.x.x"
    port: 502

Définissez un nom pour cette configuration Modbus (parce que vous pouvez en utiliser autant que vous le souhaitez), le protocole (ici le TCP), l’adresse IP et le port Modbus utilisé par votre appareil. Dans le cas de la pompe à chaleur Dimplex, tout est très standard et c’est bien évidemment l’exemple de configuration que je vais vous proposer.

Ajouter des valeurs à récupérer

Continuons avec notre exemple Dimplex. Nous allons désormais récupérer une première information que vous allez pouvoir utiliser comme exemple. Je vous donne plus bas l’ensemble de la configuration que j’utilise :

modbus:
  - name: "dimplex_modbus"
    type: tcp
    host: "x.x.x.x"
    port: 502
    sensors:
      - name: "Dimplex Outside Temperature"
        address: 1
        device_class: temperature
        unit_of_measurement: "°C"
        scale: 0.1
        data_type: int16
        precision: 1

Après la configuration initiale que je vous ai présentée plus haut, nous allons ajouter le premier « sensors » Home Assistant. On peut voir ici qu’il s’agit de la température extérieure de la pompe à chaleur. Celle-ci utilise le registre Modbus « 1 » que l’on définit dans la valeur « address ».

Il faut ensuite indiquer à Home Assistant comment interpréter cette information. Il s’agit d’une valeur de type température (device_class), exprimée en degrés Celsius (unit_of_measurement). Cette valeur nous est donnée avec une échelle (scale) de 0.1, ce qui signifie qu’elle doit être divisée par 10 pour obtenir la température réelle.

Il reste ensuite deux paramètres : le type de données (data_type) et la précision (precision). Le type de données est défini comme un entier signé 16 bits (int16), ce qui correspond à une plage allant de -32 768 à 32 767 (comme indiqué dans la documentation Dimplex). Quant à la précision (precision), elle est de 1 chiffre après la virgule, ce qui signifie que la température sera alors arrondie à une décimale seulement. C’est bon vous avez tout compris 😁 🤯 ?

Exemple pour les températures

Étant donné que je sais depuis le temps que vous êtes flemmards et que vous aimez les trucs tout prêts, je vous donne ci-dessous le code complet de mon intégration Dimplex pour les températures. Comme toujours, ce n’est pas parce que ça fonctionne chez moi que ça va aussi fonctionner chez vous, alors n’hésitez pas à chercher et corriger…

Les valeurs récupérées depuis les registres sont les suivantes dans mon exemple plus haut :

Registre	Description
1	Température extérieure
2	Température de retour
3	Température de l’eau chaude sanitaire
53	Température de retour cible (la consigne)
58	Température de retour cible de l’eau chaude sanitaire (la consigne mais de l’eau chaude sanitaire)

modbus:
  - name: "dimplex_modbus"
    type: tcp
    host: "x.x.x.x"
    port: 502
    sensors:
      - name: "Dimplex Outside Temperature"
        address: 1
        device_class: temperature
        unit_of_measurement: "°C"
        scale: 0.1
        data_type: int16
        precision: 1
      - name: "Dimplex Return Temperature"
        address: 2
        device_class: temperature
        unit_of_measurement: "°C"
        scale: 0.1
        data_type: int16
        precision: 1
      - name: "Dimplex Hot Water Temperature"
        address: 3
        device_class: temperature
        unit_of_measurement: "°C"
        scale: 0.1
        data_type: int16
        precision: 1
      - name: "Dimplex Target Return Temperature"
        address: 53
        device_class: temperature
        unit_of_measurement: "°C"
        scale: 0.1
        data_type: int16
        precision: 1
      - name: "Dimplex Target Hot Water Temperature"
        address: 58
        device_class: temperature
        unit_of_measurement: "°C"
        scale: 0.1
        data_type: int16
        precision: 1

Exemple pour le capteur d’état

Pour le capteur d’état, c’est un peu différent, car la valeur qui est retournée est uniquement numérique. On doit ensuite configurer dans Home Assistant un « template » afin de créer une table de correspondance. Nous utilisons ici un seul sensor qui ira recherche la valeur numérique du registre « 43 », mais nous allons ensuite créer un nouveau template pour donner une valeur textuelle à ces nombres :

Valeur retournée	Description (francais 🇫🇷 /anglais 🇬🇧)
0	Off / Eteinte
1-2	Heating / Chauffage
4	Hot water / Eau chaude sanitaire
8	Primary pump / Pompe primaire
15	Cycle protection / Protection des cycles (éviter trop d’enclenchements sur des cycles courts)
18	Flow monitoring / Surveillance du débit
21	Defrost / Dégivrage
… autre chose	Unknow : value / Inconnu : valeur (en gros affiche la valeur numérique quand on n’a pas de correspondance)

Dans l’exemple ci-dessous, je stocke la valeur numérique brute dans le sensor que j’ai appelé « Dimplex System State Raw » et je créais ensuite le sensor qu’on utilisera plus haut pour afficher les données « Dimplex System State » avec l’intégration Homme Assistant « template ».

modbus:
  - name: "dimplex_modbus"
    type: tcp
    host: "x.x.x.x"
    port: 502
    sensors:
      - name: "Dimplex System State Raw"
        address: 43
template:
  - sensor:
      - name: "Dimplex System State"
        state: >
          {% if states('sensor.dimplex_system_state_raw')|int == 0 %}
            Off
          {% elif states('sensor.dimplex_system_state_raw')|int == 1 %}
            Heating
          {% elif states('sensor.dimplex_system_state_raw')|int == 2 %}
            Heating
          {% elif states('sensor.dimplex_system_state_raw')|int == 4 %}
            Hot Water
          {% elif states('sensor.dimplex_system_state_raw')|int == 8 %}
            Primary pump
          {% elif states('sensor.dimplex_system_state_raw')|int == 15 %}
            Cycle protection
          {% elif states('sensor.dimplex_system_state_raw')|int == 18 %}
            Flow monitoring
          {% elif states('sensor.dimplex_system_state_raw')|int == 21 %}
            Defrost
          {% else %}
            Unknown: {{ states('sensor.dimplex_system_state_raw') }}
          {% endif %}

Exemple complet avec les températures et le capteur d’état

Et pour finir, l’exemple complet avec toute ma configuration d’exemple que je vous ai présentée, mais sans aucun commentaire ni description parce qu’on vient un peu de le faire dans les chapitres précédents :

modbus:
  - name: "dimplex_modbus"
    type: tcp
    host: "x.x.x.x"
    port: 502
    sensors:
      - name: "Dimplex Outside Temperature"
        address: 1
        device_class: temperature
        unit_of_measurement: "°C"
        scale: 0.1
        data_type: int16
        precision: 1
      - name: "Dimplex Return Temperature"
        address: 2
        device_class: temperature
        unit_of_measurement: "°C"
        scale: 0.1
        data_type: int16
        precision: 1
      - name: "Dimplex Hot Water Temperature"
        address: 3
        device_class: temperature
        unit_of_measurement: "°C"
        scale: 0.1
        data_type: int16
        precision: 1
      - name: "Dimplex System State Raw"
        address: 43
      - name: "Dimplex Target Return Temperature"
        address: 53
        device_class: temperature
        unit_of_measurement: "°C"
        scale: 0.1
        data_type: int16
        precision: 1
      - name: "Dimplex Target Hot Water Temperature"
        address: 58
        device_class: temperature
        unit_of_measurement: "°C"
        scale: 0.1
        data_type: int16
        precision: 1

template:
  - sensor:
      - name: "Dimplex System State"
        state: >
          {% if states('sensor.dimplex_system_state_raw')|int == 0 %}
            Off
          {% elif states('sensor.dimplex_system_state_raw')|int == 1 %}
            Heating
          {% elif states('sensor.dimplex_system_state_raw')|int == 2 %}
            Heating
          {% elif states('sensor.dimplex_system_state_raw')|int == 4 %}
            Hot Water
          {% elif states('sensor.dimplex_system_state_raw')|int == 8 %}
            Primary pump
          {% elif states('sensor.dimplex_system_state_raw')|int == 15 %}
            Cycle protection
          {% elif states('sensor.dimplex_system_state_raw')|int == 18 %}
            Flow monitoring
          {% elif states('sensor.dimplex_system_state_raw')|int == 21 %}
            Defrost
          {% else %}
            Unknown: {{ states('sensor.dimplex_system_state_raw') }}
          {% endif %}

Un script Python pour tester

Pour comprendre comment fonctionnait tout ce bousier système, j’ai bricolé très rapidement quelques scripts en Python permettant de récupérer les informations de notre pompe à chaleur sans utiliser Home Assistant. Le but principal était de comprendre quelles sont les valeurs auxquelles je devais m’attendre avant d’essayer dans Home Assistant, car ce dernier a tendance à tout conserver, même si c’est supprimé de la configuration. C’est donc pas très pratique pour bricoler sans risque de casser des trucs si on n’a qu’un seul Home Assistant et pas un deuxième dédié aux tests (vous arrêtez tout de suite et je vous invite à ne pas vous foutre de moi, non, je n’ai pas une instance de « non production » 🥺).

Ci-dessous je vous partage un petit script qui permet de chercher toutes les valeurs d’un appareil Modbus, un registre après l’autre. Dans le script, une première partie contient l’adresse IP de l’appareil à scanner ainsi que le registre de début et le registre de fin. On peut ensuite chercher dans la documentation à quoi correspond la valeur inscrite pour un registre donné.

import time
from pymodbus.client import ModbusTcpClient

# Configuration
ip_address = "x.x.x.x"  # Adresse IP de la pompe
port = 502  # Port Modbus TCP
start_address = 1  # Adresse de début du scan
end_address = 1000  # Adresse de fin du scan

# Connexion au client Modbus TCP
client = ModbusTcpClient(host=ip_address, port=port)

if client.connect():
    print(f"Connexion réussie à {ip_address}:{port}")
    print(f"Début du scan des registres de {start_address} à {end_address}...\n")

    for address in range(start_address, end_address + 1):
        try:
            # Lecture d'un registre à l'adresse spécifiée
            response = client.read_holding_registers(address=address, count=1)
            if response.isError():
                print(f"Registre {address} : Erreur de lecture")
            else:
                value = response.registers[0]
                print(f"Registre {address} : {value}")
        except Exception as e:
            print(f"Registre {address} : Exception ({e})")

        # Pause de 1 seconde entre les lectures
        time.sleep(1)

    # Déconnexion
    client.close()
    print("\nScan terminé.")
else:
    print(f"Échec de la connexion à {ip_address}:{port}")

Dans tous mes tests, j’ai de nombreux autres scripts pour extraire d’autres informations, mais ils ne sont pas assez propres pour être partagés et je n’ai pas trop l’envie de passer du temps dessus encore 😅 : récupérer la version du régulateur Dimplex, extraire les caractéristiques de configurations (comme les modes hiver, été, vacances,…) ou encore les durées de fonctionnement des composants de la pompe à chaleur (pompe, compresseur,…).

Modbus et optimisation solaire

Un dernier élément que je n’ai pas encore entièrement testé, mais qui est relativement facile à faire avec Home Assistant : augmenter la température des consignes quand la production solaire est suffisante. Comme indiqué un peu plus haut, le Modbus ne permet pas que de lire des informations, mais il peut aussi écrire des valeurs.

En utilisant les automatisations dans Home Assistant, on peut imaginer changer la température de consigne de l’eau chaude sanitaire, par exemple quand la production solaire est suffisante. Je n’ai pas creusé cet aspect pour le moment, car je le fais actuellement avec Solar Manager et j’en suis très satisfait.

Ci-dessus on peut d’ailleurs voir quand Solar Manager augmente la consigne de l’eau chaude sanitaire sur la courbe jaune. En temps normal, la consigne est fixée à 48°C et on voit que Solar Manager booste celle-ci avec une valeur de 52.6°C entrainant un stockage d’énergie solaire sous forme d’eau chaude.

Voilà, c’est tout pour aujourd’hui ! En espérant que cet article vous a intéressé et vous a permis de comprendre autant les possibilités offertes par Home Assistant que par le Modbus… 😊