Dúvida sobre Monitor de Energia Trifásico


#1

Boa Tarde,

Estou tentando montar um monitor de energia para minha casa que mostre o consumo instantâneo em W e o acumulado em KWh e mostre o valor acumulado da conta de energia. testei o circuito em uma das fases ligando uma lâmpada e parece que está funcionando bem, porém na minha residência o sistema é trifásico, e ai vem a dúvida: eu posso passar as 3 fases por dentro de um mesmo sensor SCT-013 100a ou necessitaria de 3 sensores? como ficaria o código? abaixo segue o meu código atual e o esquema do circuito:

//Carrega as bibliotecas
#include <EEPROM.h>
#include “EmonLib.h”
#include <LiquidCrystal.h>
#include <avr/eeprom.h>

#define eeprom_read_to(dst_p, eeprom_field, dst_size) eeprom_read_block(dst_p, (void )offsetof(__eeprom_data, eeprom_field), MIN(dst_size, sizeof((__eeprom_data)0)->eeprom_field))
#define eeprom_read(dst, eeprom_field) eeprom_read_to(&dst, eeprom_field, sizeof(dst))
#define eeprom_write_from(src_p, eeprom_field, src_size) eeprom_write_block(src_p, (void )offsetof(__eeprom_data, eeprom_field), MIN(src_size, sizeof((__eeprom_data)0)->eeprom_field))
#define eeprom_write(src, eeprom_field) { typeof(src) x = src; eeprom_write_from(&x, eeprom_field, sizeof(x)); }
#define MIN(x,y) ( x > y ? y : x )

//Cria Instância
EnergyMonitor emon1;

//Indica os pinos do display
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

//Tensao da rede eletrica
int rede = 115.0;

//Indica o pino do sensor SCT-010 000
int pino_sct = 0;

struct __eeprom_data {
double flash_kwhtotal;
};

//Cria variaveis globais
double kwhTotal;
double kwhTotal_Acc;
double vlreais;
double vlreais_Acc;
double realPower;
unsigned long ltmillis, tmillis, timems, previousMillis, refresh;
char charBuf[30];

void setup()
{
Serial.begin(9600);
emon1.current(pino_sct, 52); //Pino, calibracao
eeprom_read(kwhTotal, flash_kwhtotal);
previousMillis = millis();
lcd.begin(16, 2);
lcd.clear();

//Informacoes iniciais no display
lcd.setCursor(0,0);
lcd.print(“W:”);


lcd.setCursor(7,0);
lcd.print(“KWh:”);


lcd.setCursor(0,1);
lcd.print(“Valor (R$):”);
}

void loop()
{
// Calcula quantidade de tempo desde a última measurment realpower.
ltmillis = tmillis;
tmillis = millis();
timems = tmillis - ltmillis;
double Irms = emon1.calcIrms(1480); // Calculate Irms

//Calcula e mostra o valor da potencia
lcd.setCursor(2,0);
lcd.print(" ");
lcd.setCursor(2,0);
lcd.print(Irms*rede,0);

// Calcular o número de hoje de kWh consumido.
kwhTotal = (((Irms*115.0)/1000.0) * 1.0/3600.0 * (timems/1000.0));
kwhTotal_Acc = kwhTotal_Acc + kwhTotal;
vlreais = kwhTotal * 0.75;
vlreais_Acc = vlreais_Acc + vlreais;

Serial.print("kwhTotal_Acc: ");
Serial.println(kwhTotal_Acc, 4);


Serial.print("vlreais_Acc: ");
Serial.println(vlreais_Acc, 4);


Serial.print("");


lcd.setCursor(11,0);
lcd.println(kwhTotal_Acc, 4);


lcd.setCursor(11,1);
lcd.println(vlreais_Acc, 4);

lcd.print("");


//grava na memoria a cada 1 minuto
if ((millis() - refresh)>= 100)
refresh = millis(); //actualiza a contagem.
{
//Serial.println(“Gravando na EEprom”);
eeprom_write(kwhTotal, flash_kwhtotal);
previousMillis=millis();
}
//Multiplica pelo valor kilowatt hora R$ 0.35 Reais
//vlreais = kwhTotal * 0.35;
}

void printFloat(float value, int places) {
// this is used to cast digits
int digit;
float tens = 0.1;
int tenscount = 0;
int i;
float tempfloat = value;

// Se certificar de que arredondar corretamente. este poderia usar pow de <math.h>, mas não parece vale a importação
// Se esta etapa arredondamento não está aqui, o valor 54,321 imprime como 54,3209

// calcular arredondamento prazo d: 0,5 / pow (10, lugares)
float d = 0.5;
if (value < 0)
*d = -1.0;
// dividir por dez para cada casa decimal
for (i = 0; i < places; i++)
d/= 10.0;
// este pequeno disso, combinado com truncamento vai arredondar os nossos valores corretamente
tempfloat += d;

// Primeiro obter dezenas de valor para ser a grande potência de dez a menos do que o valor
// Tenscount não é necessário, mas seria útil se você queria saber depois desta quantos caracteres o número tomará

if (value < 0)
*tempfloat = -1.0;
while ((tens * 10.0) <= tempfloat) {
*tens = 10.0;
tenscount += 1;
}

// escrever o negativo, se necessário
if (value < 0)
Serial.print(’-’);

if (tenscount == 0)
Serial.print(0, DEC);

for (i=0; i< tenscount; i++) {
digit = (int) (tempfloat/tens);
Serial.print(digit, DEC);
tempfloat = tempfloat - ((float)digit * tens);
tens /= 10.0;
}

// se não há lugares após decimal, pare agora e retorno
if (places <= 0)
return;

// caso contrário, escreva o ponto e continuar
Serial.print(’.’);

// Agora, escrever cada casa decimal, deslocando um dígitos por uma, para o lugar queridos e escrever o valor truncado
for (i = 0; i < places; i++) {
*tempfloat = 10.0;
digit = (int) tempfloat;
Serial.print(digit,DEC);
// uma vez escrito, subtrair fora esse dígito
tempfloat = tempfloat - (float) digit;
delay(1000);
}
}


#2

Olá @lgfmoura.

Você não pode usar três fases passando pelo mesmo sensor de corrente, pois o mesmo funciona com a leitura do campo magnético de cada fase, se vc colocar duas ou mais fases no sensor de corrente estes campos eletromagnéticos se anularam. No código, para inserir mais sensores basta criar a variável corrente, corrente1, corrente2, e a mesma coisa caso for também medir a tensão.
Abraços.


#3

Ok, adquiri mais 2 sensores. Estou esperando chegar para testar e postar os resultados.