Respostas a este tópico

Permalink Responder até Eduardo em 6 janeiro 2014 at 10:07

Acho que vc precisa duplicar essas variaveis:

int readings[numReadings]

int index = 0; // the index of the current reading
int total = 0; // the running total
int average = 0; // the average

int inputPin = A0;

Fazendo algo como:

int readings1[numReadings]

int index1 = 0; // the index of the current reading
int total1 = 0; // the running total
int average1 = 0; // the average

int inputPin1 = A0;

int readings2[numReadings]

int index2 = 0; // the index of the current reading
int total2 = 0; // the running total
int average2 = 0; // the average

int inputPin2 = A1;

E ir duplicando e corrigindo todo o programa para esses nomes.

Permalink Responder até Angelo Ventura em 8 janeiro 2014 at 12:25

Olá Eduardo, Obrigado pela dica e essa foi minha primeira tentativa mas o sensor2, não funcionou, da uma olhada no código e veja se há algo errado:(separei como sensor P e sensor H)

#include <LiquidCrystal.h>

LiquidCrystal lcd(7, 6, 5, 4, 3, 2);

const int numReadingsP = 10;
const int numReadingsH = 10;

int readingsP[numReadingsP]; // the readings from the analog input
int readingsH[numReadingsH]; // the readings from the analog input

int indexP = 0; // the index of the current reading
int indexH = 0; // the index of the current reading

int totalP = 0; // the running total
int totalH = 0; // the running total

int averageP = 0; // the average
int averageH = 0; // the average

int ValorP = analogRead(A0);
int ValorH = analogRead(A1);

void setup()
{

lcd.begin(16, 2);
// initialize serial communication with computer:
Serial.begin(9600);
}

void loop() {

float voltagemP = ValorP * (5 / 1023.0);
float milimetrosP = (voltagemP * 63.69) - 63.7;

float voltagemH = ValorH * (5 / 1023.0);
float milimetrosH = (voltagemH * 63.69) - 63.7;

// subtract the last reading:
totalP= totalP - readingsP[indexP];
// subtract the last reading:
totalH= totalH - readingsH[indexH];

// add the reading to the total:
totalP= totalP + milimetrosP[indexP];
// add the reading to the total:
totalH= totalH + milimetrosH[indexH];

// advance to the next position in the array:
indexP = indexP + 1;
// advance to the next position in the array:
indexH = indexH + 1;

// if we're at the end of the array...
if (indexP >= numReadingsP)
(indexH >= numReadingsH)


// ...wrap around to the beginning:
indexP = 0;
// ...wrap around to the beginning:
indexH = 0;

// calculate the average:
averageP = totalP / numReadingsP;
// calculate the average:
averageH = totalH / numReadingsH;

lcd.setCursor(0, 0);
lcd.print("P: ");
lcd.print(averageP);
lcd.print("mmH2O ");

lcd.setCursor(0, 1);
lcd.print("H: ");
lcd.print(averageH);
lcd.print("mmH2O ");


delay(250); // delay in between reads for stability
}

Permalink Responder até Kraftman em 6 janeiro 2014 at 13:11

Pelo que vi no seu código vc está usando sensore analógicos, uma boa maneira de fazer essa suavização é utilizando capacitores cerâmicos ou eletrolíticos. Isso ocasionará um pequeno atraso na leitura, que é da ordem de milisegundos, dependendo do valor.

Sugiro que faça testes com capacitores de 1 a 10uf de 16 ou 25v, se vc encontrar capacitor de 10V de tensão de trabalho melhor, claro se isso vc estiver usando 5V como tensão de trabalho.

Quanto maior o valor do capacitor maior o atraso. No caso de usar capacitor eletrolítico, tome cuidado com a polaridade.

Ligue o positivo do capacitor a entrada analógica, no mesmo pino do sensor que vc está ligando, e o negativo do capacitor ao GND da placa ou fonte de tensão.

Não sei se vc precisa de uma leitura que aconteça muitas vezes por segundo, mas de cara pode colocar um de 10uf e pode ir subindo até uns 47uf que acho que vai te ajudar e ainda vai fazer seu código ficar menor. Caso queira vc tb pode colocar o capacitor próximo ao sensor, mantendo a mesma ligação, negativo do capacitor no GND e positivo do capacitor a saida do sensor que será conectada na entrada do arduino. No caso de capacitores cerâmicos, vc deve fazer a mesma ligação mas sem se preocupar com a polaridade, a diferença é que valores acima de 4,7uF são dificeis de serem encontrados no Brasil e acima de 10uf acho que nem existe. Mas os eletrolíticos vão bem, só preste atenção na polaridade.

