Medidor de Energia com Arduino
No final de cada mês, muitos de nós nos preocupamos com a alta conta de luz e temos que olhar para o medidor de energia de vez em quando.
Mas e se pudermos monitorar nossos usos de eletricidade de qualquer lugar do mundo e receber um SMS / E-mail quando seu consumo de energia atingir um valor limite. Aqui estamos construindo um Projeto de Medidor de Energia baseado em IoT.
Anteriormente, construímos um circuito de medidor de energia que envia SMS sobre a conta usando o módulo GSM. Neste projeto, fazemos um medidor de energia elétrica inteligente usando Arduino e ESP8266 módulo Wi-Fi, que pode não só envia um SMS / E-mail de sua conta de eletricidade, mas também você pode monitorar os usos de energia a qualquer hora e em qualquer lugar do mundo. Aqui nós usamos um sensor de corrente ACS712 para medir o consumo de energia, vamos discutir sobre isso em breve.
Vamos ajudar a plataforma IFTTT a ligar as nossas notificações de Wi-Fi a SMS / E-mail. Também usaremos o MQTT Dashboard Android App para monitorar nossos usos de energia. Então vamos começar….
Materiais requisitados:
Arduino Uno
ESP12 / NodeMCU
Sensor de corrente ACS712-30Amp
Qualquer aparelho AC
Fios Macho/Femea
Funcionamento do Sensor de Corrente ACS712
Antes de começarmos a construir o projeto, é muito importante entendermos o funcionamento do sensor ACS712 Current, pois ele é o componente chave do projeto.
A corrente de medição, especialmente a corrente alternada, é sempre uma tarefa difícil devido ao ruído associado a um problema de isolamento inadequado, etc. Mas, com a ajuda deste módulo ACS712, que foi desenvolvido pela Allegro, tornou-se muito mais fácil.
Este módulo funciona no princípio do efeito Hall, que foi descoberto pelo Dr. Edwin Hall. De acordo com seu princípio, quando um condutor de corrente é colocado em um campo magnético, uma voltagem é gerada através de suas bordas, perpendicular às direções da corrente e do campo magnético. Não nos aprofundemos muito no conceito, mas, simplesmente, usamos um sensor de hall para medir o campo magnético em torno de um condutor de corrente. Essa medida será em termos de milivolts que chamamos de voltagem do hall. Essa medida de voltagem do hall é proporcional à corrente que estava fluindo pelo condutor.
A principal vantagem do uso do Sensor de Corrente ACS712 é que ele pode medir corrente CA e CC e também fornece isolamento entre a Carga (carga AC / DC) e a Unidade de Medição (parte Microcontrolador). Como mostrado na figura, temos três pinos no módulo que são Vcc, Vout e Ground, respectivamente.
O bloco terminal de 2 pinos é o local onde o fio condutor atual deve ser passado. O módulo trabalha em + 5V para que o Vcc seja alimentado por 5V e o terra deve ser conectado ao terra do sistema. O pino Vout possui uma tensão offset de 2500mV, ou seja, quando não há corrente fluindo através do fio, a tensão de saída será de 2500mV e quando a corrente estiver positiva, a tensão será maior que 2500mV e quando a corrente estiver negativa, o a tensão será inferior a 2500mV.
Nós estaremos usando o pino Analógico do Arduino para ler a tensão de saída (Vout) do módulo, que será de 512 (2500mV) quando não houver corrente fluindo através do fio. Esse valor será reduzido à medida que a corrente flui na direção negativa e aumentará à medida que a corrente flui na direção positiva. A tabela abaixo ajudará você a entender como a tensão de saída e o valor do ADC variam com base na corrente que passa pelo fio.
Estes valores foram calculados com base nas informações fornecidas na Ficha de Dados do ACS712. Você também pode calculá-los usando as fórmulas abaixo:
Voltage(mV) = (ADC Value/ 1023)*5000 Corrente através do fio (A) = (Vout (mv) -2500) / 18
Agora, sabemos como funciona o sensor ACS712 e o que poderíamos esperar dele. Vamos continuar com o diagrama de circuito.
Usamos este sensor para fazer o Circuito Digital Amperímetro usando o Microcontrolador PIC e o ACS712.
Diagrama de circuito para medidor de energia baseado em IoT usando Arduino e NodeMCU é dado acima, conecte ESP12 como abaixo:
Conecte o Rx do ESP12 -> Tx do Arduino.
Conecte o Tx do ESP12 -> Rx do Arduino.
Há um pino analógico disponível no NodeMCU (ESP12), podemos usar esse pino, mas a série ESP pode levar até 3,3 volts em seus pinos. Como estamos usando o sensor atual, que pode fornecer até 5 Volts, isso pode danificar nosso módulo Wi-Fi e é por isso que não estamos usando o NodeMCU autônomo.
Para fazer a saída do sensor de corrente 3.3V em vez de 5V, não podemos usar o circuito divisor de tensão entre o sensor de corrente e o pino analógico do NodeMCU porque como discutimos acima sobre o sensor de corrente que na saída de 2.5Volts, a corrente é 0Amp.
Assim, o Arduino irá ler o valor atual do sensor através do pino analógico e enviá-lo para o módulo Wi-Fi ESP12 usando a comunicação serial. Use o circuito divisor de tensão no pino do receptor NodeMCU para que o pino do receptor possa atingir o nível de 3,3 Voltagem.
Para monitorar nossos usos de energia pela internet, temos que usar o broker MQTT. Nós usaremos o broker MQTT como plataforma AdaFruit IO e seguiremos o processo abaixo para fazer este medidor de energia IoT
- Configurando uma conta AdaFruit para armazenar leituras do medidor de eletricidade.
- Criar Applet no IFTTT para Disparar SMS / E-mail para Medidor de Energia
- Códigos para o módulo Wi-Fi Arduino e ESP12.
CURSO ARDUINO ESSENCIAL
Aprenda sem sair de casa: curso 100% online, parenda de forma fácil e didática!
Configurando uma conta AdaFruit para comunicação:
Primeiro, faremos um feed no AdaFruit IO. Feed armazena os dados enviados pelo IFTTT. Para fazer o feed, siga estas etapas:
Etapa 1: – Faça login no Adafruit IO com suas credenciais ou Inscreva-se se você não tiver uma conta.
Etapa 2: -Clique em Minha conta -> Painel
Etapa 3: clique em Ações e crie um novo painel.
Etapa 4: dê nome e descrição ao seu feed e clique em Criar.
Passo 5: Clique no botão Key e anote as chaves AIO, vamos usar essa chave em nosso código.
Passo 6: Clique no botão “+” para criar um novo bloco e clique em Gauge para exibir Energy uses level. Você também pode usar uma caixa de texto simples para exibir energia.
Passo 7: Agora, digite o nome do feed e clique em Criar. Em seguida, selecione o feed e clique em Próximo passo.
Passo 8: Nas configurações de bloco, preencha o min. e valores máximos como 0 e 100, respectivamente, ou você pode modificar como quiser.
Etapa 9: Seu feed de energia foi criado com sucesso. Agora, crie feed para exibir Bill clicando no sinal “+”.
Agora, temos que vincular o AdaFruit IO ao SMS / E-mail usando o IFTTT.
Criar Applet no IFTTT para Disparar SMS / E-mail para Medidor de Energia:
Etapa 1: faça o login no IFTTT com suas credenciais.
Etapa 2: em meus aplicativos, clique em New applet
Etapa 3: clique em + this
Etapa 4: Pesquise o AdaFruit e clique nele.
Step 5: Click on Monitor a feed on AdaFruit IO.
Etapa 6: escolha Feed como fatura, Relacionamento como “igual a” e o valor limite no qual você deseja enviar um e-mail. Clique em Criar ação. Eu usei 4 como meu valor de disparo de limite.
Etapa 7: clique em + isso. Pesquise por G-mail e clique nele e faça login com suas credenciais de g-mail.
Passo 8: Clique em enviar um email para você mesmo.
Passo 9: Escreva seu assunto e corpo como mostrado e clique para criar.
Etapa 10: sua “receita” está pronta. Revise e clique em terminar.
Agora, concluímos a integração da web. Vamos seguir em frente codificando parte…
[su_feed url=”https://www.hardwarelivre.com.br/feed/” limit=”4″]
Código e Explicação:
Estamos usando comunicação serial entre o ESP12 e o Arduino. Então, temos que escrever código tanto para o Arduino quanto para o NodeMCU para transmissão e recepção.
Código para a Parte do Transmissor, ou seja, para o Arduino Uno:
O código completo do Arduino é fornecido no final deste tutorial. Usaremos biblioteca para o sensor Current, que pode ser baixado deste link.
Esta biblioteca tem uma função embutida para calcular a corrente. Você pode escrever seu código para calcular a corrente, mas esta biblioteca possui algoritmos de medição de corrente precisos.
Primeiro, inclua a biblioteca para o sensor atual como:
#include “ACS712.h”
Faça uma matriz para armazenar energia para enviá-lo para o NodeMCU.
char watt[5];
Crie uma instância para usar o ACS712-30Amp no PIN A0. Altere o primeiro argumento se você estiver usando a variante 20Amp ou 5 Amp.
ACS712 sensor(ACS712_30A, A0);
Na função de configuração, defina a taxa de transmissão de 115200 para se comunicar com o NodeMCU. Chame a função sensor.calibrate () para calibrar o sensor atual para obter leituras precisas.
void setup() {
Serial.begin(115200);
sensor.calibrate();
}
Na função loop, chamaremos sensor.getCurrentAC (); Função para obter o valor atual e armazenar na variável flutuante I. Depois de obter corrente, calcule a potência usando a fórmula P = V * I. Usamos 230V porque é o padrão comum em países europeus, altere para o seu local, se necessário
void loop() {
float V= 230;
float I = sensor.getCurrentAC();
float P = V * I;
Essas linhas convertem energia em Wh.
last_time = current_time;
current_time = millis();
Wh = Wh+ P *(( current_time -last_time) /3600000.0) ;
Agora, temos que converter este Wh em forma de caractere para enviá-lo para o NodeMCU, para este dtostrf (); irá converter um float em um array char para que ele possa ser impresso facilmente:
dtostrf(Wh, 4, 2, watt);
O formato é:
dtostrf(floatvar, StringLengthIncDecimalPoint, numVarsAfterDecimal, charbuf);
Escreva este array de caracteres para o buffer serial usando Serial.write (); função. Isso enviará o valor Wh para o NodeMCU.
Serial.write(watt);
delay(10000);
}
Código para a parte do receptor NodeMCU ESP12:
Para isso, precisamos da biblioteca AdaFruit MQTT, que pode ser baixada deste link.
Agora, abra o Arduino IDE. Vá para exemplos -> Biblioteca AdaFruit MQTT -> mqtt_esp8266
Vamos editar este código de acordo com nossas chaves AIO e credenciais de Wi-Fi e dados seriais recebidos do Arduino.
Primeiro, incluímos todas as bibliotecas do ESP12 Wi-Fi Module e do AdaFruit MQTT.
#include <ESP8266WiFi.h>
#include “Adafruit_MQTT.h”
#include “Adafruit_MQTT_Client.h”
Definimos o SSID e a Senha do seu Wi-Fi, a partir dos quais você deseja conectar o seu ESp-12e.
#define WLAN_SSID “xxxxxxxx”
#define WLAN_PASS “xxxxxxxxxxx”
Esta seção define o servidor AdaFruit e a porta do servidor que é fixada como “io.adafruit.com” e “1883” respectivamente.
#define AIO_SERVER “io.adafruit.com”
#define AIO_SERVERPORT 1883
Substitua esses campos por seu nome de usuário e chaves AIO que você copiou do site AdaFruit enquanto faz o Feed.
#define AIO_USERNAME “********”
#define AIO_KEY “******************************”
Em seguida, criamos uma classe ESP12 WiFiClient para conectar ao servidor MQTT.
WiFiClient client;
Configure a classe do cliente MQTT passando o cliente WiFi e o servidor MQTT e os detalhes de login.
Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);
Configure um feed chamado “Energia” e “fature” para publicar as alterações.
Adafruit_MQTT_Publish Power = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME “/feeds/Power”);
Adafruit_MQTT_Publish bill = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME “/feeds/bill”);
Na função de configuração, conectamos o módulo Wi-Fi ao ponto de acesso Wi-Fi.
void setup() {
Serial.begin(115200);
delay(10);
Serial.println(F(“Adafruit MQTT demo”));
// Connect to WiFi access point.
Serial.println(); Serial.println();
Serial.print(“Connecting to “);
Serial.println(WLAN_SSID);
WiFi.begin(WLAN_SSID, WLAN_PASS);
….
….
…
}
Na função loop, verificaremos os dados recebidos do Arduino e publicaremos esses dados no AdaFruit IO.
void loop() {
// Ensure the connection to the MQTT server is alive (this will make the first // connection and automatically reconnect when disconnected). See the MQTT_connect // function definition further below.
MQTT_connect();
int i=0;
float watt1;
Essa função verifica os dados recebidos do Arduino e armazena esses dados no array watt [] usando a função serial.read ().
if(Serial.available() > 0 ){
delay(100); //allows all serial sent to be received together
while(Serial.available() && i<5) {
watt[i++] = Serial.read();
}
watt[i++]=’\0′;
}
atof () função converter os caracteres para valores flutuantes e vamos armazenar este valor float em outra variável float watt1.
watt1 = atof(watt);
Calcule o valor da fatura multiplicando a energia (em Wh) pela tarifa de energia e divida-a por 1000 para gerar energia em KWh.
bill_amount = watt1 * (energyTariff/1000); // 1unit = 1kwH
Agora podemos publicar coisas!
Serial.print(F(“\nSending Power val “));
Serial.println(watt1);
Serial.print(“…”);
Esta parte do código está publicando valores de energia para o Power feed
if (! Power.publish(watt1)) {
Serial.println(F(“Failed”));
} else {
Serial.println(F(“OK!”));
}
Isso publicará a conta de eletricidade no feed de faturamento.
if (! bill.publish(bill_amount)) {
Serial.println(F(“Failed”));
} else {
Serial.println(F(“OK!”));
}
Nosso valor de fatura pode mudar rapidamente, mas o IFTTT leva tempo para acionar o applet para que essas linhas dêem tempo para o acionamento, para que possamos receber o email de limite.
Altere o valor bill_amount para o qual você deseja receber um e-mail. Além disso, altere a configuração do IOFT AdaFruit IO.
if (bill_amount==4){
for (int i =0; i<=2; i++)
{
bill.publish(bill_amount);
delay(5000);
}
bill_amount =6;
}
O código completo para Arduino e NodeMCU ESP12 é fornecido no final deste tutorial.
Agora, faça o upload dos códigos para as duas placas. Conecte seu hardware como mostrado no diagrama de circuito e abra io.adafruit.com. Abra o painel que você acabou de criar. Você verá o consumo de energia e a conta de eletricidade está sendo atualizada.
Quando sua conta chegar a INR 4, você receberá um e-mail como este.
Aplicativo Android para monitorar o consumo de eletricidade:
Você pode usar o Android App para monitorar os valores. Para isso, faça o download do aplicativo android do MQTT Dashboard na Play Store ou neste link.
Para configurar a conexão com o io.adafruit.com, siga estas etapas:
Passo 1: Abra o aplicativo e clique no sinal “+”. Preencha o Id do cliente com o que você quiser. O servidor e a porta permanecem iguais aos mostrados na captura de tela. Você receberá o nome de usuário e a senha (chave ativa) do painel do AdaFruit IO, conforme mostrado abaixo.
Chave ativa é sua senha.
Etapa 2: selecione Medidor de eletricidade e selecione Assinar. Na subscrição, dê nome e tópico amigáveis. O formato do tópico é “seu nome de usuário” / feeds / “feedname” e clique em criar.
Etapa 3: da mesma forma, faça a inscrição para o feed de faturamento.
Etapa 4: À medida que seus appliances consomem energia, os valores atualizados serão exibidos sob o Power and Bill.
É assim que você pode criar um Medidor de Energia Elétrica Inteligente, que pode não apenas ser monitorado de qualquer lugar do mundo, mas também acionar E-mail quando você tem alto consumo de eletricidade.
Código:
Code For Arduino
#include "ACS712.h"
char watt[5];
ACS712 sensor(ACS712_30A, A0);
unsigned long last_time =0;
unsigned long current_time =0;
float Wh =0 ;
void setup() {
Serial.begin(115200);
sensor.calibrate();
}
void loop() {
float V = 230;
float I = sensor.getCurrentAC();
// Serial.println(I);
float P = V * I;
last_time = current_time;
current_time = millis();
Wh = Wh+ P *(( current_time -last_time) /3600000.0) ;
dtostrf(Wh, 4, 2, watt);
Serial.write(watt);
delay(10000);
}
Code For NodeMCU
#include <ESP8266WiFi.h>
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"
#define WLAN_SSID "a*************"
#define WLAN_PASS "*******************"
char watt[5];
#define AIO_SERVER "io.adafruit.com"
#define AIO_SERVERPORT 1883
#define AIO_USERNAME "rjrishabh"
#define AIO_KEY "***********************"
WiFiClient client;
int bill_amount = 0;
unsigned int energyTariff = 8.0;
Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);
Adafruit_MQTT_Publish Power = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/Power");
Adafruit_MQTT_Publish bill = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/bill");
void MQTT_connect();
void setup() {
Serial.begin(115200);
delay(10);
Serial.println(F("Adafruit MQTT demo"));
// Connect to WiFi access point.
Serial.println(); Serial.println();
Serial.print("Connecting to ");
Serial.println(WLAN_SSID);
WiFi.begin(WLAN_SSID, WLAN_PASS);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
Serial.println("WiFi connected");
Serial.println("IP address: "); Serial.println(WiFi.localIP());
}
void loop() {
// Ensure the connection to the MQTT server is alive (this will make the first
// connection and automatically reconnect when disconnected). See the MQTT_connect
// function definition further below.
MQTT_connect();
int i=0;
float watt1;
if(Serial.available() > 0 ){
delay(100); //allows all serial sent to be received together
while(Serial.available() && i<5) {
watt[i++] = Serial.read();
}
watt[i++]='\0';
}
watt1 = atof(watt);
bill_amount = watt1 * (energyTariff/1000); // 1unit = 1kwH
Serial.print(F("\nSending Power val "));
Serial.println(watt1);
Serial.print("...");
if (! Power.publish(watt1)) {
Serial.println(F("Failed"));
} else {
Serial.println(F("OK!"));
}
if (! bill.publish(bill_amount)) {
Serial.println(F("Failed"));
} else {
Serial.println(F("OK!"));
}
if (bill_amount==4){
for (int i =0; i<=2; i++)
{
bill.publish(bill_amount);
delay(5000);
}
bill_amount =6;
}
delay(5000);
}
// Function to connect and reconnect as necessary to the MQTT server.
// Should be called in the loop function and it will take care if connecting.
void MQTT_connect() {
int8_t ret;
// Stop if already connected.
if (mqtt.connected()) {
return;
}
Serial.print("Connecting to MQTT... ");
uint8_t retries = 3;
while ((ret = mqtt.connect()) != 0) { // connect will return 0 for connected
Serial.println(mqtt.connectErrorString(ret));
Serial.println("Retrying MQTT connection in 5 seconds...");
mqtt.disconnect();
delay(5000); // wait 5 seconds
retries--;
if (retries == 0) {
// basically die and wait for WDT to reset me
while (1);
}
}
Serial.println("MQTT Connected!");
}
Fonte: Circuitdigest