Modbus-TCP-Datenerfassung und Visualisierung

Zuletzt aktualisiert: 2026-10-16

Einführung

Modbus ist ein verbreitetes Kommunikationsprotokoll in der Industrieautomatisierung zum Lesen von Daten aus SPS, Messgeräten und anderen Industriegeräten. Die Modbus-Integration von Home Assistant wandelt Registerwerte in Sensorentitäten um und zeigt deren Zustand und Verlauf in einer Weboberfläche an.

Dieses Tutorial nutzt reComputer RK3576 und Home Assistant Container, um Temperatur und Luftfeuchtigkeit über Modbus TCP zu lesen und ein Dashboard zu erstellen. Für ein reproduzierbares Beispiel läuft ein Python-Modbus-TCP-Simulator lokal auf RK3576. Eine SPS oder zusätzliche Sensoren sind nicht erforderlich.

Architektur

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

Vorbereitung

Hardware

• Ein reComputer RK3576 mit ARM64 Linux.
• Ein Windows-, macOS- oder Linux-Computer, der RK3576 per SSH und im Browser erreichen kann.
• Ein lokales Netzwerk mit Zugriff auf RK3576.

Dieses Beispiel verwendet Modbus TCP und ist unabhängig von der RS485-Schnittstelle des RK3576.

Software

Schließe zunächst die Docker-Bereitstellung und Ersteinrichtung in Home Assistant auf reComputer RK3576 installieren ab. Prüfe die Umgebung:

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

Der Netzwerkmodus muss host sein. So erreicht der Container den Simulator unter 127.0.0.1:1502 auf dem RK3576-Host.

Eine Modbus-TCP-Datenquelle erstellen

Schritt 1: Den Python-Simulator schreiben

Verbinde dich per SSH mit RK3576. Kopiere den gesamten Befehl ins Terminal, um ~/modbus_demo.py im Home-Verzeichnis des aktuellen Benutzers zu erstellen:

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

Der Simulator unterstützt Funktionscode 03 zum Lesen von Holding-Registern:

Home Assistant nutzt scale: 0.1, um die Rohwerte in Grad Celsius und Prozent umzuwandeln. Die Werte ändern sich mit der Zeit und demonstrieren die laufende Überwachung.

Schritt 2: Den Simulator ausführen

Starte den Simulator:

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

Prüfe, ob er auf Verbindungen wartet:

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

Du solltest die Adresse 127.0.0.1:1502 und diese Meldung sehen:

Modbus TCP server running at 127.0.0.1:1502

Diese Demo läuft mit nohup im Hintergrund. Führe nach einem Neustart von RK3576 den Startbefehl erneut aus. Prüfe vorher den Port, um doppelte Instanzen zu vermeiden.

Modbus TCP in Home Assistant konfigurieren

Schritt 3: configuration.yaml bearbeiten

Mit Home Assistant Container benötigst du die File-Editor-App nicht. Bearbeite die auf RK3576 eingebundene Konfigurationsdatei direkt per SSH.

Sichere die bestehende Konfiguration:

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

Öffne die Datei mit Administratorrechten:

sudo nano ~/homeassistant/config/configuration.yaml

Behalte die bestehende Konfiguration, etwa default_config: und frontend:, und ergänze Folgendes:

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

Die wichtigsten Parameter:

Wenn configuration.yaml bereits einen Schlüssel modbus: auf oberster Ebene enthält, füge den neuen Hub zur bestehenden Liste hinzu, statt modbus: erneut zu deklarieren.

Speichere mit Ctrl + O und Enter. Beende nano mit Ctrl + X.

Schritt 4: Konfiguration prüfen und Container neu starten

Prüfe zunächst die Home-Assistant-Konfiguration:

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

Starte Home Assistant nach erfolgreicher Prüfung neu:

sudo docker restart homeassistant

Öffne diese Adresse im Browser des Computers:

http://<RK3576_IP>:8123

Modbus-Sensoren anzeigen

Schritt 5: Das Einlesen der Daten bestätigen

Öffne in der getesteten Home-Assistant-Oberfläche Settings → Tools → States und suche nach rk3576. Prüfe, ob diese Sensoren vorhanden sind und Zahlenwerte anzeigen:

• RK3576 Room Temperature
• RK3576 Room Humidity

Du kannst beide Sensoren auch über Overview → Edit overview → Favorite entities → Add favorite zur Übersicht hinzufügen.

Ein Modbus-Dashboard erstellen

Schritt 6: Das Dashboard erstellen

Öffne Settings → Dashboards und wähle unten rechts Add dashboard.

Trage unter Add new dashboard Folgendes ein:

Wähle Create und öffne das neue Dashboard über die Seitenleiste.

Schritt 7: Temperatur- und Feuchtigkeitsanzeigen hinzufügen

Wähle im Dashboard-Editor + unter New section, dann Add to dashboard → By card → Gauge.

Konfiguriere zwei Gauge-Karten:

Wähle für jede Karte Save.

Schritt 8: Ein Verlaufsdiagramm hinzufügen

Wähle erneut + unter New section, dann By card → History graph.

Unter History graph card configuration:

1. Setze Title auf RK3576 Modbus Sensor History.
2. Setze Hours to show auf 1.
3. Entferne die standardmäßig hinzugefügte Entität Sun aus Entities (required).
4. Wähle Add entity und füge RK3576 Room Temperature hinzu.
5. Wähle erneut Add entity und füge RK3576 Room Humidity hinzu.
6. Wähle Save und anschließend Done im Editor.

Temperatur und Luftfeuchtigkeit haben unterschiedliche Einheiten. Home Assistant kann daher separate Diagramme anzeigen. Du kannst auch eine eigene Diagrammkarte für jeden Sensor erstellen.

Ergebnisse

Das Dashboard im bereitgestellten RK3576-Testprotokoll enthält Temperatur- und Feuchtigkeitsanzeigen sowie ein Verlaufsdiagramm, das die Änderung der Luftfeuchtigkeit über die Zeit zeigt.

In diesem Test wurde folgende Kette geprüft:

Python-Modbus-TCP-Simulator → RK3576 → Home Assistant Container → Web-Dashboard.

Die Temperatur- und Feuchtigkeitswerte sind simuliert. Für eine reale SPS, einen intelligenten Zähler oder einen Modbus-TCP-Sensor passe host, port, slave, Registeradressen und Datentypen an das Gerät an.

Zusammenfassung

Diese Schritte ermöglichen Modbus-TCP-Datenerfassung, laufende Zustandsanzeige und Verlaufsvisualisierung auf reComputer RK3576. Das Beispiel bietet eine reproduzierbare Grundlage für Hausautomatisierung, lokale IoT-Überwachung und industrielle Gateways.

Referenzen

• Seeed Wiki: reComputer R1000 und Modbus mit Home Assistant
• Home-Assistant-Modbus-Integration
• Home Assistant unter Linux / Container installieren

Technischer Support und Produktdiskussion

Bei Fragen besuche das Seeed Studio Forum.