Meteo - Banderuola

BANDERUOLA

- 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.

Wind Vane - La Banderuola.

 

 

Misurata la velocità del vento è utile conoscere anche la direzione.

Con questo post indico una possibilità per poter leggere la direzione del vento con Arduino.

La realizzazione che ho fatto ha il solo scopo di testare il sistema per poter poi realizzare una banderuola capace di resistere alle intemperie.

Ho utilizzato:
Arduino, 4 resistenze, 4 reed, 2 magneti, due CD inutilizzabili, una scatolina per CD.

Questo è lo schema utilizzato.

Ho disposto i 4 contatti reed sulle 4 direzioni principali Nord, Est, Sud, Ovest, i magneti chiudono 1 (un)  cottatto se posizionati sulla direzione principale, oppure 2 ( due) contatti se si trovano nella posizione intermedia.

In questo modo il partitore di tensione fornirà 8 valori diversi. 

I 4 valori delle resistenze sono una delle possibili combinazioni, ogni combinazione corrisponderà ad una delle 8 (otto direzioni) N, NE, E, SE, S, SW, W, NW.

La scelta dei valori è stata fatta in modo da non creare incertezze nell'identificazione della direzione assegnata.

Ho calcolato i valori di tensione sul pin A0, per le otto posizioni ed ho calcolato i corrispondenti numeri ( da 0 a 1023). 

Ecco la relativa tabella che troverete nello sketch:

 nord = 153;

 nordest = 331;

 est = 237;

 sudest = 616;

 sud = 561;

 sudovest = 667;

 ovest = 411;

 nordovest = 468;

Lo sketch confronterà il valore letto sul pin A0 ed individuerà la relativa direzione.

 Questo lo schema pratico.

Come su detto ho realizzato una banderuola per testare il funzionamento dello sketch, e communque per verificare la fattibilità dell'idea.

Per semplicità ho utilizzato una scatolina porta CD, due vecchi CD, ho fissato le due calamite su un CD ed ho posizionato sopra il secondo ed incollato il tutto per renderlo stabile.

Sotto la scatola ho incollato i 4 reed ed ho saldato le 4 resistenze, in uscita ho due fili che vanno Uno sul positivo 5V, e l'altro al pin A0 di arduino ( vedi schema).

Le due calamite fissate al CD.

I reed e le resistenze.

La Banderuola pronta.

Il prototipo realizzato non potrà resistere molto alle intemperie, per ora serve per testare il funzionamento, simulando il vento con un ventilatore.... Vedermo di realizzare un oggetto più resistente, e con meno attrito.

Anemometro e banderuola.

Se possiamo sapere la direzione del vento è il caso di unire questa informazione alla velocità, in modo da avere un'informazione completa.

Ho così pensato di unire i due sketch (anemometro & banderuola).

Ecco riuniti i due lavori.

Qui sotto lo sketch che è praticamente quello dell'anemometro con l'aggiunta della porzione di codice utile per la banderuola.

Lo sketch è commentato in ogni sua parte, e dovrebbe esserVi chiaro.

/*

//*************************************************
//  UNIONE dei due sketch Anemometro + Banderuola
 Si uniscono due sketch.
 Dopo l'esecuzione di anemometro e rilevata una
 velocità del vento viene eseguito void banderuola()
 che rileva e stampa la direzione del vento

//**************************************************
  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).

//**********************************************************
//--------------------------------------------------------------------------//

*** Sergio & Adriano Prenleloup ****
  
 ***** Stazione Meteo **************
 *** Banderuola direzione vento ****
 *** Versione 0.01 *****************
 ******   06/02/2014 ***************
 ***********************************
  
  
 * Indica la direzione del vento, questo modulo è di prova per verificare
 * la banderuola autocostruita, è stata realizzata utilizzando 4 reed,
 * 4 resistenze, due calamite e altro materiale di recupero.
 * Le resistenze vengono commutate dai reed, e forniscono un tensione, 
 * diversa che viene inviata ad un pin analogico e quindi interpretata
 * la direzione del vento
 * schema e ulteriori informazioni
 * sul sito http://avventurarduino.blogspot.it
 * 

*/

