Digitalen Zwilling erstellen in 7 praktischen Schritten

Einen digitalen Zwilling zu erstellen hat weniger mit der Wahl einer Plattform zu tun als mit einer disziplinierten Abfolge: Scope festlegen, modellieren, verbinden, visualisieren, speichern, verbessern. Dieser Leitfaden führt durch sieben praxisnahe Schritte und enthält für jeden technischen Schritt funktionierenden Code. Am Ende haben Sie einen Live-Zwilling eines Assets, der über MQTT in eine Browser-Ansicht streamt, sowie einen klaren Weg in die Produktion.

Definitionen und das Gesamtbild finden Sie im Leitfaden zur Digital-Twin-Technologie.

Bevor Sie beginnen

Sie brauchen nur sehr wenig:

• Python 3.9 oder neuer mit pip install "paho-mqtt>=2.0".
• Node.js für den Viewer, mit npm install mqtt.
• Optional: die Mosquitto-Kommandozeilen-Clients für schnelle Tests.

Für die praktischen Teile verwenden wir den öffentlichen MQTT-Broker unter broker.connectmq.com, der für Tests und Prototypen gedacht ist. Er erfordert kein Konto, aber alles, was dort publiziert wird, ist für andere lesbar; verwenden Sie daher Demodaten und ein eindeutiges Topic-Präfix. Ersetzen Sie bdt-4w8 unten durch Ihre eigene zufällige ID.

Schritt 1: Entscheidung und Scope definieren

Beginnen Sie mit der Entscheidung, die der Zwilling verbessern soll, nicht mit der Technologie. „Ungeplante Stopps an der Abfülllinie reduzieren" ist ein gutes Ziel. „Einen Fabrikzwilling bauen" ist es nicht, weil es weder einen klaren Nutzer noch ein Erfolgsmaß hat.

Halten Sie schriftlich fest:

1. Den Nutzer: wer den Zwilling ansieht oder auf seiner Grundlage handelt.
2. Die Entscheidung: was er damit anders machen wird.
3. Den Asset-Scope: zum Start eine Maschine oder eine kleine Gruppe.
4. Das Erfolgsmaß: einen KPI mit aktuellem Ausgangswert.

Die meisten ersten Zwillinge sollten Asset-Zwillinge sein: eine Maschine mit ihren wichtigsten Signalen. Der Leitfaden zu den Arten digitaler Zwillinge erklärt, warum dieser Scope meist am schnellsten Ergebnisse liefert.

Schritt 2: Das Asset modellieren

Listen Sie auf, was der Zwilling über das Asset wissen muss, und ordnen Sie jeden Punkt ein:

Ordnen Sie das Asset dann in eine Hierarchie ein. Die ISA-95-Ebenen (Unternehmen, Standort, Bereich, Linie, Zelle) sind ein guter Standard, weil sie der Organisation von Werken entsprechen und der Art, wie Menschen nach Anlagen suchen. Genau diese Hierarchie wird später zur Topic-Struktur eines Unified Namespace (UNS) auf dem MQTT-Broker: In einem realen Werk läge der Füller etwa unter acme/werk-hamburg/abfuellung/linie-2/fueller-1, und jeder Zwilling, jedes Dashboard und das MES fänden ihn an derselben Adresse. In diesem Tutorial ist unser Asset ein Füller unter site1/filling/line2/filler1.

Schritt 3: Topics und Payloads entwerfen

Topics verwandeln das Modell in einen Adressraum. Ein sauberes Muster trennt die Datenarten, sodass Konsumenten nur abonnieren, was sie brauchen:

connectmq/demo/bdt-4w8/site1/filling/line2/filler1/state      retained, QoS 1
connectmq/demo/bdt-4w8/site1/filling/line2/filler1/telemetry  not retained, QoS 0
connectmq/demo/bdt-4w8/site1/filling/line2/filler1/status     Last Will, retained

Auf einem privaten Broker würden Sie das Präfix connectmq/demo/bdt-4w8 weglassen und mit Ihrem Unternehmensnamen beginnen. Payload-Regeln, die später Ärger ersparen:

• JSON mit expliziten Einheiten in den Feldnamen (temp_c, flow_lpm).
• Ein Quellzeitstempel in jeder Nachricht.
• Zustandsnachrichten enthalten den vollständigen aktuellen Zustand, nicht nur Änderungen, damit eine Retained Message für sich allein aussagekräftig ist.

Wenn Sie zu einem werksweiten UNS wachsen wollen, lesen Sie jetzt den Leitfaden zu Sparkplug B und Unified Namespace; es ist viel einfacher, von Anfang an konsistent zu sein, als später umzubenennen.

