Weidmüller u-remote mit Node-RED schalten

In diesem Tutorial lernst du, wie du mithilfe von Node-RED und intelligenter Hardware das Schalten digitaler Signale in deiner Produktion erledigen kannst.

Node-RED ist ein Drag-and-Drop-Modellierungstool, mit dem Produktionsprozesse browserbasiert und ohne Programmierkenntnisse erstellt und unterstützt werden können. Allgemein ist Node-RED aus dem Bereich der Gebäude- und Heimautomatisierung bekannt. Weniger bekannt ist jedoch, dass dieses Werkzeug sich auch hervorragend dazu eignet, eine eigene Fabrik zu digitalisieren und effizienter zu gestalten. Die offizielle Beschreibung von der Node-RED-Internetseite lautet:

Node-RED is a programming tool for wiring together hardware devices, APIs and online services in new and interesting ways. It provides a browser-based editor that makes it easy to wire together flows using the wide range of nodes in the palette that can be deployed to its runtime in a single-click.

Node-RED (nodered.org)

Das Beste daran: Es ist Open-Source.

Industrielle Anwendung

Node-RED hat sich bereits weit in der Industrie verbreitet. Es ist auf vielen Automatisierungssteuerungen vorinstalliert und wird von Unternehmen weltweit eingesetzt, um Prozesse zu automatisieren und zu optimieren. Ein Überblick über Node-RED und seine Anwendungen in der Industrie findet sich auf Wikipedia. Es gibt eine Vielzahl von Knoten in Node-RED, die speziell für den Einsatz in industriellen Umgebungen entwickelt wurden. Diese Knoten ermöglichen das Auslesen von Daten von bestimmten Geräten, die in der Industrie als Standardkomponenten verwendet werden. Beispiele hierfür sind Knoten zum Lesen von Daten von industriellen Sensoren, Aktoren oder Steuerungen:

• node-red-contrib-opcua hatte 1552 Downloads in der letzten Woche (2024-04-17)
• node-red-contrib-s7 hatte 918 Downloads in der letzten Woche (2024-04-17)
• node-red-contrib-modbus hatte 3026 Downloads in der letzten Woche (2024-04-17)

Im Blogpost wird auch das Thema Modbus behandelt. Modbus ist ein Kommunikationsprotokoll, das den Datenaustausch zwischen einem Client und mehreren Servern ermöglicht.

Im Kontext des Fabrikbetriebs gibt es eine Vielzahl von Anbietern, die Geräte bereitstellen, um digitale Signale über das Netzwerk zu schalten. In diesem Fall fiel die Wahl auf ein Remote-I/O System des führenden Industrieunternehmens Weidmüller. Das Weidmüller U-Remote ist eine Automatisierungskomponente, die in robusten, stabilen und skalierbaren Fabriken eingesetzt wird.

Das System funktioniert folgendermaßen: Ein Server, üblicherweise ein Computer, und die Clients wie Steuergeräte und Messeinheiten werden miteinander verbunden. Als Übertragungssystem wird Ethernet verwendet. Im Betriebsmodus werden die Daten mithilfe von TCP/IP-Paketen übertragen, wobei der Port 502 reserviert ist und der Datendurchsatz in binärer Form erfolgt. Das Modbus-Protokoll ermöglicht die Steuerung der angeschlossenen Geräte sowie die Übermittlung von Messdaten an den Server.

Hardware

In diesem Tutorial wird das Gerät UR20-FBC-MOD-TCP-V2 verwendet. Es ermöglicht Benutzern, von entfernten Standorten aus auf industrielle Geräte oder Anlagen zuzugreifen und diese zu überwachen. Dies unterstützt die Implementierung von Industrie-4.0-Konzepten und Smart Manufacturing. Das Modul fungiert als Feldbuskoppler, der die verschiedenen Feldbusstandards mit dem u-remote-Systembus verbindet.

Als Ausgangsmodul wird das UR20-16DO-P verwendet, das dazu dient, digitale Signale zu schalten. Dieses Modul ist über den Systembus mit dem Feldbuskoppler verbunden.

