Google Sheets: Monitorando a vibração de um motor com ESP32

Você já pensou na importância da manutenção preditiva? E como a IoT pode ajudar nesse processo de coletar dados para ter um controle periódico dos equipamentos, pois isso ajuda a agilizar e otimizar os processos, já que, agiremos antecipadamente sobre o problema. Pensando nisso, nós da Crescer decidimos analisar um dos dados importantes para que o equipamento tenha uma boa vida útil, a vibração, principalmente em motores elétricos que podem gerar diversos problemas, como desgaste de rolamentos, desalinhamento de eixo e problemas estruturais. Para isso, utilizamos um acelerômetro ADXL335, um ESP32, e criamos uma planilha no Google Sheets para monitorar esses dados.

Sumário:

1. Sobre o ADXL335;

2. Como baixar a biblioteca e mudanças no código;

3. Parte prática dos testes;

APLICAÇÃO PRÁTICA

Segue a baixo a imagem com o esquemático, e o link para ter acesso a CPB32 que utilizamos em nossos projetos: https://www.crescerengenharia.com/cpb

Esquemático do projeto

1 – Sobre o ADXL335

O ADXL335 é um sensor que mede forças de aceleração, essas forças podem ser estáticas como a da gravidade ou dinâmicas causadas pela movimentação ou vibração de um sistema, o princípio do seu funcionamento está em que cada eixo possui uma chapa de material semicondutor fixa no chip, sobre essa chapa é colocado algum material flexível, e ainda sobre esse material flexível é colocado uma outra chapa que fica presa nesse material, de acordo com o movimento essa distância entre as chapas vai alternando e a capacitância também, dessa forma temos na saída do chip uma tensão variada. O módulo que utilizamos foi o GY-61, ele vem com um regulador de tensão, pois trabalha com 3,3 V e possui três sinais de saída que correspondem aos eixos X, Y e Z. Além do ADXL335 existem diversos outros como ADXL326 e ADXL377, a diferença entre eles está na sensibilidade aos movimentos, dos três, o ADXL335 é o mais sensível a movimentos.

2 – Como baixar a biblioteca e mudanças no código

Para começar, vamos baixar e instalar a biblioteca EmonLib que calcula RMS de corrente e tensão, e utilizar ela para calcular o RMS do sinal de vibração gerado por um motor e nos enviar periodicamente para que seja possível armazenar os dados. A biblioteca pode ser achada tanto para Arduino que tem uma resolução de entrada analógica de 10 bits, quanto para o ESP32 que tem uma resolução de 12 bits, nós utilizamos a do ESP32, segue o link para download: https://github.com/Savjee/EmonLib-esp32

Clique em Download ZIP para baixar a biblioteca

Com a biblioteca baixada, nós pegamos o exemplo de “current_only”, vá até arquivos > exemplos > desça até achar Emonlib-esp32 > current_only.

Depois de pegar o exemplo, precisamos fazer algumas alterações no código, pois precisamos receber três informações diferentes, referentes os eixos X, Y e Z. Adicione mais duas variáveis, e deixe o código conforme a baixo.

// EmonLibrary examples openenergymonitor.org, Licence GNU GPL V3

#include "EmonLib.h"                   // Include Emon Library

EnergyMonitor emon1;                   // Create an instance
EnergyMonitor emon2;
EnergyMonitor emon3;

void setup() {  
  Serial.begin(115200);
  
  emon1.current(36, 111.1);             // Current: input pin, calibration.
  emon2.current(39, 111.1);
  emon3.current(34, 111.1);
  
}

void loop()
{
  double Irms1 = emon1.calcIrms(100);  // Calculate Irms only
  double Irms2 = emon2.calcIrms(100);
  double Irms3 = emon3.calcIrms(100);
  
  Serial.print(0);
  Serial.print(",");
  Serial.print(15);
  Serial.print(",");
  Serial.print(Irms1);           // Irms  EIXO X (verde)
  Serial.print(",");
  Serial.print(Irms2);        // Irms   EIXO Y (laranja)
  Serial.print(",");
  Serial.print(Irms3);      // Irms   EIXO Z   (roxo)
  Serial.println();  
}

Os valores zero e quinze em “Serial.print” servem para criar uma limitação no gráfico no momento em que abrir o plotter serial, você pode alterar esses valores para aumentar ou diminuir a escala.

Preste atenção no que está na void setup(), ali são informados os pinos de entrada, como estamos utilizando o ESP32, precisamos colocar os valores de pino referente aos que vamos utilizar.

Os valores 36, 39 e 34 são os pinos que estamos utilizando

Carregue o código e abra o plotter serial para conseguir enxergar o gráfico, por padrão o código pega 1480 amostras para calcular o RMS e nos entregar o valor, você pode alterar isso nessa parte do código.

Os valores em parênteses são as quantidades de amostras

Na imagem nós colocamos o número de amostras em duzentos, isso deixa o gráfico mais “rápido”, pois os dados são entregues mais rápidos, mas pode ocasionar uma imprecisão nos resultados gerados. Mas pode ficar à vontade para alterar os valores, e perceber como isso influência na velocidade do gráfico ao abrir o plotter serial.

3 – Parte Prática

