Saber como criar um gêmeo digital tem menos a ver com escolher uma plataforma e mais com seguir uma sequência disciplinada: definir o escopo, modelar, conectar, visualizar, armazenar, melhorar. Este guia percorre sete passos práticos e inclui código funcional para cada etapa técnica, de modo que, ao final, você terá um gêmeo ao vivo de um ativo transmitindo via MQTT para uma visualização no navegador, além de um caminho claro até a produção.
Para definições e a visão geral, veja o guia de tecnologia de gêmeo digital.
Antes de Começar
Você precisa de muito pouco para acompanhar:
- Python 3.9 ou mais recente com
pip install "paho-mqtt>=2.0". - Node.js para o visualizador, com
npm install mqtt. - Opcional: os clientes de linha de comando do Mosquitto para testes rápidos.
Usamos o servidor MQTT público (gratuito) em broker.connectmq.com nas partes práticas. Ele não exige conta, mas tudo o que é publicado ali pode ser lido por outras pessoas e ele serve para testes e protótipos, não para dados de produção, então use dados de demonstração e um prefixo de topic único. Substitua bdt-4w8 abaixo pelo seu próprio ID aleatório.
Passo 1: Defina a Decisão e o Escopo
Comece pela decisão que o gêmeo vai melhorar, não pela tecnologia. "Reduzir paradas não planejadas na linha de envase", por exemplo numa fábrica de bebidas em Manaus, é um bom objetivo. "Construir um gêmeo da fábrica" não é, porque não tem um usuário claro nem uma medida de sucesso.
Anote:
- O usuário: quem vai consultar o gêmeo ou agir com base nele.
- A decisão: o que essa pessoa vai fazer de diferente com ele.
- O escopo de ativos: uma máquina ou um pequeno grupo para começar.
- A medida de sucesso: um KPI com uma linha de base atual.
A maioria dos primeiros gêmeos deve ser de ativo: uma máquina com seus sinais principais. O guia sobre tipos de gêmeos digitais explica por que esse escopo normalmente entrega resultado mais rápido.
Passo 2: Modele o Ativo
Liste o que o gêmeo precisa saber sobre o ativo e classifique cada item:
| Item | Exemplo | Muda | Origem |
|---|---|---|---|
| Identidade e metadados | Modelo, número de série, localização | Raramente | Cadastro de ativos |
| Estado | Em operação, ocioso, falha, modo | Em eventos | CLP |
| Valores de processo | Temperatura, pressão, velocidade | Continuamente | CLP ou sensores |
| Contadores | Ciclos, peças boas, rejeitos | Continuamente | CLP |
| Alarmes | Sobretemperatura, nível baixo | Em eventos | CLP |
| Comandos (depois) | Setpoint, partida, parada | Sob demanda | Gêmeo ou operador |
Em seguida, posicione o ativo em uma hierarquia. Os níveis ISA-95 (empresa, site, área, linha, célula) são um ótimo padrão porque correspondem à forma como as plantas são organizadas e como as pessoas procuram equipamentos. Neste tutorial, nosso ativo é uma envasadora em site1/filling/line2/filler1.
Passo 3: Projete Topics e Payloads
Os topics transformam o modelo em um espaço de endereçamento. Um padrão limpo separa os tipos de dados para que os consumidores assinem apenas o que precisam:
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
Em um broker privado, você removeria o prefixo connectmq/demo/bdt-4w8 e começaria pelo nome da sua empresa. Regras de payload que evitam dor de cabeça depois:
- JSON com unidades explícitas nos nomes dos campos (
temp_c,flow_lpm). - Um timestamp de origem em cada mensagem.
- Mensagens de estado contêm o estado atual completo, não apenas as mudanças, para que uma retained message seja autossuficiente.
Se você planeja evoluir para um namespace de toda a planta, leia agora o guia de Sparkplug B e Unified Namespace; é muito mais fácil começar consistente do que renomear depois.
Passo 4: Conecte a Fonte de Dados
Em uma linha real, um gateway de borda lê o CLP (geralmente via OPC UA ou um protocolo do fabricante) e publica no MQTT. Neste tutorial, um script Python simula a envasadora e publica exatamente o que um gateway publicaria.
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()
Verifique o fluxo em outro terminal:
mosquitto_sub -h broker.connectmq.com -p 1883 -i bdt-4w8-check -t "connectmq/demo/bdt-4w8/#" -v
Passo 5: Escolha e Proteja o Broker
O broker é o hub ao qual todos os componentes do gêmeo se conectam, então trate-o como infraestrutura de produção desde o primeiro dia. Requisitos a verificar:
- TLS em todas as conexões, além de WebSocket sobre TLS para visualizadores no navegador.
- Credenciais separadas para cada gateway, visualizador e serviço.
- Suporte a MQTT 5, se você quiser expiração de mensagens, reason codes ou assinaturas compartilhadas.
- Capacidade de conexões e mensagens suficiente para o seu plano de crescimento.
- Alguém responsável por disponibilidade, patches e certificados.
Rodar seu próprio broker significa assumir os cinco itens. Um broker MQTT gerenciado como o ConnectMQ cuida deles: você cria um broker no portal e recebe usuário, senha e client ID gerados, com TLS na porta 8883 e Secure WebSocket na 8084. Levar o simulador para ele é uma mudança de três linhas:
client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="YOUR_CLIENT_ID")
client.username_pw_set("YOUR_USERNAME", "YOUR_PASSWORD")
client.tls_set()
Depois, conecte-se ao host do seu broker na porta 8883. O guia de boas práticas de segurança MQTT cobre o restante do checklist de hardening.
Passo 6: Visualize o Gêmeo
Um gêmeo se paga quando as pessoas olham para ele. Comece com uma visualização ao vivo simples e acrescente 3D quando os dados forem confiáveis. Este script Node.js é uma "visualização do gêmeo" no terminal que mantém o estado mais recente e sinaliza dados desatualizados, a mesma lógica que um dashboard no navegador usaria:
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);
Salve como view.mjs e execute node view.mjs. No navegador, conecte-se com wss://broker.connectmq.com:8084/mqtt e renderize o mesmo estado em uma página ou cena 3D; o tutorial de gêmeo digital com Three.js mostra como vincular valores a um modelo 3D, e o guia de MQTT sobre WebSocket explica a conexão pelo navegador.
Passo 7: Acrescente Histórico, Alertas e Itere
Uma visualização ao vivo responde "o que está acontecendo". Para responder "por quê" e "o que vem a seguir", acrescente:
- Histórico: um assinante como o Telegraf ou um pequeno script gravando a telemetria em um banco de séries temporais.
- Alertas: regras por limite sobre os valores-chave. O portal do ConnectMQ inclui regras de alerta por limite e um log de alertas, úteis antes de você construir seu próprio sistema de alertas.
- Retorno: quando a qualidade dos dados estiver comprovada, topics de comando com confirmações para alterar setpoints a partir do gêmeo.
Depois, meça o KPI do passo 1 e decida o próximo escopo. O modelo de maturidade de gêmeo digital ajuda a planejar essa progressão, e o guia de arquitetura de gêmeo digital cobre os componentes que você vai acrescentar pelo caminho.
Armadilhas Comuns
| Armadilha | Consequência | Como evitar |
|---|---|---|
| Começar pela fábrica inteira | Meses de integração antes de qualquer valor | Definir primeiro o escopo de um único ativo |
| Nomes de topics inconsistentes | Assinaturas com wildcard quebram, retrabalho depois | Fixar a hierarquia no passo 2 |
| Sem timestamps ou unidades | Histórico e análises não confiáveis | Regras de payload do passo 3 |
| Credenciais compartilhadas | Clientes derrubam uns aos outros, sem trilha de auditoria | Uma identidade por cliente |
| Sem indicador de dados desatualizados | Usuários confiam em valores antigos | Acompanhar o horário da última atualização e o Last Will |
Crie Seu Gêmeo Digital no ConnectMQ
Agora você sabe como criar um gêmeo digital, do escopo à visualização ao vivo. Prototipe no servidor MQTT público em broker.connectmq.com e migre para um broker MQTT gerenciado com credenciais privadas quando os dados reais chegarem. Crie um broker ConnectMQ Serverless gratuito, sem cartão de crédito, e conecte seu primeiro ativo hoje.
Perguntas frequentes
Quanto tempo leva para criar um gêmeo digital?
Um primeiro gêmeo de ativo com dados ao vivo e uma visualização simples pode estar rodando em dias, assim que o acesso aos dados estiver resolvido. Histórico, análises e 3D acrescentam semanas, e escalar para muitos ativos depende do esforço de integração.
Preciso de um modelo 3D para criar um gêmeo digital?
Não. Muitos gêmeos eficazes são dashboards. O 3D ajuda na compreensão espacial e na comunicação, mas pode ser acrescentado depois que a base de dados estiver funcionando.
Qual protocolo um gêmeo digital deve usar?
O MQTT é uma escolha comum para distribuir dados ao vivo porque é leve e permite que muitos consumidores compartilhem um único fluxo. Os gateways frequentemente leem OPC UA ou protocolos de CLP e publicam no MQTT.
Posso criar um gêmeo digital sem licença de plataforma?
Sim. Um broker MQTT padrão, ferramentas open source para histórico e visualização e um design de topics claro são suficientes para um gêmeo competente.
