Meteo - Anemometro

ANEMOMETRO

- Stazione meteo con Arduino - 

- Weather Station with Arduino -

- 05/02/2014 -

  Con questo post continua la costruzione della "nostra"  stazione meteorologica.

This post continue the project for the weather station.

Oggi vedremo come utilizzare un anemometro a coppette.

Ogni stazione meteorologica dovrebbe avere un anemometro, occorre misurare almeno intensità, e direzione del vento.

L'anemometro a coppette da me acquistato ha al suo interno un sensore reed che chiude il contatto al passaggio di un piccolo magnete, il magnete è solidale alla parte in movimento ( quella con le coppette) e quindi ogni giro passa in prossimità del sensore che si chiude.
In questo modo si hanno inpulsi in numero proporzionale alla velocità del vento.

Arduino dovrà contare il numero degli impulsi e il tempo trascorso.

Per calcolare la velocità del vento con questo anemometro occore conoscere: (r) il raggio, o braccio ( distanza asse coppette in metri), il numero dei giri al secondo (f), e quindi: 

Velocità =  r * 6.28 * f  = Velocità in m/s.  Per Velocità in Km/h = (Vm/s * 3,6)

 

 

Attenzione! il sensore che ho acquistato ha due calamite quindi ogni giro 2 impulsi.

 

 

Per collegare l' anemometro ad Arduino ho usato il seguente schema:

 L'antirimbalzo è queello pubblicato sul sito di Arduino.

Lo sketch esegue il conteggio degli impulsi e conteggia il tempo ( due secondi), quindi applica la formula descritta qui sopra ( tenendo conto che sono 2 impulsi per giro).

Lo sketch è commentato completamente.

 /*
//*********************************************************
  Sergio  & Adiano Prenleloup

 ***** Stazione meteo *********
 *** Prova per anemometro ****
 *** Versione 1.04 ************
 ******   31/01/2014 **********
 ******************************
Sketch per la prova anemometro trasparente
L'anemometro ha due magneti che chiudono
il contatto reed ( ogni giro 2 impulsi).

*/
const float Pi = 3.141593; // Pigreco
const float raggio = 0.06; // raggio dell'anemometro in metri
const int reedPin = 2; // pin assegnato al contatto reed


int Statoreed = 0; // variabile per la lettura del contatto
int Statoreed_old = 0; // variabile per evitare doppio conteggio

int Conteggio = 0;// variabile che contiene il conteggio delle pulsazioni
unsigned long int TempoStart = 0; // memorizza i  millisecondi dalla
                                 //prima pulsazione conteggiata
                               
unsigned long int Tempo = 0; // per conteggiare il tempo trascorso dalla prma pulsazione

unsigned long int TempoMax = 2000;// numero di millisecondi (2 seondi)
                  //per azzerare il conteggio e calcolare la Velocità
                  // così non si conteggiano brevi folate di vento

void setup() {
    Serial.begin(9600);   //attiva la porta seriale
    pinMode(reedPin, INPUT);// mette in ascolto del reed il pin 2
  
}

//--------------------------------------------
// loop principale
//--------------------------------------------

void loop()
{
  Statoreed = digitalRead(reedPin); // legge il contatto reed

  if (Statoreed != Statoreed_old) // si verifica se è cambiato
  {
    Statoreed_old = Statoreed;   // se SI si aggiorna lo stato
 
   if (Statoreed == HIGH)  // si controlla SE è alto ( passaggio magnete)
    {
      if (Conteggio == 0){ TempoStart =  millis();} // se E' il primo passaggio
                                                 // si memorizza il tempo di partenza
  
      Conteggio = Conteggio + 1; // si aggiorna il contatore    
  
      Tempo = ( millis() - TempoStart); // si conteggia il tempo trascorso dallo start conteggio
  
        
           if (Tempo >=  TempoMax)   // se il tempo trascorso è maggiore o uguale al tempo impostato
                                     // si eseguono i calcoli e la stampa della velocità
          {
     
           float deltaTempo = ( Tempo/1000.0); // si trasforma in secondi
       
           float Metris= (Conteggio*Pi*raggio)/deltaTempo;      // si calcola la velocità in metri/s
        
           float Kmora = (3.6*Conteggio*Pi*raggio)/deltaTempo; //formula per il calcolo della velocità
                                                             // in Km/h
           float Node = (Metris/0.514444); // si porta in nodi
       
           //--------------------------------------
           // stampa i valori sul monitor
           //---------------------------------------
           Serial.print("Velocità m/s = ");
           Serial.println(Metris);
           Serial.print("Velocità nodi = ");
           Serial.println(Node);
           Serial.print("Velocità Km/h = ");
           Serial.println(Kmora);
   
           Conteggio = 0; // azzeriamo il conteggio per nuova lettura
           delay(5000);// attesa per altra lettura        
          }
    }
  }
}

 

Scarica qui lo sketch

 

Nota integrativa  (09/05/2015) - 1

Nel nostro caso l'anemometro è costituito da coppette solidali fra loro che ruotano sull'asse, descrivendo quindi una circonferenza, misurando quanti giri al secondo e moltiplicando per la misura della circonferenza si ottiene la velocità delle coppette che corrisponde alla velocità del vento.

Il numero dei giri può essere misurato in modi diversi, nel mio caso ci sono due magneti che chiudono un contatto reed. ( quindi ogni giro due impulsi).

Si tratta quindi di cronometrare il tempo e conteggiare il numero dei giri, ed è questo che facciamo con lo sketch proposto.

Cercherò di spiegare meglio la formula indicata: ( 2*Pi*r)*f

Vediamo in dettaglio (2*pi*r) = è la circonferenza percorsa da una coppetta che ruota sull'asse dell'anemometro.

Maggiore è la velocità del vento maggiore sarà la velocità angolare e quindi il numero dei giri al secondo che la coppetta esegue.

f = rappresenta gli impulsi al secondo ovvero il numero dei giri che vengono conteggiati dal magnete chiudendo il reed.

Sarà quindi f = Numero giri/secondi ho usato Conteggio/deltaTempo

per avere la velocità del vento occorre quindi conteggiare quanti giri al secondo e moltiplicarli per la distanza percorsa che nel nostro caso è una circonferenza.

Nella mia formula ho diviso il tutto per 2 perché ho due magneti [(2*pi*r)/2]*f che semplificando diventa : Pi*r*f

La formula finale è dunque Velocità = (Pi*r*Conteggio)/deltaTempo

r = raggio espresso in metri

Pi = 3.14

Conteggio = Numero intero dei giri

deltaTempo = secondi dall'inizio conteggio.

Questo restituisce la velocità in m/s ( metri al secondo ) con anemometro con due magneti

altrimenti non si divide per 2.

Per avere Km/h basta moltiplicare per 3.6 ( 3600 secondi ora / 1000 metri km.) = 3.6

Vi sono anche anemometri a coppette che usano un piccolo generatore di corrente e la misura della velocità del vento è proporzionale alla corrente generata, in altri casi anziché un contatto reed viene utilizzato un encoder.

Spero che questa nota possa chiarire meglio il funzionamento del nostro anemometro.

Lasciate commenti o chiedete per ulteriori chiarimenti.