//--------------------------------------------------------
// costanti e variabili perBanderuola
//--------------------------------------------------------
int pinVdir = A0; // Pin analogico dedicato al sensore direzione vento.
int Vdir = 0;
float sommadir = 0;
//--------------------------------------------------------
// valori corrispondenti alle direzioni
int nord = 153;
int nordest = 331;
int est = 237;
int sudest = 616;
int sud = 561;
int sudovest = 667;
int ovest = 411;
int nordovest = 468;
//-----------------------------------------------------------
//----------------------------------------------------------
// costanti e variabili per anemometro
// ---------------------------------------------------------

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
    }

//-------------------------------------------------
// Banderuola
//-------------------------------------------------
void banderuola()
{
  
  //----------------------------------------------------------------
  // lettura Banderuola e media dei valori
  //----------------------------------------------------------------
  sommadir = 0;
  
  for (int i = 0; i < 9; i++)
  {
  
  Vdir = analogRead(pinVdir); // si legge il valore da 0 a 1023
                                     // che darà la direzione vento
  
  sommadir = (sommadir + Vdir); // sommatoria per la media letture
  delay (20);
  }
  Vdir = ( sommadir/9); // media il valore
  
  //------------------------------------------------------
  // controlla il valore con la direzione e stampa                                    
  //------------------------------------------------------
 if  ((Vdir > (nord - 25)) && (Vdir < (nord + 25)))
  {
   char Direzione[] = "Direzione = Nord";
   Serial.print(Direzione);
   }
 
 if  ((Vdir > (nordest - 25)) && (Vdir < (nordest + 25)))
  {
    char Direzione[] = "Direzione = Nord-Est ";
    Serial.print(Direzione);
   }
 
 if  ((Vdir > (est - 25)) && (Vdir < (est + 25)))
  {
   char Direzione[] = "Direzione = Est ";
    Serial.print(Direzione);   
  }
 
 if  ((Vdir > (sudest - 25)) && (Vdir < (sudest + 25)))
  {
   char Direzione[] = "Direzione = Sud-Est ";
    Serial.print(Direzione); 
  }
 
 if  ((Vdir > (sud - 25)) && (Vdir < (sud + 25)))
  {
   char Direzione[] = "Direzione = Sud ";
    Serial.print(Direzione); 
  }
 
   if  ((Vdir > (sudovest - 25)) && (Vdir < (sudovest + 25)))
   {
   char Direzione[] = "Direzione = Sud-Ovest ";
    Serial.print(Direzione);
 }
 
 if  ((Vdir > (ovest - 25)) && (Vdir < (ovest + 25)))
  {
   char Direzione[] = "Direzione = Ovest ";
    Serial.print(Direzione); 
  }
  
 if  ((Vdir > (nordovest - 25)) && (Vdir < (nordovest + 25)))
  {
   char Direzione[] = "Direzione = Nord-Ovest ";
    Serial.print(Direzione);
  }
 
   //--------------------------------------------------
   // visualizza sul monitor i valori rilevati e calcolati
   
  Serial.println();
  Serial.print("******");
  Serial.println();
  delay(500);// attesa per altra lettura
}
//----------------------------------------
// fine banderuola
//------------------------------------------


//--------------------------------------------
// loop principale anemometro + banderuola
//--------------------------------------------

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("Velocita m/s = ");
           Serial.println(Metris);
           Serial.print("Velocita nodi = ");
           Serial.println(Node);
           Serial.print("Velocita Km/h = ");
           Serial.println(Kmora);
     
           Conteggio = 0; // azzeriamo il conteggio per nuova lettura
           Statoreed = 0;
           Statoreed_old =1;
           Tempo = 0;
           banderuola();  // chiama ed esegue banderuola
           delay(2000);// attesa per altra lettura 
                   
          }
    }
  }
}

Qui sotto la stampa sul monitor dei risultati:

Scarica qui lo sketch

Ecco un video dimostrativo del lavoro.

Seguiranno presto il pluviometro e la misura della pressione atomosferica.

Riuniremo i vari sketch, a formarne uno e aggiungeremo la registrazione dati su scheda, e speriamo altro ancora.

Questo post come i precedenti riguardanti la stazione meteo potranno subire degli aggiornamenti e/o dei cambiamenti nel caso si trovino correzioni da fare.

Ogni segnalazione d'errore è gradita per  migliorare l'intero sistema.

Al prossimo post meteo .... At the next post weather.