Todo motor elétrico conta uma história antes de quebrar. Um rolamento começa a vibrar numa frequência específica. Uma correia desalinhada produz harmônicos diferentes. Um desbalanceamento crescente aparece como um pico espectral que aumenta dia após dia. O problema é que nós, humanos, só percebemos quando o barulho fica alto demais — aí já é tarde, a peça já foi pro sacrifício. E se um microcontrolador de R$ 30 pudesse ouvir essa história e te avisar semanas antes da falha?
Isso é manutenção preditiva. E graças ao TinyML, você não precisa de um PhD em processamento de sinais para implementá-la.
TinyML: IA Que Cabe no Seu Bolso
TinyML (Tiny Machine Learning) é a interseção entre machine learning e sistemas embarcados: redes neurais otimizadas para rodar em microcontroladores com kilobytes de RAM e megahertz de clock. O termo foi cunhado por Pete Warden (Google) e Matthew Stewart (Harvard) por volta de 2019, mas o campo explodiu com o lançamento do TensorFlow Lite for Microcontrollers em 2020 e, mais importante para makers, do Edge Impulse.
O Edge Impulse é uma plataforma que abstrai todo o pipeline de ML embarcado: coleta de dados do sensor → pré-processamento digital de sinais (DSP) → treinamento da rede neural → exportação do modelo como biblioteca C++ → deploy no microcontrolador. Você não escreve uma linha de rede neural. Conecta o sensor, coleta amostras, clica em “train” e exporta o modelo compilado.
Como Funciona a Detecção de Anomalias por Vibração
Um motor saudável vibra de forma previsível. Sua assinatura espectral (distribuição de energia por frequência) é estável. Quando algo começa a dar errado — um rolamento desgastado, um eixo desalinhado, uma pá quebrada — essa assinatura muda.
A abordagem clássica seria FFT (Fast Fourier Transform) + thresholds manuais. Funciona para casos simples, mas falha quando as anomalias são sutis ou quando múltiplos modos de falha coexistem. A abordagem TinyML é: treinar uma rede neural com exemplos de vibração “normal” e “anormal”, e deixar o modelo aprender sozinho quais padrões espectrais indicam problema.
Mão na Massa: Detector de Vibração Anômala
Materiais
- ESP32 DevKit (~R$ 30-50)
- MPU6050 (acelerômetro + giroscópio) (~R$ 15-25)
- Motor DC ou ventilador para simular a máquina monitorada
- Fita dupla-face ou suporte para fixar o MPU6050 no motor
Passo 1: Criar Projeto no Edge Impulse
- Crie uma conta gratuita em edgeimpulse.com.
- Crie um novo projeto → “Manutenção Preditiva Motor”.
- Conecte seu dispositivo: instale a CLI do Edge Impulse (
npm install -g edge-impulse-cli) e rodeedge-impulse-data-forwarderno computador conectado ao ESP32 via serial. - O Data Forwarder transmite os dados do sensor via serial → WebSocket → Edge Impulse cloud. A coleta é feita no navegador, mas o sensor está no ESP32.
Passo 2: Firmware do ESP32 para Coleta de Dados
Carregue este código no ESP32 usando Arduino IDE:
#include <Wire.h>
#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
Adafruit_MPU6050 mpu;
void setup() {
Serial.begin(115200);
while (!Serial);
if (!mpu.begin()) {
Serial.println("Erro: MPU6050 nao encontrado");
while (1) delay(10);
}
mpu.setAccelerometerRange(MPU6050_RANGE_8_G);
mpu.setFilterBandwidth(MPU6050_BAND_260_HZ);
mpu.setGyroRange(MPU6050_RANGE_500_DEG);
Serial.println("AccelX,AccelY,AccelZ,GyroX,GyroY,GyroZ");
}
void loop() {
sensors_event_t a, g, temp;
mpu.getEvent(&a, &g, &temp);
// Imprime em CSV para o Edge Impulse Data Forwarder
Serial.print(a.acceleration.x); Serial.print(",");
Serial.print(a.acceleration.y); Serial.print(",");
Serial.print(a.acceleration.z); Serial.print(",");
Serial.print(g.gyro.x); Serial.print(",");
Serial.print(g.gyro.y); Serial.print(",");
Serial.println(g.gyro.z);
delay(10); // ~100 Hz de amostragem
}
Passo 3: Coletar Dados de Treinamento
No Edge Impulse, crie duas classes de dados:
- Normal: grave 5 minutos de vibração com o motor funcionando normalmente.
- Anomalia: cole um peso pequeno (moeda ou parafuso) na pá do ventilador para criar desbalanceamento. Grave mais 5 minutos.
Cada amostra deve ter ~2 segundos de duração (200 amostras a 100 Hz). O Edge Impulse vai gerar automaticamente dezenas de amostras a partir das gravações longas usando janelamento.
Passo 4: Criar o Pipeline de Processamento
O bloco de processamento recomendado para vibração é o Spectral Analysis: ele calcula a FFT dos sinais de aceleração, extraindo as magnitudes de frequência como features. Isso transforma 200 amostras temporais em ~33 bins de frequência — uma representação muito mais informativa para a rede neural.
Configure: eixos = AccelX, AccelY, AccelZ. FFT length = 64. Com essa configuração, cada janela de 2 segundos produz 33 features espectrais × 3 eixos = 99 features.
Passo 5: Treinar a Rede Neural
No Edge Impulse, vá para “Impulse Design” → “Classifier” e use a arquitetura padrão (Dense neural network com 2 camadas: 20 neurons + 10 neurons). Clique em “Start Training”. Em 30 segundos, o modelo treina na nuvem e você vê a matriz de confusão.
Resultado típico para este experimento: >95% de acurácia. O modelo aprende que “Normal” tem baixa amplitude em todas as frequências, enquanto “Anomalia” tem picos espectrais característicos do desbalanceamento (tipicamente na frequência de rotação do motor).
Passo 6: Deploy no ESP32
Exporte o modelo como “Arduino library”. Baixe o ZIP, instale na Arduino IDE (Sketch → Include Library → Add .ZIP Library). Modifique o código do ESP32 para executar inferência contínua:
#include <seu_projeto_inferencing.h> // Biblioteca gerada pelo Edge Impulse
void loop() {
// Coleta 200 amostras do MPU6050 (~2s a 100 Hz)
float buffer[EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE] = {0};
for (int i = 0; i < EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE; i += 3) {
sensors_event_t a, g, temp;
mpu.getEvent(&a, &g, &temp);
buffer[i] = a.acceleration.x;
buffer[i+1] = a.acceleration.y;
buffer[i+2] = a.acceleration.z;
delay(10);
}
// Converte sinal bruto para features (igual ao bloco de processamento)
signal_t signal;
numpy::signal_from_buffer(buffer, EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE, &signal);
// Executa a inferência
ei_impulse_result_t result;
EI_IMPULSE_ERROR err = run_classifier(&signal, &result, false);
if (err == EI_IMPULSE_OK) {
float normal_score = result.classification[0].value;
float anomaly_score = result.classification[1].value;
Serial.print("Normal: "); Serial.print(normal_score);
Serial.print(" | Anomalia: "); Serial.println(anomaly_score);
if (anomaly_score > 0.8) {
Serial.println("⚠️ ALERTA: Vibração anômala detectada!");
// Aqui você pode acionar relé, enviar MQTT, notificar Telegram
}
}
}
Seu ESP32 agora é um detector de falhas em tempo real. A inferência roda no microcontrolador — zero latência de rede, zero dependência de nuvem. Apenas o sensor, o modelo compilado e o problema sendo resolvido.
Onde Isso Funciona de Verdade
Manutenção preditiva com TinyML não é só demonstração de laboratório. Empresas já usam isso em escala:
- Bombas d’água: uma fazenda nos EUA monitora 200 bombas de irrigação com ESP32 + acelerômetros, prevendo falhas com 2 semanas de antecedência. Economia: US$ 120 mil/ano em paradas não programadas.
- Ventiladores industriais: fábrica na Índia usa TinyML para detectar desbalanceamento em ventiladores de teto de grande porte, reduzindo consumo de energia e risco de acidentes.
- Máquinas CNC: makers com impressoras 3D de grande porte monitoram a vibração dos motores de passo para detectar quando as correias estão frouxas ou os rolamentos desgastados.
- Elevadores: sensores TinyML detectam padrões de vibração que precedem falhas em cabos e polias — com alerta enviado por MQTT ao painel de manutenção.
Por Que Isso Importa para o Maker
Manutenção preditiva democratizada significa que pequenas oficinas, fazendas familiares, makerspaces e startups podem competir com a indústria pesada em confiabilidade. Você não precisa de um contrato de US$ 50 mil com fornecedor de sensores industriais — precisa de um ESP32, um MPU6050 e uma conta gratuita no Edge Impulse.
O sensor que detecta vibração anômala hoje é o mesmo hardware que amanhã monitora sua impressora 3D, depois sua máquina de lavar, depois o compressor do ar-condicionado. O modelo treinado é específico para cada máquina, mas o processo é o mesmo. E quando sua lavadora te avisa que a correia está frouxa antes de ela arrebentar num sábado à tarde, você vai entender o valor de ouvir as máquinas.
Fontes e Referências
- Edge Impulse — Plataforma de TinyML para makers e profissionais
- Edge Impulse — Tutorial oficial de Manutenção Preditiva
- TensorFlow Lite for Microcontrollers — Documentação oficial
- ESP-IDF — Documentação I2C para ESP32
- Adafruit MPU6050 Library — GitHub
- TensorFlow Lite Binaries pré-compilados para ESP32
- Edge Impulse — Canal oficial no YouTube
- MPU6050 na FilipeFlop