Caso queira tb posso dar uma diga de como fazer isso via código, mas via hardware é mais simples e efetivo de resolver. 

Faça isso nos dois sensores.

Permalink Responder até Angelo Ventura em 6 janeiro 2014 at 13:30

Entendi Ricardo, excelente sugestão. Irei fazer os testes e respondo. Muito Obrigado.

Permalink Responder até Angelo Ventura em 8 janeiro 2014 at 12:26

Olá, fiz uns testes com capacitores mas o resultado não foi o que eu queria pois desejo estabilização nas leituras e as vezes eu perco o dado max e min devido ao delay dos capacitores. E também ta será interessante para outros projetos. Obrigado novamente.

Permalink Responder até Gabriel Yoshiaki Hotta em 8 janeiro 2014 at 13:05

Notei alguns erros no codigo que postou (nao sei se ja resolveu):

- Voce precisa chamar analogRead(A0) [e A1] toda vez que quiser um dado atualizado. No codigo que postou, voce esta pegando o valor uma vez, armazenando na variavel e utilizando o valor armazenado.

- A0 e A1 nao foram configurados como INPUT: pinMode(A0 , INPUT)

- milimetrosP (e milimetrosH) sao numeros float, seus vetores se chamam readingsP e readingsH.

Ta faltando um ";" em algum canto, mas isso eh o de menos.

Pelo que vi eh so isso, a logica parece estar certa.

Permalink Responder até Angelo Ventura em 8 janeiro 2014 at 14:25

Obrigado Gabriel. Vou testar e te falo.

Permalink Responder até Kraftman em 8 janeiro 2014 at 17:35

Eu nem li o código, quando vc falou do problema eu já falei dos capacitores pois ja tinha passado por isso antes e funcionou numa boa, vai ver é como disse o Gabriel, se no código tiver errado não vai rolar mesmo.

Outra coisa que seria legal pra resolver o ruido sem delay é usar um algorítimo PID (progressão, integral e derivativa) procura sobre isso no google, se trata de um algorítimo matemático para a resolução do seu problema, mas acredito que se o código estiver correto, os capacitores vão funcionar, pode colocar um de 10uF que vai bem.

Permalink Responder até Gabriel Yoshiaki Hotta em 9 janeiro 2014 at 7:45

Acho que nao cabe utilizar PID, pois para usar-lo voce precisa ter uma leitura e quer que essa leitura se aproxime de um valor ideal.

Nesse caso, trata-se apenas de um valor analogico que apresenta pequenas flutuacoes.

Se eu estiver enganado por favor me corrija.

Permalink Responder até Kraftman em 9 janeiro 2014 at 17:23

Na verdade o PID também pode ser usado quando se deseja obter um valor médio de uma determinada variação e isso pode ser controlado através de três variáveis, P, D e I, que resultarão em um número que será armazenado em uma quarta variável, que tem o valor desejado. Usei uma vez para retornar ângulos de inclinação de um acelerômetro, e este tem uma variação de 180 graus mas para cada ângulo ou fração de ângulo ele retorna um número que é a média das variações, mas "suavizado", sem ruídos. Assim se eu tivesse no ângulo 14,7° ele me retornaria esse valor que é o valor médio de todas as variações para aquele angulo em PID.

Isso serve para valores que flutuam muito, independentes de serem provenientes de uma porta analógica ou digital, pois o que importa é a variação ou o dado. É possivel usar PID em inúmeras aplicações, mas ainda não domino isso e estou aprendendo.

Mas acredito que os capacitores são uma boa alternativa já que o sensor é analógico, pois se fosse digital dentre as alternativas possíveis seria o PID.

Permalink Responder até Gabriel Yoshiaki Hotta em 10 janeiro 2014 at 7:16

Interessante, sempre vi PID sendo usado na area de controle.

Tem algum material de referencia que possa indicar sobre PID utilizado nessa forma?

Permalink Responder até Kraftman em 10 janeiro 2014 at 11:13

Tem essa library para arduino http://playground.arduino.cc/Code/PIDLibrary

Mas eu peguei um projeto opensource que faz uso do PID para controle do acelerometro que vc pode baixar de https://code.google.com/p/brushless-gimbal/downloads/list, a versão que eu usei é a _48.zip, no programa main vc pode encontrar as funções que usam o PID para tratamento dessa informação, pois se vc ler um dado de um acelerômetro, tanto digital como analógico, vai ver que tem muito ruido, foi pesquisando que descobri que o PID resolveria isso e descobri esse projeto. Dá uma conferida é muito legal.

• ‹ Anterior
• 1
• 2
• Próximo ›
• Página