Der einfache Weg ins Industrial IoT

Um das Gerät für die Kommunikation über Modbus einzurichten, muss es als Netzwerkteilnehmer konfiguriert sein. Der Feldbuskoppler bietet eine einfache Bedienoberfläche, auf die zugegriffen werden kann, sobald das Gerät über USB mit dem Client verbunden ist. Zur Einrichtung ist die Installation eines Treibers erforderlich, der auf der Supportseite für u-remote auf der Website von Weidmüller (weidmueller.de) verfügbar ist.

Für die Integration des Geräts in Node-RED wird die Knoten-Palette „node-red-contrib-modbus“ benötigt. Diese kann mit einem Klick in Node-RED nachinstalliert werden. Das Paket erweitert Node-RED um die Möglichkeit der Modbus-Kommunikation und unterstützt verschiedene Modbus-Varianten wie Modbus TCP, Modbus RTU über serielle Schnittstellen und Modbus RTU über TCP. Dadurch wird die Kommunikation mit einer Vielzahl von Geräten wie Sensoren, Aktuatoren, Steuerungen und anderen industriellen Komponenten ermöglicht.

Um in Node-RED ein neues Paket wie „node-red-contrib-modbus“ zu installieren, folge diesen Schritten:

1. Klicke auf die Schaltfläche mit den drei horizontalen Linien in der oberen rechten Ecke des Node-RED Dashboards, um das Hauptmenü zu öffnen.
2. Wähle „Palette verwalten“ aus dem Dropdown-Menü. Es öffnet sich ein Fenster namens „Manage palette“.
3. Klicke im „Einstellungen“ Fenster auf die Registerkarte „Installation“. Hier kannst du nach verfügbaren Paketen suchen.
4. Gib den Namen des Pakets, das du installieren möchtest, in das Suchfeld ein. In diesem Fall gib „modbus“ ein.
5. Wenn das gewünschte Paket („node-red-contrib-modbus“) in der Suchergebnisliste angezeigt wird, klicke auf „Installieren“ neben dem Paket.
6. Node-RED wird das Paket jetzt automatisch herunterladen und installieren. Warte einen Moment, bis der Installationsprozess abgeschlossen ist.

Nachdem das Paket erfolgreich installiert wurde, stehen dir die Modbus-Knoten zur Verfügung, die du in deinen Flows verwenden kannst, um mit Modbus-fähigen Geräten zu kommunizieren.

Ein Beispiel

Um Modbus-Daten mit Node-RED auszulesen, ist der einfachste Baustein der „Modbus Read“ Knoten. Diesen ziehen wir auf unser Arbeitspapier und öffnen mit Doppelklick die Einstellungen

Die Parameter „Name“ und „Topic“ betreffen das interne Nachrichtenobjekt von Node-RED. Anschließend folgen modbusspezifische Einstellungen.

Bevor ein Datenpunkt definiert wird, muss ein neuer Modbus-Server hinzugefügt werden. Klicke dazu einfach auf das Stift-Symbol. Dort können die serverspezifischen Daten eingegeben werden. Die wichtigsten Parameter sind:

• Name: Zur Identifizierung des Modbus-Servers in Node-RED.
• Host: Die IP-Adresse des Geräts, von dem die Modbus-Daten gelesen werden sollen.
• Verbindungstyp: Standardmäßig „Default“.

Nachdem die Daten eingegeben wurden, wird der Server in Node-RED gespeichert und kann für die Modbus-Kommunikation verwendet werden.

Nachdem der Modbus-Server in Node-RED konfiguriert wurde, wird der „Modbus Read“ Knoten verwendet, um anzugeben, welche Daten ausgelesen werden sollen. Die Informationen darüber, welche Datenpunkte angegeben werden müssen, sind der Dokumentation des Modbus-Geräts zu entnehmen.

