ESP32 para monitoramento industrial de baixo custo

O ESP32 é provavelmente a melhor relação custo-benefício para IoT industrial que existe hoje. Por menos de R$ 50, você tem um microcontrolador com WiFi, Bluetooth, múltiplos ADCs, e capacidade de processamento suficiente para a maioria das aplicações de monitoramento. Neste guia, vamos explorar como usar ESP32 para coletar dados de máquinas industriais de forma profissional.

Por que ESP32 para indústria?

Antes de entrar no técnico, vamos entender por que o ESP32 se tornou a escolha preferida para projetos de IoT industrial em PMEs:

Custo acessível: R$ 30-80 por módulo, dependendo da variante
Conectividade nativa: WiFi 802.11 b/g/n e Bluetooth 4.2/BLE
Processamento robusto: Dual-core 240MHz, 520KB SRAM
Periféricos abundantes: ADC, DAC, I2C, SPI, UART, PWM
Comunidade ativa: Milhares de bibliotecas e exemplos disponíveis
Flexibilidade de programação: Arduino IDE, MicroPython, ESP-IDF

"Com R$ 500 em hardware você consegue monitorar uma linha de produção inteira. Há 10 anos isso custaria R$ 50.000."

Variantes do ESP32: qual escolher?

Existem várias versões do ESP32. Para aplicações industriais, recomendamos:

ESP32-WROOM-32

O modelo clássico, ideal para a maioria das aplicações. Dual-core, WiFi, Bluetooth, 38 GPIOs.

ESP32-S3

Versão mais recente com suporte a USB nativo e maior capacidade de AI/ML. Ideal para projetos com visão computacional.

ESP32-C3

Single-core RISC-V, menor consumo de energia. Bom para sensores alimentados por bateria.

Recomendação

Para monitoramento industrial, recomendamos placas de desenvolvimento como ESP32 DevKit ou TTGO T-Display (que já vem com tela). Evite módulos "bare" para projetos iniciais.

Sensores industriais compatíveis

O ESP32 pode ler praticamente qualquer tipo de sensor. Os mais úteis para indústria:

Sensores de corrente (não-invasivos)

SCT-013: Sensor de corrente AC por efeito Hall. Mede até 100A sem cortar fios
ACS712: Sensor de corrente AC/DC. Mais preciso, mas requer contato

// Leitura de sensor SCT-013 com ESP32
#include <Arduino.h>

const int sensorPin = 34;  // ADC1_CH6
const float sensibilidade = 0.066;  // 66mV/A para SCT-013-030
const float tensaoRede = 220.0;

float lerCorrente() {
    float somaQuadrados = 0;
    int amostras = 1000;

    for (int i = 0; i < amostras; i++) {
        int leitura = analogRead(sensorPin);
        float tensao = (leitura / 4095.0) * 3.3;
        float corrente = (tensao - 1.65) / sensibilidade;
        somaQuadrados += corrente * corrente;
        delayMicroseconds(100);
    }

    return sqrt(somaQuadrados / amostras);
}

float calcularPotencia(float corrente) {
    return corrente * tensaoRede;  // Potência aparente
}

Sensores de vibração

ADXL345: Acelerômetro 3 eixos, digital I2C
MPU6050: Acelerômetro + giroscópio, ideal para análise de vibração
SW-420: Sensor de vibração simples (digital)

Sensores de temperatura

DS18B20: Digital, à prova d'água, ideal para líquidos
MAX6675: Termopar tipo K, para altas temperaturas
PT100/PT1000: RTD de precisão industrial

Sensores de proximidade e contagem

Sensor indutivo: Detecta metal, ideal para contagem de peças
Sensor óptico: Detecta qualquer material
Encoder rotativo: Mede velocidade e posição

Arquitetura de um sistema de monitoramento

Um sistema de monitoramento industrial típico segue esta estrutura:

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│    SENSORES     │────▶│      ESP32      │────▶│     SERVIDOR    │
│ (Corrente, Temp,│     │  (Coleta dados, │     │ (Armazena, pro- │
│  Vibração...)   │     │   pré-processa) │     │  cessa, exibe)  │
└─────────────────┘     └─────────────────┘     └─────────────────┘
                               │                        │
                               │ WiFi                   │ HTTP/MQTT
                               │                        ▼
                               │              ┌─────────────────┐
                               └─────────────▶│   DASHBOARD     │
                                              │ (Power BI,      │
                                              │  Grafana...)    │
                                              └─────────────────┘

Camada de coleta (ESP32)

Lê sensores em intervalos definidos
Pré-processa dados (médias, RMS, etc.)
Envia para servidor via WiFi
Armazena localmente em caso de falha de conexão

Camada de armazenamento (Servidor)

Recebe dados via HTTP ou MQTT
Armazena em banco de dados de séries temporais
Processa alertas e notificações

Camada de visualização

Dashboards em tempo real
Histórico e tendências
Relatórios automatizados

Exemplo completo: Monitor de máquina

Vamos criar um monitor que coleta corrente, temperatura e vibração, e envia para um servidor:

#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <Wire.h>
#include <Adafruit_MPU6050.h>
#include <OneWire.h>
#include <DallasTemperature.h>

// Configurações WiFi
const char* ssid = "REDE_INDUSTRIAL";
const char* password = "senha_segura";

// Configurações do servidor
const char* serverUrl = "https://api.empresa.com/coleta";
const char* apiKey = "sua_api_key";

