Savoir créer un jumeau numérique tient moins au choix d'une plateforme qu'au respect d'une séquence rigoureuse : cadrer, modéliser, connecter, visualiser, stocker, améliorer. Ce guide parcourt sept étapes pratiques et fournit du code fonctionnel pour chaque étape technique : à la fin, vous aurez le jumeau en temps réel d'un actif diffusé via MQTT dans une vue navigateur, ainsi qu'un chemin clair vers la production.
Pour les définitions et la vue d'ensemble, consultez le guide de la technologie du jumeau numérique.
Avant de commencer
Il vous faut très peu de choses pour suivre :
- Python 3.9 ou plus récent avec
pip install "paho-mqtt>=2.0". - Node.js pour le visualiseur, avec
npm install mqtt. - Optionnel : les clients en ligne de commande Mosquitto pour des tests rapides.
Pour la partie pratique, nous utilisons le serveur MQTT public gratuit broker.connectmq.com. Il ne nécessite aucun compte, mais il est réservé aux tests et aux prototypes, et tout ce qui y est publié est lisible par d'autres : utilisez des données de démonstration et un préfixe de topic unique. Remplacez bdt-4w8 ci-dessous par votre propre identifiant aléatoire.
Étape 1 : définir la décision et le périmètre
Partez de la décision que le jumeau doit améliorer, pas de la technologie. « Réduire les arrêts non planifiés de la ligne de remplissage » est un bon objectif. « Construire un jumeau de l'usine » n'en est pas un, car il n'a ni utilisateur clair ni mesure de réussite.
Notez :
- L'utilisateur : qui consultera le jumeau ou agira à partir de lui.
- La décision : ce qu'il fera différemment grâce à lui.
- Le périmètre d'actifs : une machine ou un petit groupe pour commencer.
- La mesure de réussite : un KPI avec une valeur de référence actuelle.
La plupart des premiers jumeaux devraient être des jumeaux d'actif : une machine avec ses signaux clés. Le guide des types de jumeaux numériques explique pourquoi ce périmètre apporte généralement de la valeur le plus vite.
Étape 2 : modéliser l'actif
Listez ce que le jumeau doit savoir de l'actif et classez chaque élément :
| Élément | Exemple | Évolution | Source |
|---|---|---|---|
| Identité et métadonnées | Modèle, numéro de série, emplacement | Rarement | Registre des actifs |
| État | En marche, à vide, en défaut, mode | Sur événement | Automate |
| Valeurs de procédé | Température, pression, vitesse | En continu | Automate ou capteurs |
| Compteurs | Cycles, pièces bonnes, rebuts | En continu | Automate |
| Alarmes | Surchauffe, niveau bas | Sur événement | Automate |
| Commandes (plus tard) | Consigne, démarrage, arrêt | Sur demande | Jumeau ou opérateur |
Placez ensuite l'actif dans une hiérarchie. Les niveaux ISA-95 (entreprise, site, zone, ligne, cellule) sont un excellent choix par défaut, car ils correspondent à l'organisation des usines et à la façon dont on recherche un équipement. Dans ce tutoriel, notre actif est une remplisseuse située en site1/filling/line2/filler1.
Étape 3 : concevoir les topics et les payloads
Les topics transforment le modèle en espace d'adressage. Un pattern propre sépare les types de données pour que les consommateurs ne s'abonnent qu'à ce dont ils ont besoin :
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
Sur un broker privé, vous supprimeriez le préfixe connectmq/demo/bdt-4w8 pour commencer par le nom de votre entreprise. Quelques règles de payload qui vous éviteront des ennuis plus tard :
- Du JSON avec des unités explicites dans le nom des champs (
temp_c,flow_lpm). - Un horodatage source dans chaque message.
- Des messages d'état contenant l'état actuel complet, pas seulement les changements, pour qu'un retained message se suffise à lui-même.
Si vous prévoyez d'évoluer vers un namespace à l'échelle de l'usine, lisez dès maintenant le guide Sparkplug B et Unified Namespace ; il est bien plus simple de partir cohérent que de tout renommer ensuite.
Étape 4 : connecter la source de données
Sur une vraie ligne, une passerelle edge lit l'automate (souvent via OPC UA ou un protocole constructeur) et publie sur MQTT. Pour ce tutoriel, un script Python simule la remplisseuse et publie exactement ce que publierait une passerelle.
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()
Vérifiez le flux depuis un autre terminal :
mosquitto_sub -h broker.connectmq.com -p 1883 -i bdt-4w8-check -t "connectmq/demo/bdt-4w8/#" -v
Étape 5 : choisir et sécuriser le broker
Le broker est le hub auquel se connecte chaque composant du jumeau : traitez-le comme une infrastructure de production dès le premier jour. Les exigences à vérifier :
- TLS pour chaque connexion, plus WebSocket sur TLS pour les visualiseurs dans le navigateur.
- Des identifiants distincts par passerelle, visualiseur et service.
- La prise en charge de MQTT 5 si vous voulez l'expiration des messages, les reason codes ou les abonnements partagés.
- Une capacité en connexions et en messages suffisante pour votre trajectoire de croissance.
- Quelqu'un responsable de la disponibilité, des correctifs et des certificats.
Exploiter votre propre broker signifie assumer ces cinq points. Un broker MQTT managé comme ConnectMQ les couvre : vous créez un broker dans le portail et recevez un nom d'utilisateur, un mot de passe et un client ID générés, avec TLS sur le port 8883 et Secure WebSocket sur le 8084. Basculer le simulateur dessus ne demande que trois lignes :
client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="YOUR_CLIENT_ID")
client.username_pw_set("YOUR_USERNAME", "YOUR_PASSWORD")
client.tls_set()
Connectez-vous ensuite à l'hôte de votre broker sur le port 8883. Le guide des bonnes pratiques de sécurité MQTT couvre le reste de la checklist de durcissement.
Étape 6 : visualiser le jumeau
Un jumeau prouve sa valeur quand les gens le regardent. Commencez par une vue en temps réel simple, puis ajoutez la 3D lorsque les données sont fiables. Ce script Node.js est une « vue du jumeau » en terminal qui conserve le dernier état et signale les données périmées, la même logique qu'utiliserait un tableau de bord dans le navigateur :
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);
Enregistrez-le sous view.mjs et lancez node view.mjs. Dans un navigateur, connectez-vous plutôt avec wss://broker.connectmq.com:8084/mqtt et affichez le même état dans une page ou une scène 3D ; le tutoriel de jumeau numérique Three.js montre comment lier des valeurs à un modèle 3D, et le guide MQTT over WebSocket explique la connexion depuis le navigateur.
Étape 7 : ajouter historique et alertes, puis itérer
Une vue en temps réel répond à « que se passe-t-il ». Pour répondre à « pourquoi » et « et ensuite », ajoutez :
- L'historique : un abonné comme Telegraf ou un petit script qui écrit la télémétrie dans une base de séries temporelles.
- Les alertes : des règles de seuil sur les valeurs clés. Le portail ConnectMQ inclut des règles d'alerte à seuil et un journal des alertes, pratiques avant de construire votre propre système d'alerte.
- La rétroaction : une fois la qualité des données prouvée, des topics de commande avec acquittements pour modifier des consignes depuis le jumeau.
Mesurez ensuite le KPI de l'étape 1 et décidez du périmètre suivant. Le modèle de maturité du jumeau numérique aide à planifier cette progression, et le guide de l'architecture du jumeau numérique présente les composants que vous ajouterez en chemin.
Pièges courants
| Piège | Conséquence | Comment l'éviter |
|---|---|---|
| Commencer par une usine entière | Des mois d'intégration avant toute valeur | Cadrer d'abord un seul actif |
| Noms de topics incohérents | Abonnements wildcard cassés, reprises ultérieures | Fixer la hiérarchie à l'étape 2 |
| Ni horodatage ni unités | Historique et analyses peu fiables | Règles de payload de l'étape 3 |
| Identifiants partagés | Les clients se déconnectent mutuellement, aucune traçabilité | Une identité par client |
| Aucun indicateur de données périmées | Les utilisateurs se fient à de vieilles valeurs | Suivre l'heure de dernière réception et le Last Will |
Créez votre jumeau numérique sur ConnectMQ
Vous savez maintenant créer un jumeau numérique, du cadrage à la vue en temps réel. Prototypez sur le serveur MQTT public gratuit broker.connectmq.com, puis passez à des identifiants privés dès que de vraies données arrivent. Créez un broker ConnectMQ Serverless (Free), sans carte bancaire, et connectez votre premier actif dès aujourd'hui.
Questions fréquentes
Combien de temps faut-il pour créer un jumeau numérique ?
Un premier jumeau d'actif avec des données en temps réel et une vue simple peut fonctionner en quelques jours une fois l'accès aux données réglé. L'historique, l'analytique et la 3D ajoutent des semaines, et le passage à de nombreux actifs dépend de l'effort d'intégration.
Faut-il un modèle 3D pour créer un jumeau numérique ?
Non. Beaucoup de jumeaux efficaces sont des tableaux de bord. La 3D aide à la compréhension spatiale et à la communication, mais elle peut être ajoutée une fois la base de données fonctionnelle.
Quel protocole un jumeau numérique doit-il utiliser ?
MQTT est un choix courant pour distribuer les données en temps réel, car il est léger et permet à de nombreux consommateurs de partager un même flux. Les passerelles lisent souvent OPC UA ou les protocoles des automates et publient sur MQTT.
Peut-on créer un jumeau numérique sans licence de plateforme ?
Oui. Un broker MQTT standard, des outils open source pour l'historique et la visualisation, et une conception de topics claire suffisent pour un jumeau performant.
