O CEP em tempo real tira o controle estatístico de processo (CEP, ou SPC em inglês) de um exercício semanal em planilha e o transforma em um sinal ao vivo no chão de fábrica. Neste tutorial você vai transmitir medições via MQTT, calcular limites de controle X-barra e R em Python, verificar cada novo subgrupo contra as regras da Western Electric e exibir pontos fora de controle em um dashboard ao vivo poucos segundos após a medição.
Por que o CEP deve ser em tempo real
O controle estatístico de processo separa a variação normal, de causas comuns, das causas especiais, como uma ferramenta desgastada, um novo lote de material ou uma mudança de temperatura. Seu objetivo é reagir antes que as peças saiam da especificação. Esse objetivo vai por água abaixo se as cartas forem atualizadas no fim do turno com valores digitados à mão: a essa altura o processo pode ter derivado por horas.
Quando as medições já fluem de instrumentos em linha, como descrito em controle de qualidade com IoT na manufatura, não há motivo para esperar. Um pequeno serviço pode manter a carta de controle continuamente e alertar o operador na primeira violação de regra.
Fundamentos de CEP em cinco minutos
Este tutorial usa a clássica carta X-barra e R, adequada a medições feitas em pequenos subgrupos (aqui, cinco peças consecutivas).
Para cada subgrupo você calcula:
- X-barra: a média dos cinco valores. Acompanha o centro do processo.
- R: a amplitude (máximo menos mínimo). Acompanha a variação de curto prazo.
A partir de um conjunto inicial de subgrupos sob controle (normalmente de 20 a 25), você calcula a média geral (X-duas-barras) e a amplitude média (R-barra) e, em seguida, os limites de controle usando as constantes padrão para subgrupos de tamanho 5:
| Carta | Linha central | Limite superior de controle | Limite inferior de controle |
|---|---|---|---|
| X-barra | X-duas-barras | X-duas-barras + A2 x R-barra | X-duas-barras - A2 x R-barra |
| R | R-barra | D4 x R-barra | D3 x R-barra |
Para n = 5, as constantes são A2 = 0,577, D3 = 0 e D4 = 2,114.
Os limites de controle vêm do próprio processo, não da especificação. Um processo pode estar sob controle e ainda assim produzir peças fora de especificação se não for capaz, e pode estar fora de controle enquanto todas as peças continuam dentro da tolerância. É exatamente nesse segundo caso que o CEP em tempo real se paga.
Regras para sinais de fora de controle
| Regra | Sinal | Causa típica |
|---|---|---|
| 1 | Um ponto além de um limite de controle | Causa especial súbita: ajuste errado, ferramenta quebrada |
| 2 | Dois de três pontos consecutivos além de 2 sigma do mesmo lado | Deslocamento começando |
| 3 | Quatro de cinco pontos consecutivos além de 1 sigma do mesmo lado | Deslocamento sustentado menor |
| 4 | Oito pontos consecutivos do mesmo lado da linha central | A média do processo mudou |
Estas são as regras da Western Electric. Aplicar as quatro aumenta a sensibilidade, mas também a taxa de alarmes falsos, por isso muitas plantas começam com as regras 1 e 4.
Arquitetura
gauge / simulator --> .../station40/measurement --> MQTT broker
|
SPC service (Python) subscribes
|
.../station40/spc/limits (retained) + .../station40/spc/point
|
live dashboard subscribes (WSS)
No tutorial, tudo roda no servidor MQTT público em broker.connectmq.com, que serve para testes e protótipos. Escolha um ID aleatório e use-o em todos os topics para que seus dados não se misturem com os de outras pessoas.
Passo 1: simule uma estação de medição
Se você ainda não tem um instrumento conectado, este simulador publica o diâmetro de um furo duas vezes por segundo. Depois de 200 peças, ele introduz uma deriva lenta para cima, do tipo causado por desgaste de ferramenta ou dilatação térmica.
import json
import random
import time
from datetime import datetime, timezone
import paho.mqtt.client as mqtt
TOPIC = "connectmq/demo/3d9c57/line3/station40/measurement"
client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="spc-sim-3d9c57")
client.connect("broker.connectmq.com", 1883, keepalive=60)
client.loop_start()
part = 0
while True:
part += 1
drift = max(0, part - 200) * 0.00004
value = random.gauss(22.000 + drift, 0.003)
msg = {"ts": datetime.now(timezone.utc).isoformat(timespec="milliseconds"),
"serial": f"A3-{part:06d}", "value": round(value, 4)}
client.publish(TOPIC, json.dumps(msg), qos=1)
time.sleep(0.5)
Passo 2: o serviço de CEP em tempo real
O serviço coleta subgrupos de cinco, usa os primeiros 25 subgrupos para calcular os limites de controle (Fase I), publica os limites como mensagem retained e depois avalia cada novo subgrupo contra as regras (Fase II). Cada subgrupo avaliado é publicado como um ponto, com as eventuais violações anexadas.
import json
import statistics
from collections import deque
import paho.mqtt.client as mqtt
BASE = "connectmq/demo/3d9c57/line3/station40"
N = 5
PHASE1_SUBGROUPS = 25
A2, D3, D4 = 0.577, 0.0, 2.114
buffer = []
phase1 = []
limits = None
history = deque(maxlen=8) # valores X-barra recentes
def zone(x):
sigma = (limits["ucl_x"] - limits["cl_x"]) / 3
return (x - limits["cl_x"]) / sigma
def check_rules(xbar, r):
v = []
if not limits["lcl_x"] <= xbar <= limits["ucl_x"]:
v.append("rule1_xbar")
if r > limits["ucl_r"]:
v.append("rule1_range")
z = [zone(x) for x in history]
for side in (1, -1):
if len(z) >= 3 and sum(1 for s in z[-3:] if s * side > 2) >= 2:
v.append("rule2")
if len(z) >= 5 and sum(1 for s in z[-5:] if s * side > 1) >= 4:
v.append("rule3")
if len(z) == 8 and all(s * side > 0 for s in z):
v.append("rule4")
return sorted(set(v))
def on_connect(client, userdata, flags, reason_code, properties):
client.subscribe(f"{BASE}/measurement", qos=1)
def on_message(client, userdata, msg):
global limits
buffer.append(json.loads(msg.payload))
if len(buffer) < N:
return
values = [m["value"] for m in buffer]
serials = [buffer[0]["serial"], buffer[-1]["serial"]]
buffer.clear()
xbar, r = statistics.fmean(values), max(values) - min(values)
if limits is None:
phase1.append((xbar, r))
if len(phase1) == PHASE1_SUBGROUPS:
xbb = statistics.fmean(x for x, _ in phase1)
rbar = statistics.fmean(rr for _, rr in phase1)
limits = {"cl_x": xbb, "ucl_x": xbb + A2 * rbar, "lcl_x": xbb - A2 * rbar,
"cl_r": rbar, "ucl_r": D4 * rbar, "lcl_r": D3 * rbar, "n": N}
client.publish(f"{BASE}/spc/limits", json.dumps(limits), qos=1, retain=True)
print("limits", limits)
return
history.append(xbar)
violations = check_rules(xbar, r)
point = {"xbar": round(xbar, 5), "range": round(r, 5),
"serials": serials, "violations": violations,
"in_control": not violations}
client.publish(f"{BASE}/spc/point", json.dumps(point), qos=1)
if violations:
client.publish(f"{BASE}/spc/alarm", json.dumps(point), qos=1, retain=True)
print("OUT OF CONTROL", point)
client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="spc-service-3d9c57")
client.on_connect = on_connect
client.on_message = on_message
client.connect("broker.connectmq.com", 1883, keepalive=60)
client.loop_forever()
Rode o simulador e o serviço em dois terminais. Depois de 125 peças (cerca de um minuto), os limites aparecem. Pouco depois da peça 200 a deriva começa e, em aproximadamente cem peças, você normalmente verá violações das regras 4, 3 ou 2, enquanto cada peça individual ainda está bem dentro de uma especificação típica. Esse é o aviso antecipado que o CEP foi feito para dar.
Passo 3: um dashboard de CEP ao vivo
Qualquer dashboard compatível com MQTT pode assinar spc/limits e spc/point. O script MQTT.js abaixo é uma visualização mínima ao vivo que se conecta via WebSocket seguro, exatamente como faria um dashboard no navegador, e imprime cada subgrupo como uma posição entre os limites de controle, marcando as violações. Instale com npm install mqtt e execute com Node.js 18 ou superior.
const mqtt = require("mqtt");
const BASE = "connectmq/demo/3d9c57/line3/station40/spc";
const client = mqtt.connect("wss://broker.connectmq.com:8084/mqtt", {
clientId: "spc-dash-3d9c57",
protocolVersion: 5,
});
let limits = null;
client.on("connect", () => {
client.subscribe([`${BASE}/limits`, `${BASE}/point`], { qos: 1 });
console.log("connected, waiting for limits...");
});
client.on("message", (topic, payload) => {
const data = JSON.parse(payload.toString());
if (topic.endsWith("/limits")) {
limits = data;
console.log(`LCL ${data.lcl_x.toFixed(4)} CL ${data.cl_x.toFixed(4)} UCL ${data.ucl_x.toFixed(4)}`);
return;
}
if (!limits) return;
const width = 41;
const span = limits.ucl_x - limits.lcl_x;
let pos = Math.round(((data.xbar - limits.lcl_x) / span) * (width - 1));
const outside = pos < 0 || pos > width - 1;
pos = Math.min(Math.max(pos, 0), width - 1);
const line = Array(width).fill(" ");
line[Math.floor(width / 2)] = "|";
line[pos] = outside ? "X" : data.in_control ? "o" : "!";
const flags = data.violations.length ? data.violations.join(",") : "";
console.log(`[${line.join("")}] ${data.xbar.toFixed(4)} R=${data.range.toFixed(4)} ${flags}`);
});
Como os limites são retained, o dashboard desenha corretamente mesmo que seja iniciado muito depois do serviço de CEP. Em uma página web, o mesmo código roda com a versão para navegador do MQTT.js e alimenta uma biblioteca de gráficos em vez do console. O explorador de topics ao vivo do portal ConnectMQ também é útil para acompanhar spc/point e spc/alarm enquanto você ajusta as regras.
Reagindo aos sinais do CEP em tempo real
Uma carta em que ninguém age é só decoração. Antes de ligar os alarmes, combine com a equipe da linha o que cada sinal significa e o que acontece em seguida. Uma violação da regra 1 na carta X-barra geralmente exige uma verificação imediata das últimas peças e do ajuste da máquina. Uma sequência da regra 4, com pontos de um lado só da linha central, indica um deslocamento gradual, como desgaste de ferramenta ou dilatação térmica, então a reação pode ser um ajuste de offset da ferramenta ou uma troca antecipada. Uma violação da regra 1 na carta R significa que a variação aumentou, o que muitas vezes indica um dispositivo de fixação frouxo, uma aresta de corte danificada ou material inconsistente.
Registre essas reações em um plano de ação curto para fora de controle por característica e exiba-o ao lado da carta. Correlacionar os sinais do CEP com dados do spindle vindos do monitoramento de desgaste de ferramentas é uma boa forma de confirmar se um deslocamento está ligado à ferramenta antes que alguém mexa na máquina. Com o tempo, as causas e reações registradas se tornam a parte mais valiosa do sistema, porque mostram quais causas especiais se repetem e quais melhorias de processo as eliminariam de vez.
Preparando para produção
- Persista os limites. Armazene os limites calculados em um banco de dados ou arquivo de configuração e recalcule apenas de forma deliberada após uma mudança de processo, nunca automaticamente durante uma deriva.
- Exclua causas especiais conhecidas dos dados da Fase I. Se uma ferramenta quebrou durante o período de referência, remova esses subgrupos antes de calcular os limites.
- Uma carta por característica e receita. Produtos diferentes precisam de limites diferentes; inclua a receita no topic ou no payload.
- Registre a reação. Quando um alarme disparar, registre o que o operador encontrou e fez. CEP sem plano de reação é apenas um gráfico.
- Use um broker privado. Dados de qualidade são confidenciais. Migre para um broker MQTT gerenciado com credenciais geradas no portal e TLS na porta 8883 ou WSS na 8084.
- Use QoS 1 nas medições, para que os subgrupos não sejam formados com dados incompletos após uma falha de rede.
O CEP em tempo real também se conecta naturalmente à rastreabilidade: como cada ponto carrega a faixa de números de série do seu subgrupo, você sabe exatamente quais peças foram produzidas enquanto o processo estava fora de controle. O guia de sistema de rastreabilidade na manufatura mostra como armazenar essa relação. Para uma visão mais ampla da arquitetura de dados da planta, veja o guia de manufatura inteligente.
Transmita seus dados de CEP pelo ConnectMQ
O ConnectMQ oferece aos seus instrumentos, ao serviço de CEP e aos dashboards um único backbone MQTT 5 seguro, com TLS, acesso via WebSocket para dashboards no navegador, retained messages e um explorador de topics ao vivo. Comece no plano Serverless gratuito em app.connectmq.com, sem cartão de crédito.
Perguntas frequentes
O que é CEP em tempo real?
É o controle estatístico de processo em que as cartas de controle e a verificação das regras são atualizadas automaticamente a cada medição recebida, de modo que condições fora de controle são sinalizadas em segundos, e não no fim do turno.
Quantos subgrupos preciso para calcular os limites de controle?
De 20 a 25 subgrupos de um processo estável é a orientação mais comum. Remova os subgrupos afetados por causas especiais conhecidas antes de calcular.
Limites de controle são o mesmo que limites de especificação?
Não. Os limites de controle descrevem o que o processo realmente faz, enquanto os limites de especificação descrevem o que o cliente exige. Eles são calculados e usados de formas diferentes.
Quais regras da Western Electric devo habilitar primeiro?
Comece com um ponto além dos limites e oito pontos de um lado da linha central. Adicione as regras de zona quando os operadores confiarem nos alarmes.
