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);
}
Tags:
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.
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.
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...
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 !
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
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.
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 =/
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.
Estou utilizando o código que você postou logo acima:
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);
}
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.
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.
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
Obs: Com a saída ligada em nenhum lugar saída livre. Uso um arduino UNO e minha luz vermelha do ACS712 está ligada.
Obrigado, desde já.
Matheus , pino A0 do Arduino foi conectado no pino Vout do sensor ACS712 ?
Conectou o 5V e GND do sensor também ?
O sensor tem que estar ligado (led vermelho aceso).
Bem-vindo a
Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)
© 2024 Criado por Marcelo Rodrigues. Ativado por