Monitorando o Consumo Elétrico em Tempo Real com Arduino

Você já imaginou poder ver o quanto gasta de eletricidade que passa pelos fios da sua casa? Com o sensor ACS712 e um Arduino, isso fica tão simples quanto medir temperatura! Neste guia, você criará um medidor inteligente que mostra:

• Consumo em tempo real de qualquer aparelho
• Cálculo automático do custo na conta de luz
• Projeção de gasto mensal: Quanto gastaria por mês um aparelho

Desenvolvimento: Montagem Rápida e Código Simplificado

Componentes Necessários

• Sensor ACS712 (20A)
• Arduino Nano
  
• Jumpers

Importante: Escolha o modelo correto do ACS712 para sua aplicação (5A, 20A ou 30A).

Esquemático 

• VCC do sensor → 5V do Arduino
• GND do sensor → GND do Arduino
• OUT do sensor → A0 do Arduino

No exemplo usamos um motor como referência de aparelho, mas você pode escolher qualquer aparelho, apenas siga o limite seguro de tensão e corrente do módulo.

Biblioteca:

Vamos instalar uma biblioteca para facilitar o desenvolvimento do código:
Como na imagem acima busque na IDE do arduino a aba de bibliotecas e pesquise por “acs712”, depois verifique a biblioteca fornecida por Rob Tillaart e precione o botão de instalar.

Código

Atenção as variáveis de tensão e custo de KWh elas devem ser alteradas conforme o fornecido pela concessionária elétrica de sua região, procure em sua conta de luz esses valores.

#include <ACS712.h>

// -------------------------------------------------------------------------------------//
//                         CONFIGURAÇÕES DO SISTEMA (Ajuste aqui)                       //
// -------------------------------------------------------------------------------------//
const float TENSAO_REDE = 127.0;       // Tensão da sua rede (127V ou 220V)
const float CUSTO_KWH = 0.90;          // Custo da sua tarifa de energia por kWh (R$)

// Configurações de projeção (personalizáveis)
const int HORAS_POR_DIA = 8;           // Horas de uso diário para projeção
const int DIAS_POR_MES = 30;           // Dias de uso mensal para projeção

// FILTRO DE RUÍDO - IMPORTANTE!
const float LIMITE_MINIMO_CORRENTE = 0.100; // Corrente mínima para considerar (100mA)
const int NUMERO_AMOSTRAS = 8;         // Amostras para média

// -------------------------------------------------------------------------------------//
//                                VARIÁVEIS GLOBAIS                                     //
// -------------------------------------------------------------------------------------//
float kWh_Total = 0;                  // Consumo total acumulado em kWh
float gasto_Real_Total = 0;           // Gasto total acumulado em R$
unsigned long tempoAnterior = 0;      // Armazena o tempo da última leitura
bool sistema_Ativo = false;           // Flag para controle do estado de medição

// Inicializa o sensor ACS712 (20A no pino A0, tensão de 5V, resolução de 1023, referência da biblioteca)
//  Para 5A  use 185 mV 
//  Para 20A use 100 mV 
//  Para 30A use  66 mV 
ACS712 sensor(A0, 5.0, 1023, 100);

// -------------------------------------------------------------------------------------//
//                                     FUNÇÕES                                          //
// -------------------------------------------------------------------------------------//

// Função para filtrar ruído
float filtrarCorrente(float corrente) {
  return (corrente < LIMITE_MINIMO_CORRENTE) ? 0.0 : corrente;
}

// Função para fazer média de várias leituras
float lerCorrenteMedia() {
  float soma = 0;
  int leituras_validas = 0;
  
  for (int i = 0; i < NUMERO_AMOSTRAS; i++) {
    // Converte de mA para A e usa o valor absoluto
    float leitura = abs(sensor.mA_AC_sampling() / 1000.0);
    leitura = filtrarCorrente(leitura);
    
    soma += leitura;
    if (leitura > 0) {
      leituras_validas++;
    }
    
    delay(80); // Pequena pausa entre leituras para estabilização
  }
  
  float media = soma / NUMERO_AMOSTRAS;
  
  // Se menos da metade das leituras foram válidas, considera ruído
  if (leituras_validas < (NUMERO_AMOSTRAS / 2)) {
    return 0.0;
  }
  
  return media;
}

// -------------------------------------------------------------------------------------//
//                                      SETUP                                           //
// -------------------------------------------------------------------------------------//
void setup() {
  Serial.begin(9600);
  while (!Serial);
  
  Serial.println("Calibrando sensor...");
  sensor.autoMidPoint();
  
  Serial.println("=================================");
  Serial.println("     MEDIDOR DE CORRENTE ATIVO   ");
  Serial.println("=================================");
  Serial.print("Limite mínimo: ");
  Serial.print(LIMITE_MINIMO_CORRENTE * 1000);
  Serial.println(" mA");
  Serial.print("MidPoint: ");
  Serial.println(sensor.getMidPoint());
  Serial.println("=================================");
  Serial.println();
  
  tempoAnterior = millis();
}

