next topic »

[Reply #30 on:]

Eu vou pretender gravar os valores de tensão para o bloco de notas de X em X tempo, neste meu caso será 15 minutos, (960 000 milisegundos) ou seja delay(960 000),
Irei fazer um ciclo for do género:

Code:

samples[5];
for (int i=0; i<4; i++)
{
samples[i] = ( 5.0 * analogRead(PinAnalogA0)) / 1024;
temp = temp + samples[i];
delay(180000);
}
temp=temp/5;

Serial.print("Tensao=");
Serialprint(temp);
delay(960000);

Desta forma, creio que de 3 em 3 minutos ele lê o valor de tensão da porta analogica A0, no total de 5 medições!
Ao fim de 15 minutos, calcula a média dos 5 valores lidos de 3 em 3 minutos e imprime no Serial_Monitor o valor!
Desta forma terei mais exatidão dos resultados, da tensão média que variou nesses 15 minutos!!

Concordam com o código e com esta minha sugestão???

Contudo neste momento queria tentar gravar para testar de 2 em 2 segundos, por isso coloquei o delay(2000) e neste momento estou a gravar para o bloco de notas através do Processing de 2 em 2 segundos!
aparecendo desta forma no bloco de notas:
6   Tensao= 2.45 || Tensao min= 2.45 || Tensao max= 2.45
8   Tensao= 2.60 || Tensao min= 2.45 || Tensao max= 2.60
10   Tensao= 2.60 || Tensao min= 2.45 || Tensao max= 2.60
12   Tensao= 2.58 || Tensao min= 2.45 || Tensao max= 2.60
...

Agora só preciso mesmo de substituir esses segundos do lado esquerdo, pela Data e Hora do RTC do PC, fazendo isso no Processing, aí está o que é + importante para este projeto e que ainda não consegui!!!!

[Reply #31 on:]

Pronto!!!!
Consegui!! 

Era isto que pretendia:




Se me poderem ajudar, verifiquem pf se o código anterior no Arduino, para ler de 15 em 15 e fazer a média dos 5 valores lidos de 3 em 3, vos parece bem!!!


Obrigado a todos pela vossa ajuda!!!

[Reply #32 on:]

Não. Não me parece bem. Parece-me aliás ridículo.

Pesquisa por millis e o exemplo blink without delay.

[Reply #33 on:]

Não. Não me parece bem. Parece-me aliás ridículo.

Pesquisa por millis e o exemplo blink without delay.

Reparei que a função millis() volta a zero, passado 50 dias, neste caso a minha aplicação seria para o funcionamento do arduino, durante o ano inteiro!!
Será que com essa função isso iria resultar passado os 50 dias?
Qual é a diferença de utilizar ou não o delay nesse meu exemplo?
Qual é a parte "ridicula" no código? Não funcionaria na prática?

[Reply #34 on:]

Devido à forma como as variáveis são usadas no calculo, o millis funciona sempre. Mesmo no overlap.

A parte ridícula é empancar o microcontrolador por 15 minutos. Experimenta fazer algo com ele durante esses 15 minutos a ver se funciona...

[Reply #35 on:]

Eu vou pretender gravar os valores de tensão para o bloco de notas de X em X tempo, neste meu caso será 15 minutos, (960 000 milisegundos) ou seja delay(960 000),

Um grande LOL.
Eu assino por baixo que isso e ridiculo.Para tu teres uma noçao do ridiculo que é o que tu estas a fazer e tipo "vou programar o arduino para no Natal daqui a uns meses me acender um led" por isso vou usar um delaaaaaaayyyyyyyy super gigante.
Vais pensar que eu sou louco correcto pois ninguem fará isto, certo?
Pois bem tu estas a faze-lo so que durante 15 minutos apenas.
Se colocares isso assim todos se vao rir desse delay.
Nao estou a dizer que é impossível tu correres essa tarefa de 15 em 15 minutos, é possivel sim, mas da maneira correcta
Como o Bubulindo te disse ve o exemplo Blink without delay.A tua resposta esta lá.
Há muitas formas de se apertar um parafuso de estrela, podes usar uma faca (as minhas ferramentas enquanto criança  ),um alicate,um garfo,martelo, ou então o correcto, que é usar uma chave estrela com a dimensão correcta e o parafuso sairá intacto e reutilizável sem
dano.É isto que te destinge de um bom programador de um desenrascado ...

[Reply #36 on:]

Fiquei pensando: "como conseguirá tirar amostragens a cada 3 minutos se o programa estiver em um delay de 15 minutos?"

Se fizeres o cálculo terás 19 minutos e não 15 que é o que estavas a dizer.

Exorciza esses delays, rapaz!!! xD

Pensa que o arduino pode tirar amostragens de três em tês minutos armazenado a média e mandar mensagem para o PC pela serial, somente quando o computador solicitar ou a cada x tempo sem ficar travadão. É necessário um protocolo master simples e o teu trabalho ficará muito mais elegante!

[Reply #37 on:]

Se calhar eu também não fui explicito!!
Na verdade eu no Arduino vou converter a tensão lida em Temperatura!!
Como estou a usar o Processsing, o mesmo vai buscar-me os valores lidos pelo Arduino pelo delay definido no Arduino (15minutos), e coloca os mesmos no bloco de texto, no qual usarei para construir a minha Base da Dados!!

Objetivo final??
O objetivo final deste projeto é verificar a variação da Temperatura num dado local, durante o ano todo!!
Nesse sentido, basta-me gravar no bloco de notas, o valor da Temperatura de 15 em 15 minutos, o que equivale a ter 4 valores por hora e 96 valores registados de temperatura por dia! Este foi o tempo que estabeleci.

O que pretendia com o ciclo for, era que o Arduino lê-se o valor da temperatura de 3 em 3 minutos, e quando tivesse 5 valores lidos, ou seja, ao fim dos 15 minutos, fizesse a média dessas 5 temperaturas lidas e que a mesma fosse, através do processing, gravada para o bloco de texto.
Para isso eu defini um delay para correr o ciclo for, de 3 em 3 minutos e outro para enviar os dados para o Processing de 15 em 15.
Neste caso, não me interessa ter LED's a piscar. As saídas que terei é de LED acessos, sempre que a Temperatura passe acima ou abaixo de um dado valor, e se tiver dentro da gama de temperaturas que pretendo, fica com um LED verde ativo!!!

Eu ainda não testei esse ciclo for, mas penso que sabem agora o que pretendo exatamente...
Acham que poderia então fazer isso de uma maneira mais eficaz e com maior exatidão???

[Reply #38 on:]

Para isso eu defini um delay para correr o ciclo for, de 3 em 3 minutos e outro para enviar os dados para o Processing de 15 em 15.

Mais uma vez, o teu programa tem de ser feito sem um unico delay!
Esquece os delays, sao a abordagem errada!!!

Neste caso, não me interessa ter LED's a piscar

Se estas a dizer isto referente ao exemplo "blink without delay" é porque ou não o leste ou não entendeste a conclusão desse exemplo
Se achares que somos nos que estamos errados tenta ir ao forum http://forum.arduino.cc/index.php?board=4.0 e coloca la isso com esse delay e vê as respostas que te vão dar ...

[Reply #39 on:]

Neste caso, não me interessa ter LED's a piscar.

Fique com a mesma impressão que o Hugo, pois o exemplo é o led piscar, mas o método é sem a utilização do dalay.

Eu ainda não testei esse ciclo for, mas penso que sabem agora o que pretendo exatamente...
Acham que poderia então fazer isso de uma maneira mais eficaz e com maior exatidão???

O procedimento estava claro, o código é que esta travado. Se você testou e esta feliz com o resultado podes deixar assim, mas veja o exemplo abaixo me diz tua opinião:

Code:

int PinAnalogA0 = 0;     //Sensor

long previousMillis = 0; // ultimo tempo de execução
long interval = 180000;  // intevalo de 3 minutos para cada amostragem
//você pode criar tantas variáveis iguais à acima quanto julgar necessárias,
//ou pode usar um array e buscar os valores assim exemplo:
//#define tempoAmostra 0
//if(currentMillis - previousMillis[tempoAmostra] >= interval[tempoAmostra])

int samples[5]; //Array para guardar os samples
int curSample = 0; //Array para guardar o exemplo atual

void setup() {
  Serial.begin(9600); //Inicia a serial
}

void loop() //loop infinito que nunca deve ser travado ;)
{
  unsigned long currentMillis = millis(); //pega o milesimo de segunto atual
  
  if(currentMillis - previousMillis >= interval) { //calcuta para saber se o intervalo desejado já ocorreu
    previousMillis = currentMillis;
    
    int total = 0;
    float media = 0;
    
    samples[curSample] = ( 5.0 * analogRead(PinAnalogA0)) / 1024;
    
    if(curSample++ >= 5){ //Já temos 5 amostrages (0 a 4), como 5*3=15 é tempo de notificar o pc
      curSample = 0; //zera o contador para reiniciar as amostragens (editado)
      for (int i=0; i<4; i++) //corre as amostragens
        total += samples[i]; //soma na variável total
      
      media=total/5;//tira a média das amostragens
      
      Serial.print("Tensao="); //imprime o texto
      Serial.println(media);    //imprime o valor
    }
  }
  
  /*
  O looop continua a ser executado, sem pausas Delays,
  então se desejas algo a cada 1 minuto é possível, pois
  não esta travado por três minutos, percebes?
  
  if(currentMillis - OutraVarTempoAnterior > OutraVarInterval) { //exemplo a cara 10 segundos
    OutraVarTempoAnterior = currentMillis;
    //executa algo
  }
  (...)
  if(currentMillis - OutraVarTempoAnterior2 > OutraVarInterval2) { //exemplo a cada um segundo
    OutraVarTempoAnterior2 = currentMillis;
    //executa algo
  }
  */
}

Não testei o código acima, o escrevi em poucos minutos para ilustrar o que estamos tentando te dizer. Como podes ver, não estou fazendo um só led piscar LOL

[Reply #40 on:]

Pois, já entendi...
Devo msm evitar usar os delay's no Arduino.
Como vou usar o Processing e pretendo ler os dados do Arduino e gravar os mesmos para um bloco de notas, penso que poderia usar algo, como, por exemplo, sempre que minuto fosse 00, 15, 30, 45, iria ler os dados do Arduino e gravava os mesmos nesse tempo exato, em vez de definir isso nos delay's do Arduino.

Penso que teria de ser algo deste género:

Code:

if (minute() == 0 &&(e) seconds() ==0 ||(ou) minute()==15 && seconds() ==0 || minute()==30 && seconds() ==0 || minute()==45 && seconds() ==0 )
{
 output.println(year() + month() + day() + hour() + minute() + second() + "\t" + sensorReading); // escreve a Data, Hora e valor da Temperatura
 output.flush(); //escreve todos os dados no ficheiro
}

Acham que estou a pensar correto??

Neste momento eu no Processing estava a gravar para o bloco de notas, pelo tempo que tinha definido do delay() do ciclo, no Arduino e o meu código no Processing é o seguinte:

Code:

void setup()
{
  size(1100,200); // Define o tamanho da janela
  myPort = new Serial(this, "COM4", 9600);  //Conecta-se com a porta COM3
  myPort.bufferUntil('\n');  // Espera receber o primeiro sinal da usb
  font = createFont(PFont.list()[2],32);
  textFont(font);
  output = createWriter( "C:/Users/alunosdefi/Desktop/data.txt" ); //cria o ficheiro de texto neste caminho

}

void draw()
{
//Nao faz nada mas é necessario declarar
} 

void serialEvent (Serial myPort)
{
 sensorReading= myPort.readStringUntil('\n'); // Pega a primeira linha recebida na porta serial
  if(sensorReading != null)
  {   // Se a linha não estiver em branco
    sensorReading=trim(sensorReading); // remove os espaços em branco
 // remove os espaços em branco
 output.println(year() + month() + day() + hour() + minute() + second() + "\t" + sensorReading); // escreve a Data, Hora e valor da Temperatura
 output.flush(); //escreve todos os dados no ficheiro
  }

Só terei de arranjar forma de encaixar aqui o código acima, ou um outro que me seja capaz de ler de 15 em 15 minutos e gravar para bloco de notas.

Penso que podia já calcular no Arduino a temperatura média de 3 em 3 minutos e depois ía apenas com o Processing buscá-la de 15 em 15 minutos.. mas penso que tbm podia fazer tudo isso no Processing...

Algumas sugestões??

[Reply #41 on:]

Pedro,

O exemplo que passei faz as amostragens de 5 em 5 minutos e após 5 amostragens manda para para o arduino a mensagem com média de 15 minutos, conforme cenário colocado por você, e sem delay. =)

No meu código tem um erro, eu não zerei a variável curSample após entrar no if (curSample  >= 5). Editarei o código do post.

Existem milhares de formas de se chegar ao mesmo lugar, você pode guardar as médias no arquino e o programa do PC requisitar a qualquer tempo, armazenando arrays e sincronizando, você pode comprar um shield com sdcard e gravar nele usando um RTC, você pode fazer uma infinidade de coisas. Faça testes e veja o que melhor atende as tuas necessidades.

[Reply #42 on:]

Code:

if (minute() == 0 &&(e) seconds() ==0 ||(ou) minute()==15 && seconds() ==0 || minute()==30 && seconds() ==0 || minute()==45 && seconds() ==0 )
{
 output.println(year() + month() + day() + hour() + minute() + second() + "\t" + sensorReading); // escreve a Data, Hora e valor da Temperatura
 output.flush(); //escreve todos os dados no ficheiro
}

Por que tantas condições se no cenário atual o processing só receberá dados do arduino a cada 15 minutos?

[Reply #43 on:]

Essas restrições eram para garantir que o tempo gravado para o bloco de notas era exato, e de 15 em 15 minutos, ou seja,
seria algo do género:

18:00:0
18:15:0
18:30:0
18:45:0
19:00:0
...

Isto seria a forma ideal de gravar a hora no bloco de notas!!
 Receio que como está atualmente definido, ele possa gravar noutro tempo descontrolado, ou seja, nos minutos e segundos exatos, em que colocar o Processing a funcionar, e não nesse tempo "certinho" percebes??

Achas que esse código resultaria para o que pretendo??

Obrigado por me teres respondido!!

[Reply #44 on:]

Podem ocorrer diferenças de segundos, mas o arduino mandará a temperatura para o processing que só precisa receber e escrever no bloco de notas.

Mas nada melhor que colocoar a coisa para funcionar e ver o que acontece, certo? Então testa ai e nos diga os resultados