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: 12335

Responder esta

Respostas a este tópico

Passagem seria o Zero cross ?

Qual é o valor de amost ? Quantas amostras esta obtendo? 

Quanto tempo corresponde à essa quantidade de amostras ? 

O numero de amostra deverá corresponder à um tempo entre dois Zero cross, ou múltiplos desse tempo.

T = 1 / f = 1 / 60Hz = 16,66 ms

Um ciclo  = 16,66 ms 

Cada semiciclo = 16,66 ms / 2 = 8,33 ms

As amostras TEM que estar dentro desse tempo. Se não estiverem, o calculo de RMS estará incorreto. 

Provei isso, em tópicos anteriores.

amost = 800! Tempo total de captura esta variando de 334 a 336ms ou seja muito próximo de 20 ciclos completos, usando um Arduino R3...

Passagem ()...... vou tentar explicar como um todo

Primeiro em um setup inicial (rodado 1 vez) é necessário captura a tensão media do ACS "que esta sendo utilizado", sem carga (0.0A) e guardar este valor médio em uma variável (valormediocapturado), para os cálculos futuros... ou seja coloco meu "novo" ACS e verifico no Arduino a tensão sem carga...  era esperado 2,5V porem o Arduino leu 2,48392V, guardo este valor para os cálculos (cada ACS que eu testei até agora deu um valor um pouco diferente!)....

...A sub função passagem() verifica se o valor que esta sendo capturado na porta analógica esta bem próximo do valor médio (valormediocapturado), se tiver libera o software para continuar se não aguarda ate estar próximo de uma pseudo passagem por zero (ideia retirada da biblioteca que você tinha indicado)... esta sub-rotina funciona como uma barreira aguardando um possível melhor momento (passagem por zero) para se iniciar a captura dos dados!

A tensão Vout do ACS712 é exatamente a medade da tensão de alimentação VCC. 

É importante medir essa tensão antes de fazer as medições de corrente. 

O meu código funciona assim também.

334 / 8,33 =  40,09 

336/ 8,33 =  40,33 

Não acho que seja interessante usar esse tempo de varredura. Acredito que vai obter valores RMS incorretos. 

Minha sugestão é que use tempos multiplos de 8,33 ms.

Capturei algumas formas de onda lampada 100W tensão e corrente para ver se estavam defasadas (sensores)...

Capturei usando o filtro no osciloscópio para mostrar vpp dos dois sinais...

Amarelo corrente e o Verde tensão!

Observei que apesar do sensor de tensão deformar mais a onda (desconsiderando o ruido) ele parece melhor para "achar" o valor de zero!

Essa defasagem entre a  forma de onda de tensão e de corrente do sensor  ACS712, deve ser porque o sensor tem amplificadores operacionais internamente e um deles poderá estar invertendo a forma de onda. 

Ou então pode ser por causa do seu circuito do sensor de tensão que esta invertendo...

A inversão com certeza é do circuito do modulo de leitura de tensão... ele tem um trafo 20mA..20mA e um amp-op lm358! Os ~1,4mS restantes também deve ser do circuito de tensão!

Oi Pessoal,

alguém quer estudar o que ainda podemos fazer neste projeto?

Tamos dentro !

O que já conseguiu?

Assim que possível farei um tutorial sobre o sensor ACS712.

Aguardem.

Olá pessoal,

eu testei os programas do tópico desde o início e estou tendo problemas com variação nas medições do ACS712x05B com o Arduino Uno R3, os valores variam em 20 mV com carga e sem carga no ACS e mesmo sem o ACS conectado (com o pino análogo vazio), já conectei o ARef com capacitor cerâmico ao GND e não resolveu.

Outra questão é que só consegui 5v de saída do Arduino no pino de alimentação de dispositivos utilizando uma fonte de 12v conectado em Vin. Verifiquei em arduino.cc que não se deve utilizar fonte de 5V, devido ao risco de instabilidade, o indicado é de 7 a 12VCC. Hoje vou tentar encontrar outros capacitores que o Gustavo indicou para testar como fica.

Meu Arduino está com problemas?

Comprei os capacitores, 0,1pF não tinha... veio 1pF e vou ver como anda meu multímetro para medir a tensão de referência e acompanhar pela programação.

Abraços

Olá bom dia,  vc teria o tutorial disponível?  Preciso medir corrente continua. Tenho um ACS712 30A. Muito obrigado.

Achei esse circuito muito interessante para medição de corrente CA !

http://www.sunrom.com/p/current-sensor-20a-acs712

RSS

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço