Ajuda - Capturar Valor - Sensor de Corrente ACS712 30a

Bom dia Pessoal,

Estou com uma grande dificuldade em conseguir capturar o valor do sensor.

Já tentei inúmeros algoritmos disponibilizados, porém o valor aparece sempre "fixo", ou seja, com algum aparelho ligado ou não, o valor permanece o mesmo.

Alguém sabe como pegar esse valor mais próximo do real possível??

Algoritmos testados que não deram certos:

int sensorPin =A0;

int sensorValue_aux = 0;
float sensorValue = 0;
float currentValue = 0;
float voltsporUnidade = 0.004887586;// 5%1023

void setup() {
Serial.begin(9600);
pinMode(sensorPin, INPUT);
}

void loop() {

for(int i=100; i>0; i--){
sensorValue_aux = (analogRead(sensorPin) -511); // le o sensor na pino analogico A0 e ajusta o valor lido ja que a saída do sensor é (1023)vcc/2 para corrente =0
sensorValue += pow(sensorValue_aux,2); // somam os quadrados das leituras.
}

sensorValue = (sqrt(sensorValue/ 100)) * voltsporUnidade; // finaliza o calculo da méida quadratica e ajusta o valor lido para volts
currentValue = (sensorValue/0.185); // calcula a corrente considerando a sensibilidade do sernsor (185 mV por amper)

// mostra o resultado no terminal
Serial.print(currentValue,3);
Serial.print(" A \n" );

sensorValue =0;

delay(100);

}
###########################################################################################################3

void setup() {
// inicializa a comunicação seral a 9600 bits por segundo:
Serial.begin(9600);
}

void loop() {
// leitura input no analog pin 0:

//aqui a leitura é mostrada entre 0 e 1023
int sensorValue = analogRead(A0);

//podemos fazer transformações para mostrar em Amperes

//O código a seguir diz para o Arduino que o valor lido pelo sensor deve ser transformado de 0 a 1023 para -30 a +30.

int outputValue = map(sensorValue, 0, 1023, -30, 30);
// mostrar valor lido pelo sensor:

Serial.print("Sensor: ");

Serial.print(sensorValue);

//mostrar valor transformado em amperes:

Serial.print(" - mA: ");

Serial.println(outputValue);

delay(3000); // Tempo entre leituras
}

#########################################################

#define Rele1 7 // Define pino de saida para rele 1
#define Rele2 8 // Define pino de saida para rele 2
const int sensorPin = A0;
float sensorValue_aux = 0;
float sensorValue = 0;
float currentValue = 0;
float voltsporUnidade = 0.0048828125;

int st_rl = 0;
String st_lamp = 0;

void setup(){
pinMode(Rele1,OUTPUT);
pinMode(Rele2,OUTPUT);
Serial.begin(9600);
}

void loop(){
char c = Serial.read();

for(int i=500; i>0; i--)
{
sensorValue_aux = (analogRead(sensorPin) -511); // le o sensor na pino analogico A0 e ajusta o valor lido ja que a saída do sensor é vcc/2 para corrente =0
sensorValue += pow(sensorValue_aux,2); // soam os quadardos das leituras no laco
}

sensorValue = (sqrt(sensorValue/ 500)) * voltsporUnidade; // finaliza o calculo da méida quadratica e ajusta o valor lido para volts
currentValue = (sensorValue/66)*1000; // calcula a corrente considerando a sensibilidade do sernsor (66 mV por amper)


if (currentValue < 0.10){
st_lamp = "Lampada apagada";
}
else{
st_lamp = "Lampada ligada";
}

if (c == 's'){
Serial.print ("Valor do st: ");
Serial.print (st_rl);
Serial.print (" Corrente: ");
Serial.print (currentValue);
Serial.print (" Status da lampada: ");
Serial.println (st_lamp);
}
if (c == 'a'){
if (st_rl == 0){
digitalWrite(Rele1, HIGH);
Serial.print ("Valor anterior do st: ");
Serial.print (st_rl);
Serial.print (" Status anterior da lampada: ");
Serial.print (st_lamp);
st_rl = 1;
Serial.print (" Valor do st mudado para: ");
Serial.print (st_rl);
Serial.print (" Status atual da lampada: ");
Serial.println (st_lamp);
}
else{
digitalWrite(Rele1, LOW);
Serial.print ("Valor do st: ");
Serial.print (st_rl);
st_rl = 0;
Serial.print (" Valor do st mudado para: ");
Serial.print (st_rl);
Serial.print (" Status da Lampada: ");
}
}


delay(5000);

}