Nesse momento a movimentação do sensor está gerando os dados, nós carregamos o código para o ESP32 e analisamos os valores que eram gerados no plotter serial da IDE do Arduino, depois de alguns testes com o ADXL335 “solto”, decidimos prender o sensor no motor e começar com os testes para entender o quanto a vibração do motor influenciaria nos dados que estavam sendo enviados para o serial do Arduino.

Enviando os dados para o Google Sheets

Usamos um inversor de frequência WEG CFW100 para controlar a velocidade do motor e gerar rampas de aceleração e desaceleração. No início não aplicamos nenhum peso sobre o eixo do motor, e a cada teste íamos colocando um parafuso com porcas para simular um desbalanceamento sobre o motor, os pesos no eixo foram de 7 g, 15 g, e 25 g, colocados respectivamente cada um por vez e gerando uma rampa de aceleração e desaceleração.

Parafusos e porcas para gerar desbalanceamento

Foi possível perceber uma grande mudança através do gráfico, ou seja, o motor poderia estar no campo e eu apenas recebendo os dados em uma sala mais distante, já seria possível perceber que a vibração estava em um nível mais alto e alguma ação deveria ser tomada, ou até mesmo analisar essa curva gerada pelo gráfico e usá-la para manutenção preditiva. A cor verde representa o eixo X, a amarela o eixo Y e a roxa o eixo Z.

Gráfico no plotter serial

Agora queremos pegar esses valores e passar eles para o Google Sheets, nós já ensinamos aqui no blog da crescer, sobre como publicar dados no Google Sheets através do ESP32, segue o link para realizar essa etapa: https://www.crescerengenharia.com/post/aprenda-como-usar-o-esp32-para-publicar-dados-no-google-sheets

Se você leu e executou os passos do post sobre como usar ESP32 para publicar dados no Google Sheets, provavelmente tem baixado a biblioteca “MultTask”, nela precisamos fazer algumas alterações, que é adicionar parte do código que calcula RMS. Caso você não tenha a biblioteca “WifiClientSecure”, você pode baixar ela pelo link https://github.com/espressif/arduino-esp32 , e adicioná-la a sua IDE. Com o código MultTask aberto, na primeira aba coloque a biblioteca EmonLib.

Adicionando a biblioteca EmonLib

Na segunda aba “Task1” é onde vamos adicionar o código que vai fazer os cálculos de RMS, copie o código a baixo e coloque na aba de “Task1”.

Parte do código da segunda aba

EnergyMonitor emon1;                   // Create an instance
EnergyMonitor emon2;
EnergyMonitor emon3;

long tempoEnvio;

double Irms1;
double Irms2;
double Irms3;

double eixoX = 0;
double eixoY = 0;
double eixoZ = 0;

void Task1code( void * pvParameters ) {

    emon1.current(36, 111.1);             // Current: input pin, calibration.
    emon2.current(39, 111.1);
    emon3.current(34, 111.1);
 
  for (;;) {
    
    long ti;
    ti = micros();
    
  while (micros() - ti < 16667)
    {
      Irms1 = emon1.calcIrms(1480);  // Calculate Irms only
      Irms2 = emon2.calcIrms(1480);
      Irms3 = emon3.calcIrms(1480);

      eixoX = Irms1;
      eixoY = Irms2;
      eixoZ = Irms3;
      
      
      Serial.print(0);
      Serial.print(",");
      Serial.print(15);
      Serial.print(",");
      Serial.print(eixoX);           // Irms  EIXO X (verde)
      Serial.print(",");
      Serial.print(eixoY);        // Irms   EIXO Y (laranja)
      Serial.print(",");
      Serial.print(eixoZ);      // Irms   EIXO Z   (roxo)
      Serial.println();
    }
  }
}

O “Task2” não precisa ser nada alterado, pois ele serve para conectar e enviar os dados. Na última aba “Z_FuncoesWifi” precisa alterar as variáveis na String Request, essas variáveis serão os dados calculados na “Task1” e agora enviados para a planilha que você criou. Coloque no lugar de String Request.

String url = String("https://script.google.com") + "/macros/s/" + GScriptId + "/exec?" + "value1=" + eixoX + "&value2=" + eixoY + "&value3=" + eixoZ;

Onde estava escrito “tensaoFinal1”, “correnteFinal1” e “tempoEnvio”, agora deve ter eixoX, eixoY e eixoZ, respectivamente.

Carregue o código para o seu ESP32, e perceba agora os valores gerados na planilha e como eles alteram conforme o ADXL335 é movimentado.

Os valores enviados pelo ESP32

Agora nós refizemos o teste de provocar desbalanceamento no motor, mandando os dados para o Google Sheets e criando um gráfico para pode visualizar bem o que estava acontecendo. Repare no gráfico a diferença entre cada etapa do teste, e como fica fácil de enxergar a alteração.

As variações no gráfico conforme era colocado mais peso sobre o eixo do motor

Perceba como ficou fácil enxergar o que está acontecendo com o motor, mesmo não estando perto dele, as formas com que isso pode ajudar em uma manutenção preditiva, em vez de alguém ir periodicamente conferir essas dados no campo, eles estão vindo até a pessoa que vai analisar e tomar as decisões, isso facilita a coleta de informações e ajuda a otimizar cada vez mais o processo, prevenindo falhas inesperadas nos equipamentos.

Linkedin do autor