In der SPS-Programmierung werden diese Datenpunkte normalerweise in der Steuerung selbst festgelegt, d.h. es wird definiert, auf welchen Registern oder Adressen welche Daten liegen. Im vorliegenden Fall ist es notwendig, das Handbuch des Modbus-Geräts zur Hilfe zu nehmen. Darin sind die entsprechenden Registeradressen oder Datenpunkte beschrieben, von denen die gewünschten Daten ausgelesen werden sollen.

Sobald die erforderlichen Datenpunkte bekannt sind (z.B. Registernummern für bestimmte Werte), können diese im „Modbus Read“ Knoten von Node-RED angegeben werden, um die gewünschten Daten aus dem Modbus-Gerät zu lesen und weiterzuverarbeiten.

Um Ausgangsbits gemäß der Funktionsbeschreibung zu lesen, verwenden wir die Funktion „Read Coils“, die dem Funktionscode 1 (0x01) entspricht. In der nachfolgenden Tabelle sind die Bitadressen für die Funktionscodes 1, 2, 5 und 15 aufgeführt. Um die gepackten Prozessdaten der Ausgänge lesen zu können, liegt der Adressbereich zwischen 32768 und 40959. Die „Quantity“ (Datenbreite) hängt von der Konfiguration der Weidmüller-Komponenten ab und ist modulabhängig. Unabhängig vom Ausbau der I/Os ist immer ein Zugriff auf alle 512 Register möglich. Ungenutzte Register senden beim Lesezugriff eine Null zurück, und Schreibzugriffe auf diese Register werden vollständig ignoriert.

Für den vorliegenden Fall wird der Adressbereich des ersten Registers auf 32768 festgelegt. Um die Ausgänge des ersten Moduls auszulesen, wird eine Datenbreite von 16 gewählt, da dieses Modul 16 digitale Ausgänge bietet.

Für den ersten Test wird über den Webserver Kanal 4 bis 7 auf den Wert 1 gesetzt. Das bedeutet, dass an diesen Ausgängen ein elektrisches Signal ausgegeben wird. Hier für gibt es einen Force-Modus, der es ermöglicht, über die Oberfläche Ausgänge zu setzen.

Nachdem der Flow freigegeben wurde, wird alle drei Sekunden das Bitmuster des Ausgangsmoduls in der Debug-Console ausgegeben. Dieses Nachrichtenobjekt kann nun im Rahmen weiterer Flows weiterverarbeitet werden. Im nachfolgenden Screenshot ist die Ausgabe des Nachrichtenobjektes innerhalb Node-RED ersichtlich. Die Payload besteht in diesem Fall aus zwei Bytes, in denen der Zustand der Ausgänge ersichtlich ist:

Lasst uns automatisieren

Im letzten Schritt wird ein Ausgang mithilfe eines Flows in Node-RED gesetzt. Dies wird durch den „Modbus Write“ Knoten realisiert. Zunächst wird der zuvor erstellte Modbus-Server ausgewählt. Der Eingangsbereich für die Funktion „Force Single Coil“ (siehe Tabelle der unterstützten Modbus-Funktionen) liegt zwischen 0x0800 und 0x09FF. Wir wählen die Adresse 32768 aus, um den ersten Ausgang des ersten Moduls auf den Wert 1 zu setzen. Um diesen Ausgang zu setzen, senden wir ein Nachrichtenobjekt mit einer Payload an den „Modbus Write“ Knoten. Hierfür wird ein „Inject“ Node verwendet.

Der „Inject“ Node in Node-RED ermöglicht das planmäßige Einspeisen von Nachrichten in einen Flow zu bestimmten Zeitpunkten oder mit festgelegten Intervallen. Durch manuelles Aktivieren des „Inject“ Nodes wird erfolgreich der erste Ausgang des ersten Moduls gesetzt.

Mit Node-RED und intelligenter Hardware hast du die Möglichkeit, Produktionsprozesse effizient zu gestalten und digitale Signale zu schalten, ohne tiefgehende Programmierkenntnisse zu benötigen. Dieses Tutorial zeigt nur einen kleinen Ausschnitt der vielfältigen Anwendungsmöglichkeiten dieses Tools in der Industrie. Node-RED öffnet die Tür zu einer Welt der Automatisierung und Prozessoptimierung, die bisher oft nur der Gebäude- und Heimautomatisierung zugeschrieben wurde.

