AJUDA COM MEDIDOR DE ENERGIA

Alguém poderia me ajudar estou tentando fazer um medidor de consumo de energia e encontrei esse código o site do laboratório de garagem mais não estou conseguindo medir a corrente real por que estou usando um sensor de corrente de 100A:50mA e o sensor utilizado para esse código foi um de 20A:1V se alguém puder me ajudar

#include <EEPROM.h>

//Baseado no programa exemplo da biblioteca EmonLib
//Carrega as bibliotecas
#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 )

EnergyMonitor emon1; 
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
//Tensao da rede eletrica
int rede = 110.0;
//Pino do sensor SCT
int pino_sct = 1;
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, 29); //Pino, calibracao - Cur Const= Ratio/BurdenR. 1800/62 = 29. 
eeprom_read(kwhTotal, flash_kwhtotal);
previousMillis = millis();
lcd.begin(16, 2);
lcd.clear();

//Informacoes iniciais display
lcd.setCursor(0,0);
lcd.print("A:");
lcd.setCursor(0,1);
lcd.print("(W):");
}
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
// Calcular o número de hoje de kWh consumido.
//kwhTotal = kwhTotal + ((realPower/1000.0) * 1.0/3600.0 * (timems/1000.0));
// Calcular o número de hoje de kWh consumido.
kwhTotal = (((Irms*127.0)/1000.0) * 1.0/3600.0 * (timems/1000.0));
kwhTotal_Acc = kwhTotal_Acc + kwhTotal;
vlreais = kwhTotal * 0.35;
vlreais_Acc = vlreais_Acc + vlreais;
//Serial.print("Watts: ");
//Serial.println(Irms*127.0); // potencia aparente
Serial.print("kwhTotal_Acc: ");
Serial.println(kwhTotal_Acc, 10);

lcd.setCursor(10,1);
lcd.print(" ");
lcd.setCursor(10,1);
lcd.print(Irms*rede,1);
/* Serial.print("Current: ");
Serial.print(Irms); // Irms 
lcd.setCursor(10,0);
lcd.print(Irms);*/
Serial.print("vlreais_Acc: ");
//Serial.print(vlreais, 10);
Serial.println(vlreais_Acc, 10);
Serial.print("");
lcd.print(" ");
lcd.setCursor(3,0);
lcd.print(vlreais, 10);
//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);
}
}

100A:50mA ou 100A:50mV?

Já agora outra questão. Qual é mesmo o sensor? Quais são as características dele? Já reparou que é necessária mais informação que “estou usando um sensor de corrente de 100A:50mA”? Pode colocar o nome do sensor (ou ainda melhor o link para o datashet)?

Aqui esta o link com as característica do sensor

http://openenergymonitor.org/emon/buildingblocks/report-yhdc-sct-013-000-current-transformer

me desculpa por não te colocado o link com informações sobre o sensor

Qual é a corrente máxima (aproximadamente) que vai ser lida? (realmente a saía do sensor é em corrente sendo assim, vai ter que se adicionar uma resistência para "converter" essa corrente em tensão e faz sentido saber o valor máximo de corrente para escolher o valor da resistência)

A corrente máxima na saída do sensor que vai ser lida e de 50 mili amperes

Parece que não nos estamos a entender muito bem. Esse é o valor que o sensor retorna quando está a ler 100A. A sua aplicação (o seu medidor de energia) vai ler 100A? Tem a certeza disso? Na zona onde vivo, a empresa que me fornece electricidade, não me disponibiliza mais do que 45. Vai monitorizar o consumo de quê?

Entendi eu quero medir uma corrente de no máximo uns 45 amperes exemplo a corrente de um chuveiro que mais ou menos 35 amperes

A partir desta página, consegue-se perceber como se configuram esse tipo de sensores. Sendo assim, e se eu percebi bem, se adicionar uma resistência de 120 Ohm (penso que este valor é suficiente para os 45A), deve substituir a linha do seu código:

emon1.current(pino_sct, 29); //Pino, calibracao - Cur Const= Ratio/BurdenR. 1800/62 = 29.

por:

emon1.current(pino_sct, 16.67); //Pino, calibracao - Cur Const= Ratio/BurdenR. = (100/0,05) / 120 = 16,67.

Se a única alteração for a mudança de sensor, o código assim deve funcionar.

muito obrigado pela ajuda