arduino, eletrônica, robotica...

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();

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);
}

Curtir

1 membro curte isto

Exibições: 12341

▶ Responder esta

Respostas a este tópico

Permalink Responder até Wiechert em 29 julho 2015 at 0:02

Olá,

Discordo que os possíveis erros nas leituras sejam culpa do código.

A precisão de qualquer conversor analógico (ADC) depende da precisão da tensão de referência usada. O hardware irá fazer a conversão em função da referência (Vref).

No programa devemos fazer os cálculos usando o valor da tensão de referência usada.

De nada adianta termos um programa correto se não tivermos precisão na tensão de referência...

Abraço.

▶ Responder

Permalink Responder até José Gustavo Abreu Murta em 29 julho 2015 at 0:25

Isso esta explicado nos links citados acima...

No meu circuito de teste a tensão Vcc medida foi de 5,01 V (Analog reference) e mesmo assim o resultado foi muito instavel. Para mim os programas estão errados.

O mais sensato foi o que eu encontrei foi do link Openenergy citado em um tópico anterior.

Mas o sketch não esta adaptado ainda para o ACS712,

Estou estudando ainda.

▶ Responder

Permalink Responder até Wiechert em 29 julho 2015 at 0:39

O problema dos erros de leitura são devidos a precisão da tensão de referência, não do programa, como bem explicado nos links citados por você.

Mas ainda assim você escreveu na postagem que o erro erra no programa...

▶ Responder

Permalink Responder até José Gustavo Abreu Murta em 29 julho 2015 at 2:11

Opa! descobri mais uma modificação para estabilizar as leituras !!!

Estava lendo no Datasheet do ATmega 328, que se colocar um capacitor no pino ARef pode melhorar a estabilidade ! Sugiro a todos que conectem um capacitor de 0,1 microfarads entre o Pino ARef do Arduino e o terra. Melhora bastante a estabilidade das medições .

No ATmega328 pode-se usar três tipos de referência para o conversor ADC:

- a propria tensão Vcc (essa opção é a mais usada - por isso é preciso que Vcc seja 5,00V)

- Vref interno de 1,1 V (limita a escala de medição)

- Aref - uma tensão externa pode ser usada como referência.

A seleção dessas referências são alteradas através dos bits dos registradores internos do ATmega.

Corrigindo o que eu falei que os programas estão errados :

Na verdade eles estão calculando de forma errada !

▶ Responder

Permalink Responder até José Gustavo Abreu Murta em 29 julho 2015 at 2:34

Use esse Sketch para aferir as medições do seu Arduino :

Meça com multimetro, as tensões de Vcc e de A0 durante os testes.

// 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);
}

Meu resultado medindo a tensão do chip AD580 ( Vmedida = 2,504 V)

4 mV de erro...

2.5001
2.5001
2.5001
2.5001
2.5001
2.5001
2.5001
2.5001
2.5001
2.5001
2.5001
2.5001
2.5001

▶ Responder

Permalink Responder até Matheus Rossato em 28 agosto 2015 at 17:16

Boa tarde, José Gustavo.

Estou tentando fazer a leitura de corrente com esse mesmo sensor, porém nessa parte de verificar a tensão no pino A0 ele me apresenta os seguintes resultado:

7304
0.7304
0.7255
0.7255
0.7206
0.7206
0.7157
0.7157
0.7108
0.7108
0.7108
0.7157
0.7157
0.7206
0.7255
0.7255
0.7255
0.7304
0.7304
0.7353
0.7353
0.7353
0.7304
0.7304
0.7304
0.7255
0.7255
0.7206
0.7206
0.7157
0.7157
0.7157
0.7157
0.7157

o que seria isso?

Sendo que o meu vcc do meu arduino uno, está calibrado em 5.1 V corretamente.

Obrigado.

▶ Responder

Permalink Responder até Matheus Rossato em 28 agosto 2015 at 17:45

Vcc = 5241 mV
Vout = 1229 mV

Vcc = 5241 mV
Vout = 778 mV

Vcc = 5241 mV
Vout = 845 mV

Vcc = 5241 mV
Vout = 1080 mV

Vcc = 5241 mV
Vout = 1306 mV

Vcc = 5241 mV
Vout = 1034 mV

Vcc = 5241 mV
Vout = 829 mV

Vcc = 5241 mV
Vout = 886 mV

Vcc = 5241 mV
Vout = 1214 mV

Vcc = 5241 mV
Vout = 1250 mV

Vcc = 5241 mV
Vout = 927 mV

Meus valores de saida na A2 foram esses quando ligado ao ACS712 =/

▶ Responder

Permalink Responder até José Gustavo Abreu Murta em 28 agosto 2015 at 20:43

Qual código esta usando ?

Esta esquisito isso ....Deveria ter 2,5 V na saida do sensor sem carga.

Não conecte nenhum aparelho ao sensor.

▶ Responder

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

Estou utilizando o código que você postou logo acima:

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

Porém meus valores não aparecem 2,5. Eu deixei ele sem conexão a nenhuma carga. Faz dias que estou tentando mexer com esse sensor, mas ele está me dando muito trabalho. Eu acho que posso facilitar minha vida, pois estou tentando monitorar a saída de tensão e de corrente de uma placa solar ligado a uma bateria o sensor de tensão que utilizei funcionou corretamente, provavelmente não preciso fazer leitura de uma corrente AC e sim uma DC.

Mas em casa testando com um ferro de 1200W e tensão de 126.7 o código que você utilizou aqui "arduinogroove" ele fica oscilando entre 11 - 6 amperes tem algo de muito errado.

O problema de testar ele com um sinal DC é que geralmente a corrente é baixa e para testar ele com corrente baixa o problema deve ser muito maior.

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

Matheus use o código que eu havia postado aqui:

http://labdegaragem.com/forum/topics/ajuda-capturar-valor-sensor-de...

Não use o código do Vitor, pois ele fez modificações incorretas.

Permalink Responder até Matheus Rossato em 7 setembro 2015 at 0:40

José Gustavo, eu inseri o capacitor de 0.1uF entre o ARef e o terra, e em coloquei o VCC - 5V, GND - GND, OUT - A0 no sensor ACS712 30A. Medi a saída do arduino que deu aproximadamente 5.045 V corrigi esse valor para o código de medição e os valores apresentado no serial foram os seguintes:

0.9962
1.0258
1.0258
1.0406
1.0060
1.0011
1.0110
1.0504
1.0110
1.0159
1.0060
1.0159
1.0258
1.0504
1.0060
1.0011
1.0060
1.0110
1.0110
1.0011
1.0011
1.0110
1.0110
1.0159
1.0258
1.0307