Sensor de monitoramento de vibração: monte um monitor de vibração MQTT para manutenção preditiva

Um sensor de monitoramento de vibração é o sistema de alerta precoce mais barato que você pode instalar em uma máquina rotativa. Neste tutorial, você vai montar um com um ESP32 e um acelerômetro, calcular RMS, pico e fator de crista no próprio dispositivo, publicar os resultados via MQTT e disparar alertas quando a vibração ultrapassar uma linha de base aprendida.

Por que a vibração é o primeiro sinal que vale a pena medir

Quase toda falha mecânica em equipamentos rotativos muda a forma como a máquina vibra antes de mudar qualquer outra coisa. Desbalanceamento, desalinhamento, parafusos de fixação soltos, rolamentos desgastados e cavitação adicionam energia em frequências características muito antes de um motor desarmar ou de um rolamento travar. A temperatura costuma subir depois e, quando um técnico finalmente ouve o ruído, o dano muitas vezes já está bem avançado.

É por isso que a vibração está no centro da maioria dos programas de manutenção preditiva. A visão geral de manutenção preditiva com IoT explica a estratégia completa; este artigo foca na parte prática: obter um valor de vibração confiável de uma máquina — uma bomba de saneamento, um ventilador de frigorífico ou uma esteira de mineradora — e levá-lo a um sistema capaz de agir sobre ele.

Você não precisa de um analisador de espectro no primeiro dia. Acompanhar a tendência de duas ou três estatísticas simples por máquina, a cada segundo ou a cada minuto, já detecta uma grande parte das falhas em desenvolvimento. O segredo é a consistência: mesmo ponto de fixação, mesmo eixo, mesmo cálculo e um histórico para comparar.

Como escolher um sensor de monitoramento de vibração

Os sensores vão de placas MEMS para hobby até acelerômetros piezoelétricos industriais. A escolha certa depende do que você quer detectar.

Neste tutorial usamos um MPU6050 porque ele custa muito pouco e ensina todos os conceitos de que você precisa. A mesma estrutura de firmware vale quando você troca por um acelerômetro melhor: amostrar uma janela, remover o offset DC, calcular as features e publicar.

A fixação importa mais do que o chip

Um sensor colado em uma chapa fina de proteção mede a chapa de proteção. Fixe a placa o mais perto possível da caixa do mancal, em uma superfície rígida, com prisioneiro, ímã forte ou epóxi industrial. Anote qual eixo aponta na direção radial e qual na axial, e nunca mova o sensor depois de coletar uma linha de base, porque um novo local significa uma nova linha de base.

Hardware e ligações

Você vai precisar de:

1. Uma placa de desenvolvimento ESP32.
2. Um módulo MPU6050 (GY-521 ou similar).
3. Quatro jumpers e um cabo USB.

Ligue VCC em 3,3 V, GND em GND, SDA no GPIO 21 e SCL no GPIO 22. Esses são os pinos I2C padrão na maioria das placas ESP32 DevKit, conforme documentado na referência de I2C do ESP32.

O que o sensor calcula

Aceleração bruta a 800 amostras por segundo significaria 2.400 números por segundo por máquina. Enviar isso via MQTT é possível, mas raramente útil para análise de tendência. Em vez disso, o ESP32 reduz cada janela de um segundo a algumas features:

• RMS (valor eficaz): a energia total da vibração. É o valor de tendência mais útil de todos.
• Pico: o maior desvio absoluto em relação à média na janela. Sensível a impactos.
• Fator de crista: pico dividido pelo RMS. Um fator de crista em alta com RMS estável é um sinal clássico de defeito incipiente em rolamentos, porque impactos curtos elevam o pico sem acrescentar muita energia.

Antes de calcular esses valores, o firmware subtrai a média de cada eixo. Isso remove a gravidade e o offset do sensor, de modo que uma máquina parada apresenta leitura próxima de zero.

Firmware: sensor de monitoramento de vibração com ESP32

O sketch abaixo lê os registradores do MPU6050 diretamente com Wire, então não depende de nenhuma biblioteca extra de sensor. Instale a PubSubClient pelo Library Manager do Arduino. Substitua o sufixo aleatório 7f3a91 por um seu, para que seus topics não colidam com os de outras pessoas no broker público.

#include <WiFi.h>
#include <Wire.h>
#include <PubSubClient.h>
#include <math.h>

const char* WIFI_SSID = "YOUR_WIFI";
const char* WIFI_PASS = "YOUR_WIFI_PASSWORD";

const char* MQTT_HOST = "broker.connectmq.com";
const uint16_t MQTT_PORT = 1883;
const char* CLIENT_ID = "vib-sensor-7f3a91";
const char* TOPIC = "connectmq/demo/7f3a91/line1/pump1/vibration";

const uint8_t MPU_ADDR = 0x68;
const int SAMPLE_HZ = 800;
const int N = SAMPLE_HZ;               // janela de um segundo
const uint32_t PERIOD_US = 1000000UL / SAMPLE_HZ;
const float LSB_PER_G = 4096.0f;       // faixa de +/-8 g

WiFiClient net;
PubSubClient mqtt(net);
float bufX[N], bufY[N], bufZ[N];

void mpuWrite(uint8_t reg, uint8_t val) {
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(reg);
  Wire.write(val);
  Wire.endTransmission();
}

bool readAccel(float &x, float &y, float &z) {
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x3B);
  if (Wire.endTransmission(false) != 0) return false;
  if (Wire.requestFrom(MPU_ADDR, (uint8_t)6) != 6) return false;
  int16_t rx = (Wire.read() << 8) | Wire.read();
  int16_t ry = (Wire.read() << 8) | Wire.read();
  int16_t rz = (Wire.read() << 8) | Wire.read();
  x = rx / LSB_PER_G;
  y = ry / LSB_PER_G;
  z = rz / LSB_PER_G;
  return true;
}

void stats(const float* b, float &rms, float &peak) {
  double mean = 0;
  for (int i = 0; i < N; i++) mean += b[i];
  mean /= N;
  double sumSq = 0;
  peak = 0;
  for (int i = 0; i < N; i++) {
    double d = b[i] - mean;
    sumSq += d * d;
    if (fabs(d) > peak) peak = fabs(d);
  }
  rms = sqrt(sumSq / N);
}

void connectWifi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) delay(250);
}

void connectMqtt() {
  while (!mqtt.connected()) {
    if (!mqtt.connect(CLIENT_ID)) delay(2000);
  }
}

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);
  Wire.setClock(400000);
  mpuWrite(0x6B, 0x00);  // acorda o sensor
  mpuWrite(0x1A, 0x01);  // DLPF: largura de banda do acelerômetro ~184 Hz
  mpuWrite(0x1C, 0x10);  // fundo de escala de +/-8 g
  connectWifi();
  mqtt.setServer(MQTT_HOST, MQTT_PORT);
  mqtt.setBufferSize(512);
}

void loop() {
  if (WiFi.status() != WL_CONNECTED) connectWifi();
  if (!mqtt.connected()) connectMqtt();
  mqtt.loop();

  uint32_t next = micros();
  for (int i = 0; i < N; i++) {
    while ((int32_t)(micros() - next) < 0) { }
    next += PERIOD_US;
    if (!readAccel(bufX[i], bufY[i], bufZ[i])) {
      bufX[i] = bufY[i] = bufZ[i] = 0;
    }
  }

  float rx, px, ry, py, rz, pz;
  stats(bufX, rx, px);
  stats(bufY, ry, py);
  stats(bufZ, rz, pz);
  float rmsMax = fmaxf(rx, fmaxf(ry, rz));
  float peakMax = fmaxf(px, fmaxf(py, pz));
  float crest = rmsMax > 0.0001f ? peakMax / rmsMax : 0;

  char payload[256];
  snprintf(payload, sizeof(payload),
    "{\"rms_g\":{\"x\":%.4f,\"y\":%.4f,\"z\":%.4f},"
    "\"peak_g\":%.4f,\"crest\":%.2f,\"fs\":%d,\"n\":%d}",
    rx, ry, rz, peakMax, crest, SAMPLE_HZ, N);

  mqtt.publish(TOPIC, payload);
  Serial.println(payload);
}