#############################################

int VQ; //2.5 volts na saída quando corrente for 0A
int ACSPin = A2;
void setup() {
Serial.begin(9600);
VQ = determineVQ(ACSPin);
delay(1000);
}
void loop() {
Serial.print("ACS712@A2:");Serial.print(readCurrent(ACSPin),3);Serial.println(" mA");
delay(150);
}
int determineVQ(int PIN) {
Serial.print("estimating avg. quiscent voltage:");
long VQ = 0;
//read 5000 samples to stabilise value
for (int i=0; i<10000; i++)
{
VQ += abs(analogRead(PIN));
delay(1);
}

VQ /= 10000;
Serial.print(map(VQ, 0, 1023, 0, 5000));Serial.println(" mV");
return int(VQ);
}
float readCurrent(int PIN) {
int current = 0;
int sensitivity = 66;//sensibilidade para o sensor de 30 A
for (int i=0; i<50; i++)
{
current += abs(analogRead(PIN)) - VQ;
delay(1);
}
current = map(current/50, 0, 1023, 0, 5000);
return float(current)/sensitivity;
}

############################################################

const int sensorPin = A4;
float sensorValue_aux = 0;
float sensorValue = 0;
float currentValue = 0;
float voltsporUnidade = 0.0048828125;


void setup() {

Serial.begin(9600);
}


void loop() {


for(int i=500; i>0; i--)
{
sensorValue_aux = (analogRead(sensorPin) -511); // le o sensor na pino analogico A0 e ajusta o valor lido ja que a saída do sensor é vcc/2 para corrente =0
sensorValue += pow(sensorValue_aux,2); // soam os quadardos das leituras no laco
}

sensorValue = (sqrt(sensorValue/ 500)) * voltsporUnidade; // finaliza o calculo da méida quadratica e ajusta o valor lido para volts
currentValue = (sensorValue/185)*1000 ; // calcula a corrente considerando a sensibilidade do sernsor (185 mV por amper)

// mostra o resultado no terminal
Serial.print(currentValue);
Serial.print("\n" );

sensorValue =0;
delay(1000);
}

Exibições: 12340

▶ Responder esta

Respostas a este tópico

Permalink Responder até Matheus Rossato em 28 agosto 2015 at 20:51

Sim, liguei pelo cabo macho-fêmea o GND ao GND do arduino, VCC ao VCC 5V do arduino, e o OUT ao A0 do arduino e o sensor em série com a tomada e o ferro.

Permalink Responder até Matheus Rossato em 28 agosto 2015 at 20:53

Se você souber de algo mais específico para fazer a leitura desse tipo de corrente para uma placa solar ligado a uma bateria me diga, eu também preciso de outro sensor de tensão, pois o que tenho aqui é somente para ler tensões de 100 V a 220 V, ou seja, não é o que minha bateria vai armazenar, sendo valores no máximo de 24 V.

Permalink Responder até Matheus Rossato em 28 agosto 2015 at 20:55

e o led vermelho está ligado.

Permalink Responder até José Gustavo Abreu Murta em 28 agosto 2015 at 21:19

Matheus, esse teste tem que ser realizado sem carga. 

Desconecte o ferro de passar. 

// Sketch para testar acuracidade das medições do pino Analógico do Arduino.

void setup() { 
  Serial.begin(9600);
}

void loop() {
  double Vcc = 5.015; // Tensão medida no pino Vcc do Arduino 
  int valor = analogRead(A0); // leitura da tensão no pino A0
  double volt = (valor / 1023.0) * Vcc; // Somente correto se Vcc = 5.0 volts
  Serial.println( volt, 4 ); // Imprime a tensão medida em A0
  delay(300);
}

Permalink Responder até José Gustavo Abreu Murta em 28 agosto 2015 at 21:38

Matheus, para medir corrente continua CC é muito mais simples !

Pode usar o mesmo código do ArduinoGroove. 

Se inverter a polaridade, acho que a tensão ficará abaixo dos 2,5V.

