Saber cómo crear un gemelo digital tiene menos que ver con elegir una plataforma y más con seguir una secuencia disciplinada: alcance, modelo, conexión, visualización, almacenamiento, mejora. Esta guía recorre siete pasos prácticos e incluye código funcional para cada uno de los pasos técnicos, de modo que al final tendrás un gemelo en vivo de un activo que transmite por MQTT a una vista en el navegador, además de un camino claro hacia producción.
Para las definiciones y la visión general, consulta la guía de tecnología de gemelo digital.
Antes de empezar
Necesitas muy poco para seguir la guía:
- Python 3.9 o superior con
pip install "paho-mqtt>=2.0". - Node.js para el visor, con
npm install mqtt. - Opcional: los clientes de línea de comandos de Mosquitto para pruebas rápidas.
Para las partes prácticas usamos el servidor MQTT público gratuito en broker.connectmq.com, pensado para pruebas y prototipos, no para datos de producción. No necesita cuenta, pero cualquier cosa publicada allí la pueden leer otros, así que usa datos de demostración y un prefijo de topic único. Sustituye bdt-4w8 por tu propio ID aleatorio.
Paso 1: define la decisión y el alcance
Empieza por la decisión que el gemelo va a mejorar, no por la tecnología. "Reducir las paradas no planificadas en la línea de llenado" es un buen objetivo. "Construir un gemelo de la fábrica" no lo es, porque no tiene un usuario claro ni una medida de éxito.
Anota:
- El usuario: quién va a mirar el gemelo o actuar a partir de él.
- La decisión: qué hará de forma diferente gracias a él.
- El alcance de activos: una máquina o un grupo pequeño para empezar.
- La medida de éxito: un KPI con una línea base actual.
La mayoría de los primeros gemelos deberían ser gemelos de activo: una máquina con sus señales clave. La guía de tipos de gemelos digitales explica por qué ese alcance suele dar resultados más rápido.
Paso 2: modela el activo
Enumera lo que el gemelo debe saber sobre el activo y clasifica cada elemento:
| Elemento | Ejemplo | Cambia | Origen |
|---|---|---|---|
| Identidad y metadatos | Modelo, número de serie, ubicación | Rara vez | Registro de activos |
| Estado | En marcha, inactivo, fallo, modo | Con eventos | PLC |
| Valores de proceso | Temperatura, presión, velocidad | Continuamente | PLC o sensores |
| Contadores | Ciclos, piezas buenas, rechazos | Continuamente | PLC |
| Alarmas | Sobretemperatura, nivel bajo | Con eventos | PLC |
| Comandos (más adelante) | Consigna, arranque, parada | Bajo petición | Gemelo u operario |
Después sitúa el activo en una jerarquía. Los niveles ISA-95 (empresa, planta, área, línea, célula) son una opción por defecto sólida porque coinciden con cómo se organizan las plantas y con cómo la gente busca los equipos. En este tutorial, nuestro activo es una llenadora en site1/filling/line2/filler1.
Paso 3: diseña topics y payloads
Los topics convierten el modelo en un espacio de direcciones. Un patrón limpio separa los tipos de datos para que los consumidores se suscriban solo a lo que necesitan:
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
En un broker privado eliminarías el prefijo connectmq/demo/bdt-4w8 y empezarías por el nombre de tu empresa. Reglas de payload que ahorran problemas más adelante:
- JSON con las unidades explícitas en los nombres de campo (
temp_c,flow_lpm). - Una marca de tiempo de origen en cada mensaje.
- Los mensajes de estado contienen el estado actual completo, no solo los cambios, para que un retained message sea autosuficiente.
Si planeas crecer hacia un namespace de toda la planta, lee ahora la guía de Sparkplug B y Unified Namespace; es mucho más fácil empezar de forma coherente que renombrar después.
Paso 4: conecta la fuente de datos
En una línea real, un gateway edge lee el PLC (a menudo mediante OPC UA o un protocolo del fabricante) y publica en MQTT. En este tutorial, un script de Python simula la llenadora y publica exactamente lo que publicaría un gateway.
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()
Verifica el flujo desde otra terminal:
mosquitto_sub -h broker.connectmq.com -p 1883 -i bdt-4w8-check -t "connectmq/demo/bdt-4w8/#" -v
Paso 5: elige y protege el broker
El broker es el núcleo al que se conectan todos los componentes del gemelo, así que trátalo como infraestructura de producción desde el primer día. Requisitos que comprobar:
- TLS en todas las conexiones, además de WebSocket sobre TLS para los visores en el navegador.
- Credenciales separadas para cada gateway, visor y servicio.
- Soporte de MQTT 5 si quieres expiración de mensajes, reason codes o suscripciones compartidas.
- Capacidad suficiente de conexiones y mensajes para tu plan de crecimiento.
- Alguien responsable de la disponibilidad, los parches y los certificados.
Ejecutar tu propio broker implica asumir los cinco. Un broker MQTT gestionado como ConnectMQ los cubre: creas un broker en el portal y recibes un usuario, una contraseña y un client ID generados, con TLS en el puerto 8883 y Secure WebSocket en el 8084. Mover el simulador a él es un cambio de tres líneas:
client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="YOUR_CLIENT_ID")
client.username_pw_set("YOUR_USERNAME", "YOUR_PASSWORD")
client.tls_set()
Después conéctate al host de tu broker en el puerto 8883. La guía de buenas prácticas de seguridad MQTT cubre el resto de la checklist de hardening.
Paso 6: visualiza el gemelo
Un gemelo justifica su existencia cuando la gente lo mira. Empieza con una vista en vivo sencilla y añade un gemelo digital 3D cuando los datos sean fiables. Este script de Node.js es una "vista del gemelo" en la terminal que guarda el último estado y marca los datos obsoletos, la misma lógica que usaría un dashboard en el navegador:
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);
Guárdalo como view.mjs y ejecuta node view.mjs. En un navegador, conéctate en su lugar con wss://broker.connectmq.com:8084/mqtt y renderiza el mismo estado en una página o en una escena 3D; el tutorial de gemelo digital con Three.js muestra cómo vincular valores a un modelo 3D, y la guía de MQTT sobre WebSocket explica la conexión desde el navegador.
Paso 7: añade histórico y alertas, e itera
Una vista en vivo responde a "qué está pasando". Para responder a "por qué" y "qué viene después", añade:
- Histórico: un suscriptor como Telegraf o un pequeño script que escriba la telemetría en una base de datos de series temporales.
- Alertas: reglas de umbral sobre los valores clave. El portal de ConnectMQ incluye reglas de alerta por umbral y un registro de alertas, muy útiles antes de construir tu propio sistema de alertas.
- Retroalimentación: una vez demostrada la calidad de los datos, topics de comandos con confirmaciones para cambiar consignas desde el gemelo.
Después mide el KPI del paso 1 y decide el siguiente alcance. El modelo de madurez del gemelo digital ayuda a planificar esa progresión, y la guía de arquitectura de gemelo digital cubre los componentes que irás añadiendo por el camino.
Errores habituales
| Error | Consecuencia | Cómo evitarlo |
|---|---|---|
| Empezar con toda una fábrica | Meses de integración antes de obtener valor | Acotar primero a un activo |
| Nombres de topic incoherentes | Las suscripciones con comodines fallan y hay que rehacer trabajo | Fijar la jerarquía en el paso 2 |
| Sin marcas de tiempo ni unidades | Histórico y analítica poco fiables | Las reglas de payload del paso 3 |
| Credenciales compartidas | Los clientes se desconectan entre sí, sin trazabilidad | Una identidad por cliente |
| Sin indicador de datos obsoletos | Los usuarios confían en valores antiguos | Registrar la hora de la última recepción y usar Last Will |
Crea tu gemelo digital en ConnectMQ
Ya sabes cómo crear un gemelo digital desde el alcance hasta la vista en vivo. Prototipa en broker.connectmq.com y pasa a credenciales privadas cuando lleguen los datos reales. Crea un broker ConnectMQ Serverless gratuito, sin tarjeta de crédito, y conecta hoy tu primer activo.
Preguntas frecuentes
¿Cuánto se tarda en crear un gemelo digital?
Un primer gemelo de activo con datos en vivo y una vista sencilla puede estar funcionando en días una vez resuelto el acceso a los datos. El histórico, la analítica y el 3D añaden semanas, y escalar a muchos activos depende del esfuerzo de integración.
¿Necesito un modelo 3D para crear un gemelo digital?
No. Muchos gemelos eficaces son dashboards. El 3D ayuda a la comprensión espacial y a la comunicación, pero puede añadirse cuando la base de datos ya funciona.
¿Qué protocolo debería usar un gemelo digital?
MQTT es una opción habitual para distribuir datos en vivo porque es ligero y permite que muchos consumidores compartan un mismo flujo. Los gateways suelen leer OPC UA o protocolos de PLC y publicar en MQTT.
¿Puedo crear un gemelo digital sin una licencia de plataforma?
Sí. Un broker MQTT estándar, herramientas open source para el histórico y la visualización y un diseño de topics claro bastan para un gemelo capaz.