Abra um terminal e acompanhe a chegada dos valores:

mosquitto_sub -h broker.connectmq.com -p 1883 -i viewer-7f3a91 -t "connectmq/demo/7f3a91/#" -v

Dê uma batidinha na mesa ao lado do sensor e você verá o pico e o fator de crista saltarem enquanto o RMS quase não se mexe. Coloque o sensor em um ventilador em funcionamento e o RMS se acomoda em uma faixa estável. Essa faixa estável é a sua linha de base.

Transformando leituras em alertas

Um limite fixo copiado de um datasheet é um ponto de partida ruim, porque cada máquina tem o seu próprio normal. Uma abordagem melhor é aprender a linha de base de cada ativo e alertar sobre um múltiplo dela. O subscriber em Python abaixo faz exatamente isso com o paho-mqtt 2.x. Ele coleta as primeiras 300 leituras como linha de base e, depois, publica um aviso ou um alarme quando o RMS ultrapassa 2x ou 3x essa linha de base por várias janelas consecutivas.

import json
import statistics
import paho.mqtt.client as mqtt

BROKER = "broker.connectmq.com"
PREFIX = "connectmq/demo/7f3a91"
BASELINE_SAMPLES = 300
WARN_FACTOR, ALARM_FACTOR = 2.0, 3.0
CONSECUTIVE = 5

state = {}  # por ativo: samples, baseline, streak, level

def on_connect(client, userdata, flags, reason_code, properties):
    print("connected:", reason_code)
    client.subscribe(f"{PREFIX}/+/+/vibration", qos=1)

def on_message(client, userdata, msg):
    data = json.loads(msg.payload)
    rms = max(data["rms_g"].values())
    asset = "/".join(msg.topic.split("/")[3:5])
    s = state.setdefault(asset, {"samples": [], "baseline": None, "streak": 0, "level": "ok"})

    if s["baseline"] is None:
        s["samples"].append(rms)
        if len(s["samples"]) >= BASELINE_SAMPLES:
            s["baseline"] = statistics.median(s["samples"])
            print(f"{asset} baseline RMS = {s['baseline']:.4f} g")
        return

    ratio = rms / s["baseline"]
    level = "alarm" if ratio >= ALARM_FACTOR else "warning" if ratio >= WARN_FACTOR else "ok"
    s["streak"] = s["streak"] + 1 if level != "ok" else 0

    if level != s["level"] and (level == "ok" or s["streak"] >= CONSECUTIVE):
        s["level"] = level
        alert = {"asset": asset, "level": level, "rms_g": round(rms, 4),
                 "baseline_g": round(s["baseline"], 4), "ratio": round(ratio, 2)}
        client.publish(f"{PREFIX}/{asset}/alert", json.dumps(alert), qos=1, retain=True)
        print("ALERT", alert)

client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="vib-alerts-7f3a91")
client.on_connect = on_connect
client.on_message = on_message
client.connect(BROKER, 1883, keepalive=60)
client.loop_forever()

Três detalhes tornam essa solução robusta na prática. A linha de base pela mediana ignora um ou outro solavanco durante o aprendizado. A exigência de janelas consecutivas evita que uma ferramenta derrubada ou a passagem de uma empilhadeira acione alguém. E o alerta é publicado como retained message, de modo que um dashboard que se conecte depois veja imediatamente o estado de alarme atual de cada ativo.

Se você prefere não rodar código para limites básicos, o portal da ConnectMQ inclui regras de alerta por limite e um log de alertas. Você pode apontar uma regra para o campo RMS do seu topic de vibração e ver cada excursão no portal, mantendo o serviço em Python para a lógica relativa à linha de base.

Da demonstração para a produção

O servidor MQTT público é perfeito para este experimento, mas tudo o que passa por ele pode ser lido por qualquer pessoa, e ele limita os clientes a 10 mensagens por segundo. Use-o apenas para testes e protótipos, nunca para dados de produção. Para máquinas reais, migre para um broker privado:

1. Cadastre-se no portal da ConnectMQ e crie um broker. Você recebe um usuário, uma senha e um client ID gerados automaticamente.
2. Troque o ESP32 para WiFiClientSecure na porta 8883 e passe as credenciais para mqtt.connect(CLIENT_ID, USER, PASS).
3. Adote uma árvore de topics no estilo ISA-95, como acme/plant1/assembly/line1/pump1/vibration, que o portal reconhece e agrupa na visualização de dispositivos.
4. Execute o serviço de alertas sob um gerenciador de processos para que ele reinicie automaticamente.

Um broker MQTT gerenciado elimina o trabalho de aplicar patches, cuidar de certificados e planejar capacidade, o que faz diferença quando você tem dezenas de sensores publicando a cada segundo.

Checklist de solução de problemas

1. Todas as leituras estão zeradas: verifique o endereço I2C com um sketch de scanner. Algumas placas usam 0x69 quando o AD0 está em nível alto.
2. O RMS parece alto demais com a máquina desligada: ruído elétrico ou fixação solta. Reposicione o sensor e mantenha o cabo longe dos cabos de potência do motor.
3. O MQTT desconecta a cada poucos segundos: outro cliente está usando o mesmo client ID. Torne-o único.
4. Os valores parecem limitados: está ocorrendo saturação (clipping). Aumente o fundo de escala de 8 g para 16 g (0x18 no registrador 0x1C, e 2048 LSB por g).
5. Falhas em alta frequência passam despercebidas: a largura de banda do MPU6050 é limitada. Use um acelerômetro industrial para rolamentos e redutores.

Próximos passos

Quando o RMS e o fator de crista estiverem chegando de forma confiável, adicione um segundo sinal. Combinar a vibração com o monitoramento de corrente do motor ou o monitoramento de temperatura de rolamentos separa problemas elétricos de mecânicos e confirma alarmes a partir de duas fontes independentes. Quando estiver pronto para colocar os dados em contexto em toda a planta — seja uma usina, uma fábrica em Joinville ou um gêmeo digital da linha de produção —, o guia de manufatura inteligente mostra como a vibração se encaixa na espinha dorsal de dados mais ampla.

Comece a monitorar vibração na ConnectMQ

A ConnectMQ oferece a cada sensor um endpoint MQTT seguro e privado com TLS, um cliente no navegador, um explorador de topics em tempo real e alertas por limite integrados. Crie um broker no plano Serverless gratuito em app.connectmq.com, sem cartão de crédito, e leve seu monitor de vibração do topic de demonstração para a produção em minutos.

Perguntas frequentes

Qual é o melhor sensor de monitoramento de vibração para um projeto iniciante?

Um acelerômetro MEMS, como o MPU6050 ou o ADXL345, ligado a um ESP32 é o ponto de partida mais fácil. É barato, usa I2C e é bom o suficiente para acompanhar a tendência da vibração geral em ventiladores, bombas e esteiras.

Devo enviar formas de onda de vibração brutas via MQTT?

Normalmente não, no monitoramento contínuo. Envie features resumidas, como RMS, pico e fator de crista, a cada segundo, e capture rajadas curtas de dados brutos apenas quando precisar de análise espectral.

Como defino os limites de alarme de vibração?

Aprenda uma linha de base para cada máquina enquanto ela opera normalmente e, depois, alerte sobre múltiplos dessa linha de base. Exija várias janelas consecutivas acima do limite para evitar alarmes falsos.

Posso usar o broker.connectmq.com em máquinas reais?

Use o servidor MQTT público apenas para testes, porque os topics dele podem ser lidos por qualquer pessoa. Para produção, crie um broker privado com suas próprias credenciais no portal da ConnectMQ.