Permalink Responder até José Gustavo Abreu Murta em 7 setembro 2015 at 1:21

Matheus , desconecte o pino Vout do ACS712 (somente esse pino) e meça esse pino com seu multimetro. Tem que dar aprox 2,5V.

 sem carga.Se não der, seu sensor esta com problema.

Permalink Responder até Matheus Rossato em 7 setembro 2015 at 1:30

Provavelmente ele deve estar com problema, vou pedir outro. Muito obrigado.

Permalink Responder até Matheus Rossato em 11 setembro 2015 at 14:32

Boa Tarde, José Gustavo.

Comprei outro sensor de corrente do mesmo modelo de 30A e finalmente saiu os valores espardos na saída do A0


2.5247
2.5149
2.5247
2.5247
2.5149
2.5198
2.5247
2.5149
2.5198
2.5198
2.5247
2.5247
2.5198
2.5247
2.5198
2.5198
2.5198
2.5247
2.5149
2.5149
2.5149
2.5198
2.5198

Permalink Responder até Matheus Rossato em 11 setembro 2015 at 14:33

Devo então colocar no código que você fez a referência como 2.5198 certo?

Permalink Responder até José Gustavo Abreu Murta em 31 julho 2015 at 23:14

Corrigindo a minha  afirmativa de que é necessário que a Tensão de Referência precisa ser 5,00 V !

A tensão de offset do ACS712 é realmente a metade da tensão de alimentação Vcc. 

Assim a tensão Vcc usada pelo sensor é a mesma usada pelo conversor ADC do Arduino. 

http://labdegaragem.com/forum/topics/acs712-n-o-funciona?commentId=...

Permalink Responder até José Gustavo Abreu Murta em 30 julho 2015 at 22:37

Colegas, fiz uma simulação de valores usando uma planilha Excel .

Os valores simulados são de uma tensão senoidal com frequencia de 60 Hz. 

O periodo da frequencia de 60 Hz é 1/f = 1/60 = 16,666 milisegundos. 

No eixo X , dividi o periodo de 16,7 ms com divisões de 0,1 ms. 

No eixo Y , ficou a Tensão (V).  A amplitude do sinal é o valor A na formula, no caso 180 V. 

Frequencia = f = 60 Hz   

A formula usada foi essa :

   V = A x seno 2 x PI x f x ( T / 1000) 

Montei uma planilha com os cálculos da Tensão RMS. 

Numa coluna da planilha coloquei os valores dos quadrados das tensões.

A somatória de todos os quadrados deu = 2700005,685

O número de medidas foi de 167 ( 16,7 / 0,1). 

A média das somas foi  = 16167,69871

A Raiz quadrada dessa média deu = 127,1522659  !

Que beleza, meus cálculos estão corretos. Anexei a planilha Excel . 

No próximo tópico, colocarei minhas conclusões e sugestões sobre o calculo de RMS. 

Anexos
Permalink Responder até José Gustavo Abreu Murta em 31 julho 2015 at 21:31

Galera, boas notícias !!! 

Comprovei através de simulações de cálculo, usando a minha planilha Excel que os programas que usam uma quantidade aleatória de medidas para calcular a Tensão e ou corrente RMS estão todos errados !!!!

A maioria dos programas do ACS712 na web, não definem limites entre os semiciclos. 

Podem usar a planilha anexada no tópico anterior, para testes. 

Para calcular Tensão RMS, você terá que fazer medições dentro de N semiciclos da senoide. 

Isto é, N medições de 0 a 1/2 T ou de 0 a T ( período completo). 

Acredito que quanto mais semiciclos, a precisão será maior. Ainda não testei com mais do que um período da frequencia, isto é dois semiciclos (um positivo e um negativo). 

Como as tensões são multiplicadas por elas mesmas, o produto sempre será positivo. 

Eu vi isso no calculo do Open Energy (citado por mim anteriormente) e no calculo citado pelo Carlos Machado (abaixo). 

Agora é fazer um algoritmo para definir os limites das medições. 

O Open Energy, usa o cruzamento da Tensão por zero ( zero cross) para definir os limites. 

Boa !

RSS

Destaques

Registre-se no Lab de Garagem
clicando aqui

Convide um amigo para fazer parte

curso gratis de arduino

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço