Meteo - Pluviometro

Pluviometro

- Stazione meteo con Arduino - 

- Weather Station with Arduino -

- 09/02/2014 -

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

This post continue the project for the weather station.

 Oggi vediamo come utilizzare un pluviometro con Arduino 

Today we see how to use a rain gauge with Arduino

 

 

 

 Esistono pluviometri manuali, pluviometri a vaschetta basculante, (vedi su wikipedia altre informazioni).

Pluviometro manuale: 
Occorrente:
Un contenitore  sufficiente a contenere la massima quantità di acqua che può cadere in zona nelle 24h.

Dovremo calcolare la superficie di raccolta con precisione.

Occorre un cilindro graduato per misurare la quantità di pioggia caduta nelle 24h.

Si utilizza così:

- alle ore 24 di ogni (notte), un coraggioso (anche in caso di neve, pioggia, grandine ecc..) vuota il contenitore nel cilindro graduato e misura i ml di acqua raccolti.

- adesso si potrà calcolare i mm/m²  con questa ==>  ml raccolti / superficie in cm²   

Es. raccolti 50ml,  superfice di raccolta 200 cm² avremo ( 50/200) = cm 0.25 cioè 2,5 mm/m²

Questo pluviometro è semplice, economico, preciso, ma molto scomodo!

Usiamo Arduino è più comodo!! E divertente.

Con arduino possiamo utilizzare un pluviometro a bascula, o a doppia vaschetta basculante.

Ho trovato su ebay un pluviometro a doppia vaschetta basculante.

Questo è l'esterno foto 1

Questo l'interno foto 2

Come potete vedere dallo foto ( 1) sopra c'è una superficie di raccolta a forma d'imbuto rettangolare con un foro sul fondo, l'acqua raccolta cade sulla vascchetta sottostante (vedi foto 2) quando il peso dell'acqua fa ruotare sul perno al centro in basso foto 2, l'altra vaschetta si pone sotto il foro e comincia a riempirsi mentre la prima si è svuotata. Questo movimento fa muovere un magnete che chiude un contatto reed, la cosa si ripete.

Avremo così una serie di chiusure ed aperture del contatto reed che ci segnaleranno lo svuotamento della vaschetta a bascula.

Conoscendo la quantità di acqua che fa ruotare la vaschetta, e contando il numero delle vuotature ( o basculate), potremo ricavare i mm/m².

Il venditore dichiara questi dati:

The output switch closes once per 0.3mm of Rainfall. e.g

    10   pulses = 3mm of rainfall
    50   pulses = 15mm of rainfall
    100 pulses = 30mm of rainfall

Quindi ogni impulso 0.3mm di pioggia!

In ogni caso quanto ho scritto prima sul pluviometro manuale potrebbe tornarci utile per verificare quanto detto dal costruttore, oppure per eseguire una taratura nel caso che ci manchino i dati del pluviometro in nostro possesso.

Non ci resta che contare gli impulsi!!

Questo lo sappiamo fare, basta vedere il post anemometro.

Purtroppo per la pioggia ci sono delle considerazioni da fare:
La pioggia è un evento che accade con tempi molto diversi, possono occorrere giorni o mesi prima che si verifichi, può durare minuti oppure molte ore. Questi fatti rendono problematico l'uso di Arduino in quanto dovremmo aspettare l'impulso dal reed senza poter fare altro.

Fortunatamente possiamo risolvere anche questi problemi con l' INTERRUPT.
L'IDE di arduino ci rende disponibile l'utilizzo degli interrupt in modo semplificato con la chiamata ad una funzione specifica (vedi reference di arduino).

attachInterrupt() vedremo nello sketch come utilizzare questa funzione per approfondimenti sul tema degli interrupt vi consiglio di leggere sul sito di Michele Maffucci, e sul sito di Mauro Alfieri, logicamente anche il reference sul sito arduino.

In breve questa funzione abilita uno o più d'uno (su Arduino UNO i pin 2 e 3),  ad ascoltare il verificarsi di un'evento, quando questo si verifica il microcontollore sospende quello che stà facendo ed esegue la routin che abbiamo preparato, eseguita questa torna al programma.

Così abiliteremo un pin (2 o 3) in attesa che la vaschetta riempita dalla pioggia ruoti, azionando il reed, e quindi il microcontrollore sospende quello che stà facendo conteggia l'avvenuto svuotamento della bascula e torna a fare quelle che deve .... fino al verificarsi di altro evento.

Tutto qui. Si dobbiamo anche tener conto del passare del tempo perchè trascorso il tempo che vogliamo, dovremo resettare il conteggio, magari alle 24 di ogni giorno.
Ma potremmo farlo anche ogni ora.

 Ho realizzato questi collegamenti:

 Nelle foto qui sotto la realizzazione pratica del collegamento del pluviometro.

L'insieme.

Il pluviometro

 I collegamenti sulla BB.

Sulla destra ho posizionato due led il LED verde lampeggia (loop principale) facendo lavorare il microcontrollore, al momento dell'Interrupt, esegue il conteggio della basculata accende il LED giallo e poi riprende il lampeggio del LED verde.
Nella versione successiva lo sketch, anzichè far lampeggiare un LED eseguirà le altre misure utili alla stazione meteo.

Lo sketch.
//------------------------------------------------------------------------------------------------------------//

/*
 *** Sergio & Adriano Prenleloup ****
  
 ***** Stazione Meteo *********
 *** Prova per pluviometro ****
 *** Versione 0.01 ************
 ******   02/02/2014 **********
 ******************************
  
Questa è una prova con led per provare e tarare il pluviometro
si utilizza un led lampenggiante che viene "INTERROTTO" dalla
chiamata del pluviometro, si conteggia l'avvenuta basculata
del pluviometro, si sommano i millimitri caduti si accende il led
giallo quidi si torna al programma principale.
*/

// -----------------------------------------------------------------------
// costanti
const unsigned int durataMisura = 60 * 1000;   //durata osservazione
// questa durata osservazione è di 60 secondi e serve  solo per il
// filmato dimostrativo - sarà invece di 24 ore o frazioni da cumulare
// fino alle 24 ore.
// -------------------------------------------------------------------
// led dimostrativi
const int pinLed_blink = 5; // led verde che lampeggia
const int pinLed_inter = 6; // led gallo per interrupt
//--------------------------------------------------------------------
// costante contenuto in mm di ogni bascula ( venditore e nostra)
//const float mmGoccia = 0.3; // costante bascula indicata dal venditore
const float mmGoccia = 0.43; // costante bascula ricavata ( vedi blog)
                             // corrisponde ai mm di pioggia per ogni bascula
const int pinInterrupt = 2; // pin interrupt "0"
//-------------------------------------------------------------------------
// variabili usate nella funzione interrupt
//-------------------------------------------------------------------------
volatile unsigned int gocce = 0; // variabile conteggio numero basculate
volatile float mmPioggia = 0.0; // conteggio millimetri di pioggia
volatile boolean statoLed = false; // cambia stato nell'interrupt
//-------------------------------------------------------------------------
unsigned long oraLetturaPioggia = 0; //orario lettura misura
unsigned long oraCorrente = 0;

// ---------------------------------------------------
// setup
//----------------------------------------------------
void setup()
{
  Serial.begin(9600);
  pinMode(pinLed_blink, OUTPUT);
  pinMode(pinLed_inter, OUTPUT);
  //-------------------------------------------------------------------------
  // Interrupt pluviometro
  //-------------------------------------------------------------------------
  attachInterrupt(0, ContaGocce, RISING); // modo da LOW ad HIGH
  //-------------------------------------------------------------------------
  
  oraLetturaPioggia = millis() + durataMisura; // imposta ora prima lettura
}
//--------------------------------------------------------------------------
// programma principale
//--------------------------------------------------------------------------
void loop()
{
  // operazioni perdita di tempo
  digitalWrite(pinLed_blink, HIGH); 
  delay(100);
  digitalWrite(pinLed_blink, LOW);
  delay(100);
  //--------------------------------
  
  // stampa letture
  oraCorrente = millis();
  if (oraCorrente > oraLetturaPioggia) // si controlla se ora di chiusura
                                       // del conteggio
  {
    Serial.print("Pioggia caduta in ");
    Serial.print(durataMisura /1000);
    Serial.print("s = ");
    Serial.print(gocce);
    Serial.print(" = ");    
    Serial.print(mmPioggia);
    Serial.println(" mm");    
    //azzera millimetri misurati (=> vuota contenitore)
    gocce = 0;
    mmPioggia = 0;
    //imposta ora della prossima lettura
    oraLetturaPioggia = oraCorrente + durataMisura;
  }
}
//--------------------------------------------------
// funzione interrupt
//--------------------------------------------------
void ContaGocce()
{
  gocce++; // incrementa numero basculate
  mmPioggia = mmPioggia + mmGoccia; // sommatoria millimetri pioggia
  statoLed = !statoLed;
  digitalWrite(pinLed_inter, statoLed ? HIGH : LOW);
}

Per provare il funzionamento ho eseguito la taratura del pluviometro, in questo modo:

1) ho misurato 50ml di acqua con un misurino graduato
1b) misurata la superficie del pluviometro.
2) avviato lo sketch con interrupt.
3) cominciato ad introdurre acqua nel pluviometro ( vedi filmato).
4) contato le "basculate" cioè gli impulsi dati dal reed.
5) confrontato se i mm/m² corrispondono a quelli teorici.
6) aggiustata la costante fornita dal venditore e ricominciato dal passo 2.

Ma quali sono i mm/m² teorici?

Rileggendo il primo pezzo di questo post abbiamo la risposta  - ml raccolti / superficie in cm²   

Nel mio caso ho versato 50ml,  in volume = 50 cm³.
La superficie è 5*11 = 55 cm²  quindi (cm³/cm²) = cm.  quindi ( 50cm³/ 55cm²) = cm 0,909 cioè    mm= 9,09  
 Come potete vedere qui sotto lo screenshot  del monitor seriale non siamo lontani da quanto previsto in teoria.
In ogni caso prima della messa in funzione definitiva farò  ulteriori controlli, in ogni caso è importante aver stabilito un metodo per eseguire la taratura.

Qui sotto un filmato dimostrativo

 

Attendo commenti e suggerimenti

Nel prossimo post vedremo come misurare la pressione atmosferica.
Grazie per avermi seguito....