Un sensor de monitorización de vibraciones es el sistema de alerta temprana más barato que puedes instalar en una máquina rotativa. En este tutorial construirás uno con un ESP32 y un acelerómetro, calcularás en el dispositivo el RMS, el pico y el factor de cresta, publicarás los resultados por MQTT y dispararás alertas cuando la vibración supere una referencia aprendida.
Por qué la vibración es la primera señal que merece la pena medir
Casi todos los fallos mecánicos de los equipos rotativos cambian la forma en que vibra la máquina antes de cambiar cualquier otra cosa. El desequilibrio, la desalineación, los pernos de anclaje flojos, los rodamientos desgastados y la cavitación añaden energía a frecuencias características mucho antes de que salte un motor o se gripe un rodamiento. La temperatura suele subir más tarde y, cuando un técnico oye el ruido, el daño a menudo ya está muy avanzado.
Por eso la vibración está en el centro de la mayoría de los programas de mantenimiento predictivo. La visión general de mantenimiento predictivo con IoT explica la estrategia completa; este artículo se centra en la parte práctica: obtener un valor de vibración fiable de una máquina y llevarlo a un sistema que pueda actuar en consecuencia.
No necesitas un analizador de espectro desde el primer día. Seguir la tendencia de dos o tres estadísticas sencillas por máquina, cada segundo o cada minuto, detecta una gran parte de los fallos en desarrollo. La clave es la coherencia: mismo punto de montaje, mismo eje, mismo cálculo y un historial con el que comparar.
Elegir un sensor de monitorización de vibraciones
Los sensores van desde placas MEMS para aficionados hasta acelerómetros piezoeléctricos industriales. La elección correcta depende de lo que quieras detectar.
| Tipo de sensor | Uso típico | Ventajas | Limitaciones |
|---|---|---|---|
| Acelerómetro MEMS (MPU6050, ADXL345) | Prototipos, ventiladores, bombas, transportadores | Muy barato, salida digital I2C/SPI, fácil con ESP32 | Ancho de banda limitado y mayor ruido de fondo |
| Sensor de vibración MEMS industrial | Monitorización permanente de motores y bombas | Mayor ancho de banda, carcasa robusta, a menudo Modbus o IO-Link | Necesita un gateway para llegar a MQTT |
| Acelerómetro IEPE / piezoeléctrico | Rodamientos, reductoras, husillos de alta velocidad | Amplio rango de frecuencias, bajo ruido, estándar de la industria | Necesita alimentación de corriente constante y un ADC rápido |
| Sensor de vibración inalámbrico | Activos de difícil acceso o rotativos | Sin cableado, alimentado por batería | Envía resúmenes, no formas de onda en bruto |
En este tutorial usamos un MPU6050 porque cuesta muy poco y enseña todos los conceptos que necesitas. La misma estructura de firmware sirve cuando lo sustituyes por un acelerómetro mejor: muestrear una ventana, eliminar el offset de continua, calcular características y publicar.
El montaje importa más que el chip
Un sensor pegado a una chapa protectora fina mide la chapa protectora. Monta la placa lo más cerca posible del alojamiento del rodamiento, sobre una superficie rígida, con un espárrago, un imán potente o epoxi industrial. Anota qué eje apunta en dirección radial y cuál en axial, y nunca muevas el sensor una vez que hayas recogido una referencia, porque una nueva ubicación implica una nueva referencia.
Hardware y cableado
Necesitas:
- Una placa de desarrollo ESP32.
- Un módulo MPU6050 (GY-521 o similar).
- Cuatro cables de puente y un cable USB.
Conecta VCC a 3,3 V, GND a GND, SDA a GPIO 21 y SCL a GPIO 22. Son los pines I2C por defecto en la mayoría de las placas ESP32 DevKit, como se documenta en la referencia I2C del ESP32.
Qué calcula el sensor
La aceleración en bruto a 800 muestras por segundo supondría 2.400 números por segundo por máquina. Enviar eso por MQTT es posible, pero rara vez útil para seguir tendencias. En su lugar, el ESP32 reduce cada ventana de un segundo a unas pocas características:
- RMS (valor eficaz): la energía global de la vibración. El valor de tendencia más útil.
- Pico: la mayor desviación absoluta respecto a la media en la ventana. Sensible a los impactos.
- Factor de cresta: el pico dividido por el RMS. Un factor de cresta creciente con un RMS estable es un signo temprano clásico de defectos en rodamientos, porque los impactos breves elevan el pico sin añadir mucha energía.
Antes de calcularlos, el firmware resta la media de cada eje. Eso elimina la gravedad y el offset del sensor, de modo que una máquina parada da lecturas cercanas a cero.
Firmware: sensor de monitorización de vibraciones con ESP32
El siguiente sketch lee directamente los registros del MPU6050 con Wire, así que no depende de ninguna librería de sensor adicional. Instala PubSubClient desde el gestor de librerías de Arduino. Sustituye el sufijo aleatorio 7f3a91 por uno propio para que tus topics no coincidan con los de nadie más en el 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; // ventana de un segundo
const uint32_t PERIOD_US = 1000000UL / SAMPLE_HZ;
const float LSB_PER_G = 4096.0f; // rango 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); // despertar
mpuWrite(0x1A, 0x01); // DLPF, ancho de banda del acelerómetro ~184 Hz
mpuWrite(0x1C, 0x10); // fondo 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);
}
Abre una terminal y observa cómo llegan los valores:
mosquitto_sub -h broker.connectmq.com -p 1883 -i viewer-7f3a91 -t "connectmq/demo/7f3a91/#" -v
Golpea suavemente la mesa junto al sensor y verás cómo saltan el pico y el factor de cresta mientras el RMS apenas se mueve. Coloca el sensor en un ventilador en marcha y el RMS se estabilizará en una banda constante. Esa banda constante es tu referencia.
Convertir lecturas en alertas
Un umbral fijo copiado de una hoja de datos es un mal punto de partida, porque cada máquina tiene su propia normalidad. Un enfoque mejor es aprender la referencia de cada activo y alertar sobre un múltiplo de ella. El siguiente suscriptor en Python hace exactamente eso con paho-mqtt 2.x. Recoge las primeras 300 lecturas como referencia y después publica un aviso o una alarma cuando el RMS supera 2x o 3x esa referencia durante varias ventanas 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 activo: muestras, referencia, racha, nivel
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()
Tres detalles hacen que esto sea robusto en la práctica. La referencia por mediana ignora algún golpe ocasional durante el aprendizaje. La exigencia de ventanas consecutivas evita que una herramienta que cae al suelo o el paso de una carretilla elevadora alerte a nadie. Y la alerta se publica como mensaje retained, de modo que un dashboard que se conecte más tarde ve de inmediato el estado de alarma actual de cada activo.
Si prefieres no ejecutar código para los umbrales básicos, el portal de ConnectMQ incluye reglas de alerta por umbral y un log de alertas. Puedes apuntar una regla al campo RMS de tu topic de vibración y ver cada desviación en el portal, y reservar el servicio en Python para la lógica relativa a la referencia.
Pasar de la demo a producción
El servidor MQTT público gratuito es perfecto para este experimento, pero todo lo que hay en él es legible por cualquiera y limita los clientes a 10 mensajes por segundo. Para máquinas reales, pasa a un broker privado:
- Regístrate en el portal de ConnectMQ y crea un broker. Recibirás un usuario, una contraseña y un client ID generados.
- Cambia el ESP32 a
WiFiClientSecureen el puerto 8883 y pasa las credenciales amqtt.connect(CLIENT_ID, USER, PASS). - Adopta un árbol de topics de estilo ISA-95, como
acme/plant1/assembly/line1/pump1/vibration, que el portal reconoce y agrupa en su vista de dispositivos. - Ejecuta el servicio de alertas bajo un gestor de procesos para que se reinicie automáticamente.
Un broker MQTT gestionado elimina el trabajo de parches, certificados y planificación de capacidad, algo que importa cuando tienes decenas de sensores publicando cada segundo.
Checklist de solución de problemas
- Todas las lecturas son cero: comprueba la dirección I2C con un sketch de escaneo. Algunas placas usan 0x69 cuando AD0 está a nivel alto.
- El RMS parece demasiado alto con la máquina apagada: ruido eléctrico o un montaje flojo. Vuelve a fijar el sensor y aleja el cable de los cables de potencia del motor.
- MQTT se desconecta cada pocos segundos: otro cliente está usando el mismo client ID. Hazlo único.
- Los valores parecen recortados: estás saturando. Aumenta el fondo de escala de 8 g a 16 g (
0x18en el registro0x1C, y 2048 LSB por g). - Se pierden los fallos de alta frecuencia: el ancho de banda del MPU6050 es limitado. Usa un acelerómetro industrial para trabajos con rodamientos y reductoras.
Siguientes pasos
Cuando el RMS y el factor de cresta fluyan de forma fiable, añade una segunda señal. Combinar la vibración con la monitorización de la corriente del motor o la monitorización de la temperatura de rodamientos separa los problemas eléctricos de los mecánicos y confirma las alarmas desde dos fuentes independientes. Cuando estés listo para poner los datos en contexto en toda la planta, la guía de manufactura inteligente muestra cómo encaja la vibración en la columna vertebral de datos general.
Empieza a monitorizar vibraciones con ConnectMQ
ConnectMQ ofrece a cada sensor un endpoint MQTT privado y seguro con TLS, un cliente en el navegador, un explorador de topics en vivo y alertas por umbral integradas. Crea un broker en el plan gratuito Serverless en app.connectmq.com, sin tarjeta de crédito, y pasa tu monitor de vibraciones del topic de demo a producción en minutos.
Preguntas frecuentes
¿Cuál es el mejor sensor de monitorización de vibraciones para un proyecto de iniciación?
Un acelerómetro MEMS como el MPU6050 o el ADXL345 en un ESP32 es el punto de partida más sencillo. Es barato, usa I2C y es suficiente para seguir la tendencia de la vibración global en ventiladores, bombas y transportadores.
¿Debo enviar formas de onda de vibración en bruto por MQTT?
Normalmente no, para la monitorización continua. Envía características resumidas como el RMS, el pico y el factor de cresta cada segundo, y captura ráfagas breves en bruto solo cuando necesites un análisis espectral.
¿Cómo fijo los umbrales de alarma de vibración?
Aprende una referencia para cada máquina mientras funciona con normalidad y alerta sobre múltiplos de esa referencia. Exige varias ventanas consecutivas por encima del límite para evitar alarmas molestas.
¿Puedo usar broker.connectmq.com para máquinas reales?
Usa el servidor público solo para pruebas, porque sus topics son legibles por cualquiera. Para producción, crea un broker privado con tus propias credenciales en el portal de ConnectMQ.