// Pinos
const int pinCorrente = 34;
const int pinTemperatura = 4;

// Objetos dos sensores
Adafruit_MPU6050 mpu;
OneWire oneWire(pinTemperatura);
DallasTemperature sensoresTemp(&oneWire);

// Identificação da máquina
const char* maquinaId = "torno_cnc_01";

void setup() {
    Serial.begin(115200);

    // Conecta WiFi
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.println("\nWiFi conectado!");

    // Inicializa sensores
    Wire.begin();
    if (!mpu.begin()) {
        Serial.println("MPU6050 não encontrado!");
    }
    sensoresTemp.begin();
}

float lerCorrente() {
    float soma = 0;
    for (int i = 0; i < 1000; i++) {
        int leitura = analogRead(pinCorrente);
        float tensao = (leitura / 4095.0) * 3.3;
        float corrente = (tensao - 1.65) / 0.066;
        soma += corrente * corrente;
        delayMicroseconds(100);
    }
    return sqrt(soma / 1000);
}

float lerTemperatura() {
    sensoresTemp.requestTemperatures();
    return sensoresTemp.getTempCByIndex(0);
}

float lerVibracao() {
    sensors_event_t a, g, temp;
    mpu.getEvent(&a, &g, &temp);

    // Calcula magnitude da aceleração
    float magnitude = sqrt(
        a.acceleration.x * a.acceleration.x +
        a.acceleration.y * a.acceleration.y +
        a.acceleration.z * a.acceleration.z
    );
    return magnitude;
}

void enviarDados(float corrente, float temperatura, float vibracao) {
    if (WiFi.status() != WL_CONNECTED) return;

    HTTPClient http;
    http.begin(serverUrl);
    http.addHeader("Content-Type", "application/json");
    http.addHeader("X-API-Key", apiKey);

    StaticJsonDocument<256> doc;
    doc["maquina"] = maquinaId;
    doc["timestamp"] = millis();
    doc["corrente"] = corrente;
    doc["temperatura"] = temperatura;
    doc["vibracao"] = vibracao;
    doc["status"] = corrente > 0.5 ? "ligada" : "desligada";

    String json;
    serializeJson(doc, json);

    int httpCode = http.POST(json);
    if (httpCode == 200) {
        Serial.println("Dados enviados com sucesso");
    } else {
        Serial.printf("Erro HTTP: %d\n", httpCode);
    }
    http.end();
}

void loop() {
    float corrente = lerCorrente();
    float temperatura = lerTemperatura();
    float vibracao = lerVibracao();

    Serial.printf("Corrente: %.2f A | Temp: %.1f °C | Vibração: %.2f m/s²\n",
                  corrente, temperatura, vibracao);

    enviarDados(corrente, temperatura, vibracao);

    delay(5000);  // Envia a cada 5 segundos
}

Protocolos de comunicação

HTTP/REST

Mais simples de implementar. Ideal para envio periódico de dados.

MQTT

Protocolo leve, ideal para IoT. Permite comunicação bidirecional e menor overhead.

// Exemplo de envio via MQTT
#include <PubSubClient.h>

WiFiClient espClient;
PubSubClient mqtt(espClient);

void setupMQTT() {
    mqtt.setServer("mqtt.empresa.com", 1883);
    mqtt.connect("esp32_torno_01", "usuario", "senha");
}

void publicarDados(float corrente) {
    char payload[50];
    sprintf(payload, "{\"corrente\":%.2f}", corrente);
    mqtt.publish("maquinas/torno_01/corrente", payload);
}

Modbus TCP

Para integração com sistemas industriais existentes (CLPs, SCADAs).

Segurança em ambiente industrial

IoT industrial exige cuidados especiais de segurança:

Rede isolada: Use VLAN separada para dispositivos IoT
HTTPS/TLS: Sempre criptografe a comunicação
Autenticação: Use API keys ou certificados
Firmware OTA: Implemente atualização remota segura
Watchdog: Configure reinício automático em caso de travamento

Atenção

Nunca conecte dispositivos IoT diretamente à internet. Use sempre um gateway ou VPN. Redes industriais são alvo frequente de ataques.

Cases práticos

Confecção: Monitoramento de máquinas de costura

Instalamos sensores de corrente em 50 máquinas de costura. O sistema detecta automaticamente quando cada máquina está operando, parada ou em manutenção. Resultado: visibilidade real da produtividade e identificação de gargalos.

Metalúrgica: Predição de falha em torno CNC

Sensor de vibração no eixo principal. Quando a vibração sai do padrão, alerta é enviado. Em 8 meses, zero paradas não programadas.

Indústria alimentícia: Monitoramento de temperatura

Sensores DS18B20 em câmaras frias com alertas via Telegram quando temperatura ultrapassa limites. Conformidade com vigilância sanitária garantida.

Próximos passos

Monte um protótipo: Compre um ESP32 e sensores básicos
Escolha uma máquina piloto: A mais crítica ou com mais problemas
Defina métricas: O que você quer medir e por quê?
Implemente gradualmente: Comece simples, expanda depois

A Blumenau TI oferece kits completos de monitoramento industrial com ESP32, incluindo hardware, firmware e integração com dashboards. Podemos ajudar desde o projeto até a implementação.

Lucas Junges

Fundador & CTO, Blumenau TI

Engenheiro especializado em sistemas embarcados e IoT industrial. Desenvolveu soluções de monitoramento para mais de 30 empresas da região.