Collecte et visualisation de données Modbus TCP

Dernière mise à jour: 2026-10-16

Introduction

Modbus est un protocole courant en automatisation industrielle pour lire les données des automates, compteurs et autres appareils industriels. L’intégration Modbus de Home Assistant transforme les valeurs des registres en entités de capteurs et affiche leur état et leur historique dans une interface web.

Ce tutoriel utilise reComputer RK3576 et Home Assistant Container pour lire la température et l’humidité via Modbus TCP et créer un tableau de bord de surveillance. Pour faciliter la reproduction, un simulateur Python Modbus TCP s’exécute localement sur RK3576, sans automate ni capteur supplémentaire.

Architecture

Python Modbus TCP simulator
     127.0.0.1:1502
            ↓
     reComputer RK3576
            ↓
 Home Assistant Container
            ↓
 Live temperature/humidity / history graphs

Préparation

Matériel

• Un reComputer RK3576 sous Linux ARM64.
• Un ordinateur Windows, macOS ou Linux pouvant accéder à RK3576 par SSH et dans un navigateur.
• Un réseau local permettant d’accéder à RK3576.

Cet exemple utilise Modbus TCP et ne dépend pas de l’interface RS485 de RK3576.

Logiciels

Terminez d’abord le déploiement Docker et la configuration initiale de Installer Home Assistant sur reComputer RK3576. Vérifiez l’environnement :

python3 --version
sudo docker ps --filter name=homeassistant
sudo docker inspect homeassistant --format '{{.HostConfig.NetworkMode}}'

Le mode réseau doit être host. Le conteneur peut ainsi accéder au simulateur sur 127.0.0.1:1502 de l’hôte RK3576.

Créer une source de données Modbus TCP

Étape 1 : Écrire le simulateur Python

Connectez-vous à RK3576 par SSH. Copiez la commande entière dans le terminal pour créer ~/modbus_demo.py dans le dossier personnel de l’utilisateur actuel :

cat > ~/modbus_demo.py <<'PY'
import math
import socketserver
import struct
import time


class ModbusHandler(socketserver.BaseRequestHandler):
    def read_exact(self, size):
        data = b""
        while len(data) < size:
            chunk = self.request.recv(size - len(data))
            if not chunk:
                return None
            data += chunk
        return data

    def handle(self):
        try:
            while True:
                header = self.read_exact(7)
                if not header:
                    break

                tid, pid, length, unit = struct.unpack(">HHHB", header)
                if pid != 0 or not 2 <= length <= 254:
                    break

                request = self.read_exact(length - 1)
                if not request:
                    break

                function = request[0]
                if function == 3 and len(request) == 5:
                    address, count = struct.unpack(">HH", request[1:])

                    if count < 1 or count > 2 or address + count > 2:
                        response = bytes([0x83, 2])
                    else:
                        temperature = round(
                            (25 + 2 * math.sin(time.monotonic() / 20)) * 10
                        )
                        humidity = round(
                            (60 + 10 * math.sin(time.monotonic() / 30)) * 10
                        )
                        registers = [temperature, humidity]
                        response = bytes([3, count * 2]) + b"".join(
                            struct.pack(">H", value)
                            for value in registers[address:address + count]
                        )
                else:
                    response = bytes([function | 0x80, 1])

                reply = struct.pack(">HHHB", tid, 0, len(response) + 1, unit) + response
                self.request.sendall(reply)
        except (OSError, ConnectionError):
            pass


class ModbusServer(socketserver.ThreadingTCPServer):
    allow_reuse_address = True
    daemon_threads = True


with ModbusServer(("127.0.0.1", 1502), ModbusHandler) as server:
    print("Modbus TCP server running at 127.0.0.1:1502", flush=True)
    server.serve_forever()
PY

Le simulateur prend en charge le code de fonction 03 pour lire les registres de maintien :

Home Assistant utilise scale: 0.1 pour convertir les valeurs brutes en degrés Celsius et pourcentages. Les valeurs évoluent pour démontrer la surveillance en direct.

Étape 2 : Exécuter le simulateur

Démarrez le simulateur :

nohup python3 ~/modbus_demo.py > ~/modbus_demo.log 2>&1 &

Vérifiez qu’il écoute :

ss -lntp | grep ':1502'
cat ~/modbus_demo.log

Vous devez voir l’adresse d’écoute 127.0.0.1:1502 et ce message :

Modbus TCP server running at 127.0.0.1:1502

Cette démonstration s’exécute en arrière-plan avec nohup. Après le redémarrage de RK3576, relancez la commande de démarrage. Vérifiez le port avant de démarrer pour éviter les instances en double.

Configurer Modbus TCP dans Home Assistant

Étape 3 : Modifier configuration.yaml

Avec Home Assistant Container, l’application File Editor n’est pas nécessaire. Modifiez directement par SSH le fichier de configuration monté sur RK3576.

Sauvegardez la configuration existante :

sudo cp ~/homeassistant/config/configuration.yaml \
  ~/homeassistant/config/configuration.yaml.bak

Ouvrez le fichier avec les droits administrateur :

sudo nano ~/homeassistant/config/configuration.yaml

Conservez la configuration existante, notamment default_config: et frontend:, et ajoutez ceci :

modbus:
  - name: rk3576_demo
    type: tcp
    host: 127.0.0.1
    port: 1502

    sensors:
      - name: RK3576 Room Temperature
        unique_id: rk3576_demo_temperature
        slave: 1
        address: 0
        input_type: holding
        data_type: uint16
        scale: 0.1
        precision: 1
        unit_of_measurement: "°C"
        device_class: temperature
        state_class: measurement
        scan_interval: 5

      - name: RK3576 Room Humidity
        unique_id: rk3576_demo_humidity
        slave: 1
        address: 1
        input_type: holding
        data_type: uint16
        scale: 0.1
        precision: 1
        unit_of_measurement: "%"
        device_class: humidity
        state_class: measurement
        scan_interval: 5

Les principaux paramètres :

Si configuration.yaml contient déjà une clé modbus: au niveau supérieur, ajoutez le nouveau hub à sa liste existante sans redéclarer modbus:.

Appuyez sur Ctrl + O, puis Enter pour enregistrer, et sur Ctrl + X pour quitter nano.

Étape 4 : Vérifier la configuration et redémarrer le conteneur

Validez d’abord la configuration Home Assistant :

sudo docker exec homeassistant \
  python -m homeassistant --script check_config --config /config

Après une vérification réussie, redémarrez Home Assistant :

sudo docker restart homeassistant

Ouvrez cette adresse dans le navigateur de l’ordinateur :

http://<RK3576_IP>:8123

Afficher les capteurs Modbus

Étape 5 : Confirmer la lecture des données

Dans l’interface Home Assistant utilisée pour le test, ouvrez Settings → Tools → States et recherchez rk3576. Vérifiez que ces capteurs existent et affichent des valeurs numériques :

• RK3576 Room Temperature
• RK3576 Room Humidity

Vous pouvez aussi les ajouter à la vue d’ensemble via Overview → Edit overview → Favorite entities → Add favorite.

Créer un tableau de bord Modbus

Étape 6 : Créer le tableau de bord

Ouvrez Settings → Dashboards et sélectionnez Add dashboard en bas à droite.

Dans Add new dashboard, renseignez :

Sélectionnez Create, puis ouvrez le nouveau tableau de bord depuis la barre latérale.

Étape 7 : Ajouter les jauges de température et d’humidité

Dans l’éditeur, sélectionnez + dans New section, puis Add to dashboard → By card → Gauge.

Configurez deux cartes Gauge :

Sélectionnez Save pour chaque carte.

Étape 8 : Ajouter un graphique historique

Sélectionnez de nouveau + dans New section, puis By card → History graph.

Dans History graph card configuration :

1. Réglez Title sur RK3576 Modbus Sensor History.
2. Réglez Hours to show sur 1.
3. Supprimez l’entité par défaut Sun de Entities (required).
4. Sélectionnez Add entity et ajoutez RK3576 Room Temperature.
5. Sélectionnez encore Add entity et ajoutez RK3576 Room Humidity.
6. Sélectionnez Save, puis Done dans l’éditeur.

La température et l’humidité utilisent des unités différentes ; Home Assistant peut donc afficher des graphiques séparés. Vous pouvez également créer une carte indépendante pour chaque capteur.

Résultats

Le tableau de bord du compte rendu de test RK3576 fourni comprend des jauges de température et d’humidité, ainsi qu’un historique de l’humidité montrant son évolution.

La chaîne suivante a été vérifiée lors de ce test :

Simulateur Python Modbus TCP → RK3576 → Home Assistant Container → Tableau de bord web.

Les valeurs sont simulées. Pour connecter un automate, un compteur intelligent ou un capteur Modbus TCP réel, adaptez host, port, slave, les adresses des registres et les types de données aux caractéristiques de l’appareil.

Résumé

Ces étapes réalisent la collecte Modbus TCP, l’affichage de l’état en direct et la visualisation de l’historique sur reComputer RK3576. Cet exemple constitue une base reproductible pour la domotique, la surveillance IoT locale et les passerelles industrielles.

Références

• Seeed Wiki : reComputer R1000 et Modbus avec Home Assistant
• Intégration Modbus de Home Assistant
• Installation de Home Assistant sur Linux / Container

Assistance technique et discussion sur les produits

Pour vos questions, consultez le Seeed Studio Forum.