// -------------------------------------------------------------------------------------//
//                                       LOOP                                           //
// -------------------------------------------------------------------------------------//
void loop() {
  // Medição da corrente com filtro
  float Irms = lerCorrenteMedia();

  // Cálculo da potência instantânea
  float potencia_W = Irms * TENSAO_REDE;

  // Cálculo do consumo e gasto acumulado
  unsigned long tempoAtual = millis();
  
  // Calcula o tempo decorrido desde a última medição
  float delta_Segundos = (tempoAtual - tempoAnterior) / 1000.0;
  
  // Se houver uma corrente detectada, calcula o consumo
  if (Irms > 0) {
    float consumo_Instantaneo_Wh = (potencia_W * delta_Segundos) / 3600.0;
    float gasto_Instantaneo_Reais = (consumo_Instantaneo_Wh / 1000.0) * CUSTO_KWH;

    kWh_Total += consumo_Instantaneo_Wh / 1000.0; // Adiciona ao total em kWh
    gasto_Real_Total += gasto_Instantaneo_Reais;  // Adiciona ao total em R$
  }
  
  tempoAnterior = tempoAtual;

  // Exibição dos dados no monitor serial
  Serial.println("=================================");
  
  if (Irms > 0) {
    // APARELHO CONECTADO - Mostra dados completos
    Serial.println("APARELHO DETECTADO");
    Serial.println("---------------------------------");
    
    Serial.print("Corrente: ");
    Serial.print(Irms, 3);
    Serial.println(" A");
    
    Serial.print("Potência: ");
    Serial.print(potencia_W, 1);
    Serial.println(" W");
    
    Serial.println();
    
    Serial.println("GASTO EM TEMPO REAL");
    Serial.println("---------------------------------");
    Serial.print("Energia acumulada: ");
    Serial.print(kWh_Total, 4);
    Serial.println(" kWh");
    Serial.print("Custo total: R$ ");
    Serial.println(gasto_Real_Total, 4);
    Serial.println();
    
    Serial.println("PROJEÇÃO DE CUSTOS");
    Serial.println("---------------------------------");
    
    // Cálculos de projeção
    float custoPorHora = (potencia_W / 1000.0) * CUSTO_KWH;
    float custoPorDia = custoPorHora * HORAS_POR_DIA;
    float custoPorMes = custoPorDia * DIAS_POR_MES;
    
    float consumoDiario = (potencia_W * HORAS_POR_DIA) / 1000.0;
    float consumoMensal = consumoDiario * DIAS_POR_MES;
    
    // Projeção por hora
    Serial.print("Por hora: R$ ");
    Serial.print(custoPorHora, 3);
    Serial.print(" (");
    Serial.print(potencia_W / 1000.0, 3);
    Serial.println(" kWh)");
    
    // Projeção por dia
    Serial.print("Por dia: R$ ");
    Serial.print(custoPorDia, 2);
    Serial.print(" (");
    Serial.print(consumoDiario, 2);
    Serial.print(" kWh em ");
    Serial.print(HORAS_POR_DIA);
    Serial.println("h)");
    
    // Projeção por mês
    Serial.print("Por mês: R$ ");
    Serial.print(custoPorMes, 2);
    Serial.print(" (");
    Serial.print(consumoMensal, 1);
    Serial.print(" kWh em ");
    Serial.print(DIAS_POR_MES);
    Serial.println(" dias)");
    
  } else {
    // SEM CARGA - Mensagem simples
    Serial.println("CONECTE UM APARELHO PARA MEDIR");
    Serial.println("---------------------------------");
    Serial.println("Aguardando detecção de corrente...");
    Serial.print("(limite mínimo de corrente: ");
    Serial.print(LIMITE_MINIMO_CORRENTE * 1000);
    Serial.println(" mA)");
  }
  
  Serial.println("=================================");
  Serial.println();

  delay(2500); // Espera 2.5 segundos entre leituras
}

Unidades de medidas

Pense na eletricidade como um rio:

• Corrente (A) = Volume de água passando por segundo
• Tensão (V) = Força da correnteza
• Potência (W) = Força total do rio = Corrente × Tensão
• Energia (kWh) = Água acumulada no reservatório

Baseado nisso conseguimos fazer alguns cálculos com os dados do sensor.

O que calculamos?

Determinamos a corrente elétrica (A) do aparelho com o sensor e a biblioteca. Por exemplo, vamos usar um ferro de passar que consome 8,7 A. Calculamos a potência (W) do aparelho usando a fórmula:

Potência (W) = Corrente (A) x Tensão (V)

Considerando a tensão de 127 V, a potência do ferro é: 8,7 A × 127 V = 1105 W. Agora, para saber a energia (kWh) consumida, multiplicamos a potência pelo tempo de uso em horas e dividimos por mil para manter dentro da unidade KWh.

Energia (kWh) = [Potência (W) x Tempo (h)] / 1000

Se o ferro for usado por 2 horas: [1105 W × 2 h] / 1000 = 2,21 kWh

Por fim, calculamos o custo total multiplicando a energia consumida pelo preço do kWh na sua região.

Custo = Energia (kWh) x Preço por kWh

Se o preço do kWh for de R$ 0,90: 2,21 kWh × R$ 0,90 = R$ 1,99

O custo para usar o ferro de passar por duas horas é de R$ 1,99. Com esses dados conseguimos calcular o gasto por hora, dia, mês e fazer projeções do quanto seria a fatura mensal.

Conclusão: Para Onde Levar Seu Projeto?

Seguindo todos os passos teremos algo como no vídeo:

Com essa base simplificada, você pode:

1. Criar um dashboard online usando ESP32 e IoT
2. Acionar relés automaticamente quando o consumo passar de um limite
3. Integrar com assistentes como Alexa ou Google Home

Dica Profissional: Combine com sensor de tensão para medição 100% precisa em redes instáveis!

Sobre o Autor

Abraão da Silva Estudante de Engenharia da Computação, especializado em curiosidades aparentemente aleatórias e desenvolvimento de software. Se eu não estiver pedalando agora, estou estudando ou tentando aproveitar a energia dos raios.