Schritt 4: Die Datenquelle anbinden

An einer echten Linie liest ein Edge-Gateway die SPS aus (oft über OPC UA oder ein Herstellerprotokoll) und publiziert auf MQTT. In diesem Tutorial simuliert ein Python-Skript den Füller und publiziert genau das, was ein Gateway publizieren würde.

import json
import random
import time
from datetime import datetime, timezone

import paho.mqtt.client as mqtt

BASE = "connectmq/demo/bdt-4w8/site1/filling/line2/filler1"
CLIENT_ID = f"bdt-4w8-filler1-{random.randint(1000, 9999)}"


def now():
    return datetime.now(timezone.utc).isoformat(timespec="seconds")


def on_connect(client, userdata, flags, reason_code, properties):
    print("Connected:", reason_code)
    client.publish(f"{BASE}/status", "online", qos=1, retain=True)


client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id=CLIENT_ID)
client.will_set(f"{BASE}/status", "offline", qos=1, retain=True)
client.on_connect = on_connect
client.connect("broker.connectmq.com", 1883, keepalive=30)
client.loop_start()

good, rejects, mode = 0, 0, "running"
try:
    while True:
        if random.random() < 0.02:
            mode = "fault" if mode == "running" else "running"
        if mode == "running":
            good += random.randint(4, 6)
            rejects += 1 if random.random() < 0.05 else 0
        telemetry = {"ts": now(), "fill_temp_c": round(random.gauss(21.5, 0.3), 2),
                     "flow_lpm": round(random.gauss(118, 2), 1) if mode == "running" else 0.0}
        state = {"ts": now(), "mode": mode, "good_count": good, "reject_count": rejects}
        client.publish(f"{BASE}/telemetry", json.dumps(telemetry), qos=0)
        client.publish(f"{BASE}/state", json.dumps(state), qos=1, retain=True)
        time.sleep(1)
except KeyboardInterrupt:
    client.publish(f"{BASE}/status", "offline", qos=1, retain=True)
    client.loop_stop()
    client.disconnect()

Prüfen Sie den Datenstrom in einem zweiten Terminal:

mosquitto_sub -h broker.connectmq.com -p 1883 -i bdt-4w8-check -t "connectmq/demo/bdt-4w8/#" -v

Schritt 5: Den Broker auswählen und absichern

Der Broker ist die Drehscheibe, mit der sich jede Zwillingskomponente verbindet; behandeln Sie ihn daher vom ersten Tag an als Produktionsinfrastruktur. Zu prüfende Anforderungen:

1. TLS für jede Verbindung, dazu WebSocket über TLS für Browser-Viewer.
2. Getrennte Zugangsdaten für jedes Gateway, jeden Viewer und jeden Dienst.
3. Unterstützung für MQTT 5, wenn Sie Message Expiry, Reason Codes oder Shared Subscriptions nutzen wollen.
4. Ausreichende Verbindungs- und Nachrichtenkapazität für Ihren Wachstumspfad.
5. Jemand, der für Verfügbarkeit, Patches und Zertifikate verantwortlich ist.

Wer einen eigenen Broker betreibt, trägt alle fünf Punkte selbst. Ein verwalteter MQTT-Broker wie ConnectMQ deckt sie ab: Sie erstellen im Portal einen Broker und erhalten einen generierten Benutzernamen, ein Passwort und eine Client ID, mit TLS auf Port 8883 und Secure WebSocket auf Port 8084. Den Simulator darauf umzustellen, ist eine Änderung von drei Zeilen:

client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="YOUR_CLIENT_ID")
client.username_pw_set("YOUR_USERNAME", "YOUR_PASSWORD")
client.tls_set()

Verbinden Sie sich anschließend mit Ihrem Broker-Host auf Port 8883. Der Leitfaden zu Best Practices für MQTT-Sicherheit behandelt den Rest der Härtungs-Checkliste.

Schritt 6: Den Zwilling visualisieren

Ein Zwilling lohnt sich erst, wenn Menschen ihn ansehen. Beginnen Sie mit einer einfachen Live-Ansicht und ergänzen Sie 3D, sobald die Daten vertrauenswürdig sind. Dieses Node.js-Skript ist eine „Zwillingsansicht" im Terminal, die den neuesten Zustand vorhält und veraltete Daten kennzeichnet, mit derselben Logik, die auch ein Browser-Dashboard verwenden würde:

import mqtt from "mqtt";

const BASE = "connectmq/demo/bdt-4w8/site1/filling/line2/filler1";
const twin = { status: "unknown", state: {}, telemetry: {}, lastSeen: 0 };

