Machine Learning

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 rode edge-impulse-data-forwarder no 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.

Tag: Machine Learning

Manutenção Preditiva com TinyML: Quando o Motor Avisa Antes de Quebrar