Folgender Flow kann direkt in Node-RED importiert werden:

[
    {
        "id": "c1d253122f4f75ee",
        "type": "modbus-read",
        "z": "f6f2187d.f17ca8",
        "name": "Read Coil Status",
        "topic": "",
        "showStatusActivities": false,
        "logIOActivities": false,
        "showErrors": false,
        "showWarnings": true,
        "unitid": "",
        "dataType": "Coil",
        "adr": "32768",
        "quantity": "16",
        "rate": "99999",
        "rateUnit": "s",
        "delayOnStart": false,
        "startDelayTime": "",
        "server": "92d4244cfcf3c375",
        "useIOFile": false,
        "ioFile": "",
        "useIOForPayload": false,
        "emptyMsgOnFail": false,
        "x": 460,
        "y": 160,
        "wires": [
            [
                "8877d89ca79e3408"
            ],
            []
        ]
    },
    {
        "id": "8877d89ca79e3408",
        "type": "debug",
        "z": "f6f2187d.f17ca8",
        "name": "debug",
        "active": true,
        "tosidebar": true,
        "console": false,
        "tostatus": false,
        "complete": "payload",
        "targetType": "msg",
        "statusVal": "",
        "statusType": "auto",
        "x": 650,
        "y": 140,
        "wires": []
    },
    {
        "id": "b02b505ab62b3268",
        "type": "modbus-write",
        "z": "f6f2187d.f17ca8",
        "name": "Write Output 1",
        "showStatusActivities": true,
        "showErrors": true,
        "showWarnings": true,
        "unitid": "",
        "dataType": "Coil",
        "adr": "32768",
        "quantity": "1",
        "server": "92d4244cfcf3c375",
        "emptyMsgOnFail": true,
        "keepMsgProperties": true,
        "delayOnStart": false,
        "startDelayTime": "",
        "x": 460,
        "y": 260,
        "wires": [
            [
                "6fa504ceb11e892e"
            ],
            []
        ]
    },
    {
        "id": "08a9721af6ba555c",
        "type": "inject",
        "z": "f6f2187d.f17ca8",
        "name": "",
        "props": [
            {
                "p": "payload"
            }
        ],
        "repeat": "",
        "crontab": "",
        "once": false,
        "onceDelay": 0.1,
        "topic": "",
        "payload": "true",
        "payloadType": "bool",
        "x": 230,
        "y": 260,
        "wires": [
            [
                "b02b505ab62b3268"
            ]
        ]
    },
    {
        "id": "6fa504ceb11e892e",
        "type": "debug",
        "z": "f6f2187d.f17ca8",
        "name": "debug 1",
        "active": true,
        "tosidebar": true,
        "console": false,
        "tostatus": false,
        "complete": "true",
        "targetType": "full",
        "statusVal": "",
        "statusType": "auto",
        "x": 680,
        "y": 240,
        "wires": []
    },
    {
        "id": "92d4244cfcf3c375",
        "type": "modbus-client",
        "name": "UREMOTE_01",
        "clienttype": "tcp",
        "bufferCommands": true,
        "stateLogEnabled": false,
        "queueLogEnabled": false,
        "failureLogEnabled": true,
        "tcpHost": "127.0.0.1",
        "tcpPort": "502",
        "tcpType": "DEFAULT",
        "serialPort": "/dev/ttyUSB",
        "serialType": "RTU-BUFFERD",
        "serialBaudrate": "9600",
        "serialDatabits": "8",
        "serialStopbits": "1",
        "serialParity": "none",
        "serialConnectionDelay": "100",
        "serialAsciiResponseStartDelimiter": "0x3A",
        "unit_id": 1,
        "commandDelay": 1,
        "clientTimeout": 1000,
        "reconnectOnTimeout": true,
        "reconnectTimeout": 2000,
        "parallelUnitIdsAllowed": true,
        "showErrors": false,
        "showWarnings": true,
        "showLogs": true
    }
]