const client = mqtt.connect("mqtts://broker.connectmq.com:8883", {
  clientId: "bdt-4w8-view-" + Math.random().toString(16).slice(2, 8),
  protocolVersion: 5,
});

client.on("connect", () => client.subscribe(`${BASE}/#`, { qos: 1 }));
client.on("message", (topic, payload) => {
  const kind = topic.split("/").pop();
  twin.lastSeen = Date.now();
  if (kind === "status") twin.status = payload.toString();
  else twin[kind] = JSON.parse(payload.toString());
});

setInterval(() => {
  const ageS = twin.lastSeen ? Math.round((Date.now() - twin.lastSeen) / 1000) : null;
  const stale = ageS === null || ageS > 10;
  const { mode = "-", good_count = 0, reject_count = 0 } = twin.state;
  console.clear();
  console.log(`Filler1  [${twin.status}]${stale ? "  STALE" : ""}`);
  console.log(`Mode: ${mode}   Good: ${good_count}   Rejects: ${reject_count}`);
  console.log(`Fill temp: ${twin.telemetry.fill_temp_c ?? "-"} C   Flow: ${twin.telemetry.flow_lpm ?? "-"} l/min`);
  console.log(`Last update: ${ageS ?? "-"} s ago`);
}, 1000);

Speichern Sie es als view.mjs und führen Sie node view.mjs aus. Im Browser verbinden Sie sich stattdessen mit wss://broker.connectmq.com:8084/mqtt und rendern denselben Zustand in eine Seite oder eine 3D-Szene; das Three.js-Tutorial für digitale Zwillinge zeigt, wie Sie Werte an ein 3D-Modell binden, und der Leitfaden zu MQTT über WebSocket erklärt die Browserverbindung.

Schritt 7: Historie und Alarme ergänzen und iterieren

Eine Live-Ansicht beantwortet die Frage „Was passiert gerade?". Um „Warum?" und „Was kommt als Nächstes?" zu beantworten, ergänzen Sie:

• Historie: einen Subscriber wie Telegraf oder ein kleines Skript, das Telemetrie in eine Zeitreihendatenbank schreibt.
• Alarme: Grenzwertregeln für wichtige Werte. Das ConnectMQ-Portal enthält Grenzwert-Alarmregeln und ein Alarmprotokoll, praktisch, bevor Sie eine eigene Alarmierung aufbauen.
• Rückkopplung: Sobald die Datenqualität nachgewiesen ist, Befehls-Topics mit Bestätigungen, um Sollwerte aus dem Zwilling heraus zu ändern.

Messen Sie dann den KPI aus Schritt 1 und legen Sie den nächsten Scope fest. Das Reifegradmodell für digitale Zwillinge hilft bei der Planung dieser Entwicklung, und der Leitfaden zur Architektur digitaler Zwillinge behandelt die Komponenten, die Sie unterwegs ergänzen werden.

Häufige Stolperfallen

Erstellen Sie Ihren digitalen Zwilling auf ConnectMQ

Jetzt wissen Sie, wie Sie einen digitalen Zwilling vom Scope bis zur Live-Ansicht erstellen. Bauen Sie Prototypen auf broker.connectmq.com und wechseln Sie zu privaten Zugangsdaten, sobald echte Daten eintreffen. Erstellen Sie einen kostenlosen ConnectMQ Serverless-Broker, ganz ohne Kreditkarte, und binden Sie noch heute Ihr erstes Asset an.

Häufig gestellte Fragen

Wie lange dauert es, einen digitalen Zwilling zu erstellen?

Ein erster Asset-Zwilling mit Live-Daten und einer einfachen Ansicht kann innerhalb weniger Tage laufen, sobald der Datenzugriff geklärt ist. Historie, Analytik und 3D kosten Wochen, und die Skalierung auf viele Assets hängt vom Integrationsaufwand ab.

Brauche ich ein 3D-Modell, um einen digitalen Zwilling zu erstellen?

Nein. Viele wirkungsvolle Zwillinge sind Dashboards. 3D hilft beim räumlichen Verständnis und bei der Kommunikation, kann aber ergänzt werden, sobald das Datenfundament steht.

Welches Protokoll sollte ein digitaler Zwilling verwenden?

MQTT ist eine verbreitete Wahl für die Verteilung von Live-Daten, weil es schlank ist und viele Konsumenten sich einen Datenstrom teilen können. Gateways lesen häufig OPC UA oder SPS-Protokolle und publizieren auf MQTT.

Kann ich einen digitalen Zwilling ohne Plattformlizenz erstellen?

Ja. Ein Standard-MQTT-Broker, Open-Source-Tools für Historie und Visualisierung und ein klares Topic-Design reichen für einen leistungsfähigen Zwilling aus.