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();
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);
}
Respostas a este tópico
-
Permalink Responder até José Gustavo Abreu Murta em
-
Ok, obrigado.
Descobri o furo dos programas !
A quantidade de medições tem que ser proporcional ao tempo de cada semiciclo da senoide.
E a galera estava chutando uma quantidade variada de medições !
Por isso, tantas medições erradas
-
-
===== Segunda Parte : Medição e aferição do Vout do Sensor ACS712 .====================
Mais uma etapa de medições e aferições. Resolvi medir com o conversor ADC do Arduino, a saida Vout do Sensor ACS712-30A.
Quando não existir nenhuma corrente passando pelo sensor, a saída Vout vai ter uma tensão de Vcc / 2.
Isto consta no Data Sheet do ACS712 (dica do Alexandre Nogueira).
Essa tensão é um offset criado pelos Amplificadores Operacionais do ACS712, para que na entrada do Conversor ADC
não entre tensão negativa.
No meu Arduino , Vcc = 5009 mV, portanto Vcc / 2 = 2504 mV
Para uma aferição de boa qualidade desse offset, resolvi usar um chip que tenho - o AD580.
AD580 - High Precision, 2.5 V IC Reference
http://www.analog.com/media/en/technical-documentation/data-sheets/...
A tensão medida no AD580 foi de exatamente 2505 mV (meu multimetro Fluke 17B+).
Desenvolvi esse outro Sketch para medir e aferir a Tensão Vout com o AD580.
Depois testarei com o ACS712-30A.
Revendo o Sketch anterior , que mede o Vcc, resolvi mudar o divisor das tensões por 1023 e não por 1024.
Apesar de que, no Data Sheet do ATmega informa que deva ser 1024. Ainda não estou certo de qual o valor correto a ser usado. Estou em dúvida.
Outra alteração que fiz (acho que esta correta) foi essa :
int Vin = analogRead(A2) + 1
Ao fazer testes com o programa, sempre percebia que a medição dava 510 e não 511.
Analisando no Data Sheet do Atmega, os tipos de erros que o ADC pode ter, como calibração eu acrescentei esse 1 bit LSB a mais. E os resultados ficaram muito bons. Espero que isso não induza a novos erros.
Veja o capítulo 24.6.3 ADC Accuracy Definitions
As medições foram bem estáveis e com um pequenísimo erro de alguns milivolts ( já esperado)
Vcc = 5010 mV
Vout = 2502 mVVcc = 5010 mV
Vout = 2502 mVVcc = 5010 mV
Vout = 2502 mV
-
-
Esse é o Sketch usado para medição e aferição com o ACS712-30A.
Sem carga nenhuma, isto é sem nenhuma corrente passando pelo sensor.
Percebi que existe uma variação maior nas medições do que no Chip AD580.
Não entendi ainda porque.
Conversor ADC do Arduino já calibrado
Primeiro ReadVcc = 1.1 * 1023 * 1000 ===> Vcc = 4957 mVMedições :
Com Multimetro Vcc = 5000 mV e Vref = 2500 mV
Com Sketch Vcc = 5000 mV e Vout = 2497
-
Permalink Responder até Alexandre A. M. Nogueira em
-
Jose Gustavo dei uma olhada nas suas referencias e seu código, e escrevi baseado nelas um kádikim para um teste... só que eu ainda não tenho o sensor (tá vindo de mula lá da china)... testei no proteus mas gostaria e saber como esta comportando fisicamente com o sensor.. tem como vc fazer uns testes rápidos e me dar um retorno... tem partes escritas ainda não usadas.... esta bem bagunçado!
grato desde já Alexandre Nogueira
-
-
Alexandre, você pode encontrar esse sensor ACS712-30A aqui no Brasil, por uns 27 reais....+ frete.
Qual sensor já comprou? O de 30A é para cargas maiores.
Assim que eu puder farei um teste.
Dei uma olhada no seu código. Tá ficando bonito.
Uma observação = o calculo de Vrms = 0.707 x Vp só serve para sinais senoidais. Que é o nosso caso da rede eletrica.
Você esta correto :
Vp = Vpp/2 , isto é a tensão de pico (de um semiciclo) é a metade da Tensão de pico a pico. E esta tensão Vp que é usada no cálculo.
Eu pensei em usar esse método para o cálculo do Vrms, mas optei e, usar o método usado pelo OPenEnergy , lembrando de que ruidos podem ocorrer na tensão de pico.
-
-
José Gustavo eu calculei das duas maneiras.. lembrando que o seu fluke é RMS é bem provável de encontrar um valor próximo a VPx0.707..(Vmultimetro) na verdade para o calculo do true RMS "OPenEnergy" fiz umas modificações justamente para facilitar os ajustes finos no futuro! Separei em RMSA rms alternado (ainda vou modificar para ficar mais exato) e RMSC rms continuo... somando as duas... True RMS (rms)... peguei o código de passagem por zero do OPenEnergy para usar como barreira mas ainda não estou usando... e o ajuste de escala pelo VCC real também parte do código esta lá mas ainda sem uso...
-
-
Beleza ! Ontem estava montando o meu código baseado no OpenEnergy, mas fiquei cansado e não terminei.
Esta dando um trabalhão danado. Tem pegar as variáveis no arquivo Header e pegar as rotinas na biblioteca. Por isso não gosto de bibliotecas. É muito complicado estudar uma....
Depois vou estudar o seu código. Obrigado pela ajuda !
-
-
No Lab de garagem tem esse dois sensores de corrente :
http://www.labdegaragem.org/loja/acs711lc-current-sensor-carrier-12...
http://www.labdegaragem.org/loja/sensor-de-corrente-acs712.html
-
-
Ok! Como eu já fiz o pedido a uns 30 dias, vou esperar chegar! Se chegar!
Estou trabalhando no código para o HX711 conversor AD 24bits (para célula de carga), e estou meio travado, resolvi mexer neste para tirar o foco e me dar outra visão, e aproveito e já adianto algo que vou usar no futuro.
-
-
Cara, gostei demais do seu blog !!
Ficou muito bom ! Parabéns !
Depois podia dar umas dicas de como fazer um blog.
Tenho vontade de fazer um, mas acho que deve dar muito trabalho não ?
Por isso, me distraio por aqui.
As vezes a gente fica muito focado em um projeto, fica de cabeça quente...
Ai é bom dar uma arejada.
-
-
Esta tendo alguma dificuldade no conversor ADC de 24bits?
Se precisar, posso ajuda-lo.
-
-
Na verdade estou precisando escolher qual o melhor filtro para uma balança, que seja fácil de implementar e principalmente fácil de explicar como funciona... A maior dificuldade é que cada amostra possui 24 bits e estou evitando muito malabarismo...
Se tiver uns links para recomendar agradeço!
Bem-vindo a
Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)
© 2024 Criado por Marcelo Rodrigues.
Ativado por
