Stazione Meteo v.103

Stazione Meteo con Arduino UNO

In questo post pubblico lo sketch che riunisce i precedenti relativi alla stazione meteo.

Gli sketch sono stati revisionati ed integrati fra loro.

Questa non è la versione definitiva ed alcune parti dello sketch sono state scritte pensando alla prossima versione.

In ogni caso lo sketch è funzionante.

La scheda pronta al centro BMP180 e DHT22

Qui sono riunite le seguenti funzioni:

Misura temperatura ed umidità con DHT22.

Misura pressione e temperatura con BMP180.

Misura velocità del vento con anemometro a coppette.

Pluviometro.

Direzione del vento.

E' sta aggiunta una visualizzazione sul display LCD 20x2 con rotazione delle misure effettuate.
-------------------------------------------------------------------------------------------------------------------

Materiale occorrente:

Arduino UNO

DHT22 

BMP180 

Sensore pluviometro.

Sensore direzione vento.

Anemometro a coppette.

Per questi sensori consultate i singoli post su questo stesso blog.

2) condensatori ceramici da 100 nF 6,3V.

4) resistenze da 10 Kohm.

2) resistenze da 100 ohm.

1) Trimmer da 10 Kohm.

1) display LCD 20x2

3) morsetti due poli per il collegamento dei sensori.

Filo per collegamento, breadboard o basetta mille fori.

Minuteria e contenitore.

In particolare se volete autocostruire la banderuola consultate il blog occorrono:

1) resistenza da 10K

1) resistenza da 56K

1) resistenza da 15K

1) resistenza da 8,2k

1) resistenza da 33K

4) ampolle reed

1) piccolo magnete.

vedi post banderuola

vedi post anemometro

vedi post pluviometro

Qui sotto lo schema della stazione completa.

(corretto schema 16/3/2016)

Ai morsetti saranno collegati i sensori anemometro, pluviometro, direzione vento.

In questo modo la stazione meteo è in grado di rilevare e mostrare a rotazione sul display le misure effettuate.

Per un lavoro più completo si dovrebbe aggiungere un orologio ed una registrazione delle misure, vedrò di procurarmi il materiale necessario e di completare il lavoro.

 Se avete dubbi o domande consultatemi lasciando un commento. ( Indicate un nome od un Nickname)

Sul mio canale YOUTUBE trovate un piccolo video dimostrativo

======= INIZIO SKETCH =======================

/*

************************************************

*****   Sergio & Adriano Prenleloup        *****

************************************************

*****   Stazione meteorologica             *****

*****   Versione che riunisce gli sketch   *****

*****    ------ ver. 1.03 del 9/3/2014     *****

************************************************

** IN QUESTO SKETCH SONO RIUNITI E REVISIONATI

** GLI SKETCH QUI SOTTO ELENCATI E GIA' PUBBLICATI

** SUL BLOG  http://avventurarduino.blogspot.it

 

/*

//---------------------------------------------------------------

//  PRESSIONE

//---------------------------------------------------------------

 **** Stazione Meteo *********

 *** Temperatura, Umidità  ****

 *** pressione atmosferica ****

 *** Versione 1.01 ************

 ******   22/02/2014 **********

 ******************************

 **sensore  DHT22 *************

 **sensore  BMP180 ************

 * Rileva Temperatura e Umidità mediante il sensore DHT22

 * e mostra i dati su display LCD 2002A (20 caratteri, 2righe)

 * Inoltre gestisce con pulsante la lettura

 * di temperatura minima e massima e lo switch

 * per mostrare le informazioni sul display

 *

 * schema e ulteriori informazioni

 * sul BLOG.

 * Circuito

 * LCD GND     -> blu     -> pin 14

 * LCD RS      -> marrone -> pin 13

 * LCD ENABLE  -> giallo  -> pin 12

 * LCD D4 (11) -> marrone -> pin 10

 * LCD D5 (12) -> rosso   -> pin 9

 * LCD D6 (13) -> verde   -> pin 11

 * LCD D7 (14) -> arancio -> pin 8

 * LCD 5v      -> rosso   -> pin 5v

 *

 * Pin DHT 22         -> pin 5

 * Pin bottone switch -> pin 2

 *

 * Sensore pressione BMP180

 *  SDA              -> A4

 *  SCL              -> A5

 */

//-----------------------------------------------------------

//  PLUVIOMETRO

//-----------------------------------------------------------

/*

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

*/

// -----------------------------------------------------------------------

// ANEMOMETRO E BANDERUOLA

//------------------------------------------------------------------------

/*

//*************************************************

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

//**************************************************

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

//**********************************************************

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

*/

#include <LiquidCrystal.h> // libreria LCD

//NOTA: esistono tre librerie per la gestione del sensore DHT

//- La "DHT22" è più vecchia e specifica per il sensore DHT22

//- La "DHT" è più recente e, oltre a rilevare automaticamente

//il tipo di sensore,

//  promette una minore occupazione di memoria

//- La "A_DHT" è quella descritta sul sito di Arduino

//#include <DHT22.h>       // libreria sensore temperatura e umidita

#include <dht.h>           // libreria sensore temperatura e umidita

//#include <A_DHT.h>

#include <SFE_BMP180.h>    // libreria sensore pressione

#include <Wire.h>          // wire per comunicazione bus

// ----------------------------------------------------------------------------

// Configurazione PIN

// -----------------------------------------------------------------------------

#define WIND_DIR_PIN    0 // A0: Pin analogico dedicato al sensore direzione vento.

#define SDA_PIN         4 // A4: SDA, bus I2C per la comunicazione con BMP180

#define SCL_PIN         5 // A5: SCL  bus I2C per la comunicazione con BMP180

#define DHT22_PIN       5 // piedino dati sensore DHT

#define REED_PIN        6 // pin assegnato al contatto reed ANEMOMETRO

#define INTERRUPT_PIN   2 // pin interrupt "0" PLUVIOMETRO

// pin digitali utilizzati per il display LCD

#define LCD_RS_PIN 13

#define LCD_EN_PIN 12

#define LCD_D4_PIN 10

#define LCD_D5_PIN 9

#define LCD_D6_PIN 11

#define LCD_D7_PIN 8

#define ALTITUDINE 234.3 // Altitude del luogo dove si trova il sensore

// ----------------------------------------------------------------------

// Dichiarazione classi lcd e dht e chiamate costruttori

// ---------------------------------------------------------------------

// Inizializa la libreria per la gestione dell'LCD

// LiquidCrystal(rs, enable, d4, d5, d6, d7)

LiquidCrystal lcd(LCD_RS_PIN, LCD_EN_PIN, LCD_D4_PIN, LCD_D5_PIN, LCD_D6_PIN,

LCD_D7_PIN);

// Inizializza la libreria per comunicare con il sensore DHT22

//DHT dht;

dht dhtsensor;

// Notare che l'inizializzazione della lib richiede il il pin nel costruttore

//DHT22 dht(DHT22_PIN);

// Inizializza la libreria per lettura dati pressione

SFE_BMP180 pressure;

// -----------------------------------------------------------------------

// Costanti e variabili gestione temp max e temp min

// -----------------------------------------------------------------------

const int D_TEMP_CUR   = 0;

const int D_UMID_CUR   = 1;

const int D_TEMP_MAX   = 2;

const int D_TEMP_MIN   = 3;

const int D_TEMP2_CUR  = 4;

const int D_PRESS_CUR  = 5;

const int D_PREL_CUR   = 6;

const int D_ALT_CUR    = 7;

const int D_WIND_SPEED = 8;

const int D_WIND_DIR   = 9;

const int D_BASCULATE_CNT = 10;

const int D_MM_PIOGGIA    = 11;

// ------------------------------------------------------------------------

// Array contenente tutti i dati raccolti

// ------------------------------------------------------------------------

double dati[12];

// -----------------------------------------------------------------------

// Variabili gestione lettura e timer

// -----------------------------------------------------------------------

const byte TMR_TH       = 0;

const byte TMR_TP       = 1;

const byte TMR_VENTO    = 2;

const byte TMR_PIOGGIA  = 3;

const byte TMR_INFO     = 4;

const int DELAY_LETTURE[5] = {

  30,  //900 secondi = 15 minuti, tempo tra le letture di temp e umidità

  30,  //900 secondi = 15 minuti, tempo tra le letture di pressione

  45, //1800 secondi = 30 minuti, tempo tra le letture di velocità del vento

  60, //24 ore = tempo tra le letture del pluviometro

  3    //tempo tra le rotazioni delle pagine informazioni

};

unsigned long ora_lettura[5];

//----------------------------------------------------------------

//    P L U V I O M E T R O

//----------------------------------------------------------------

//durata osservazione pluviometro (in secondi)

const unsigned int MISURA_PLUVIOMETRO = 24 * 60 * 60;  

//costante contenuto in mm di ogni bascula (venditore e nostra)

//corrisponde ai mm di pioggia per ogni bascula

//const float MM_GOCCIA = 0.3; // costante bascula indicata dal venditore

const float MM_GOCCIA = 0.43; // costante bascula ricavata ( vedi blog)

//-------------------------------------------------------------------------

// variabili usate nella funzione interrupt

//-------------------------------------------------------------------------

volatile unsigned int basculate = 0; // variabile conteggio numero basculate

volatile float mmPioggia = 0.0; // conteggio millimetri di pioggia

//-------------------------------------------------------------------------

// costanti e variabili per Banderuola

//-------------------------------------------------------------------------

// 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;

const int DIR_VENTO_NA        = -1;

const int DIR_VENTO_NORD        = 0;

const int DIR_VENTO_NORD_EST    = 1;

const int DIR_VENTO_EST         = 2;

const int DIR_VENTO_SUD_EST     = 3;

const int DIR_VENTO_SUD         = 4;

const int DIR_VENTO_SUD_OVEST   = 5;

const int DIR_VENTO_OVEST       = 6;

const int DIR_VENTO_NORD_OVEST  = 7;

char* directions[] = {

  "Nord",

  "Nord-Est",

  "Est",

  "Sud-Est",

  "Sud",

  "Sud-Ovest",

  "Ovest",

  "Nord-Ovest"

};

//----------------------------------------------------------

// costanti e variabili per anemometro

// ---------------------------------------------------------

const float Pi = 3.141593; // Pigreco

const float raggio = 0.06; // raggio dell'anemometro in metri

// numero di millisecondi (2 seondi)

//per azzerare il conteggio e calcolare la Velocità

// così non si conteggiano brevi folate di vento

const unsigned long int DURATA_LETTURA_VENTO = 2000;

//----------------------------------------------------------

// costanti e variabili per rotazione pannello

// ---------------------------------------------------------

const byte PAN_TEMP = 1;

const byte PAN_TEMP_MIN_MAX = 2;

const byte PAN_PRESS_A = 3;

const byte PAN_PRESS_R = 4;

const byte PAN_WIND = 5;

const byte PAN_PIOGGIA = 6;

byte pannello_corrente = 0;

// ------------------------------------------------------------------------

// Funzioni di utilità generale

// -------------------------------------------------------------------------

//ritorna il numero di secondi da quando è stato avviato arduino

unsigned long seconds()

{

  return millis() / 1000;

}

// --------------------------------------------------------------------------

// Metodi gestione aggiornamento e Min, Max temp

// ---------------------------------------------------------------------------

// Aggiorna le temperature minime e massime solo se necessario

void aggiorna_min_max(double temp)

{

  if (temp > dati[D_TEMP_MAX])

  {

    dati[D_TEMP_MAX] = temp;

  }

  if (temp < dati[D_TEMP_MIN])

  {

    dati[D_TEMP_MIN] = temp;

  }

}

// legge i valori di temperatura e umidità interrogando il sensore

// ritorna true se la lettura ha avuto successo false in caso di errore

boolean leggi_temperatura_e_umidita(double& temp, double& umidita)

{

  // Avvia la lettura e legge lo stato

  int chk = dhtsensor.read22(DHT22_PIN);

  switch (chk)

  {

    case DHTLIB_OK:

      //Serial.print("OK,\t");

      break;

    case DHTLIB_ERROR_CHECKSUM:

      Serial.println("Checksum error,\t");

      return false;

    case DHTLIB_ERROR_TIMEOUT:

      Serial.println("Time out error,\t");

      return false;

    default:

      Serial.println("Unknown error,\t");

      return false;

  }

  // se la lettura ha avuto successo, i due valori sono disponibili nelle

  // due variabili corrispondenti

  temp = dhtsensor.temperature;

  umidita = dhtsensor.humidity;

  return true;

}

// legge i valori di temperatura e pressione interrogando il sensore BMP

boolean leggi_temperatura_e_pressione(double& temp, double& pres, double& pr,

double& alt)

{

  boolean res = false;

  double T, P, p0, a;

  // Prima di poter leggere la pressione e' necessario effettuare una lettura della

  // temperatura

  // Invia il comando per iniziare la lettura della temperatura

  // Se il comando ha successo ritorna il numero di millisecondi

//da attendere prima di ricevere il dato

  // In caso di errore ritorna 0

  int stat = pressure.startTemperature();

  if (stat != 0)

  {

    // Attende il completamento della lettura della temperatura

    delay(stat);

    // Adesso si puo' recuperare il valore, il valore è salvato in T

    stat = pressure.getTemperature(T);

    if (stat != 0)

    {

      // si ripete il procedimento per la lettura della pressione

      // Il parametro 3 indica la precisione (lettura piu' lenta)

      stat = pressure.startPressure(3);

      if (stat != 0)

      {

        delay(stat);

        // Si legge il valore della pressione assoluta e si salva in P

        // la funzione richiede la temperatura corrente

        stat = pressure.getPressure(P, T);

        // calcola la pressione relativa, compensando con l'altitudine locale

        p0 = pressure.sealevel(P, ALTITUDINE);

        // Infine calcola l'altitudine in base alla pressione

//misurata e alla pressione al livello del mare

        a = pressure.altitude(P, p0);

        // la lettura ha avuto successo, si aggiornano le variabili

        res = true;

        pres = P;

        temp = T;

        pr = p0;

        alt = a;

      }

    }

  }

  return res;

}

// funzioni di utilità per stampare i valori su lcd (min e max)

void print_lcd_min_max(double t_min, double t_max)

{

  lcd.clear();

  lcd.setCursor(0, 0);

  lcd.print("T MAX: ");

  lcd.print(t_max, 1);

  lcd.print(" C");

  lcd.setCursor(0, 1);

  lcd.print("T MIN: ");

  lcd.print(t_min, 1);

  lcd.print(" C");

}

// funzioni di utilità per stampare i valori su lcd (temp e umid)

void print_lcd_temp_umid(double temp, double umid)

{

  lcd.clear();

  lcd.setCursor(0, 0);

  lcd.print("Temp : ");

  lcd.print(temp, 1);

  lcd.print(" C");

  lcd.setCursor(0, 1);

  lcd.print("Umid : ");

  lcd.print(umid, 1);

  lcd.print(" %");

}

void print_lcd_temp_press(double temp, double pres)

{

  lcd.clear();

  lcd.setCursor(0, 0);

  lcd.print("Temp : ");

  lcd.print(temp, 1);

  lcd.print(" C");

  lcd.setCursor(0, 1);

  lcd.print("Pres : ");

  lcd.print(pres, 1);

  lcd.print(" mb");

}

void print_lcd_pr_altitudine_lcd(double pr, double alt)

{

  lcd.clear();

  lcd.setCursor(0, 0);

  lcd.print("Pres. rel. : ");

  lcd.print(pr, 1);

  lcd.print(" mb");

  lcd.setCursor(0, 1);

  lcd.print("Altitudine : ");

  lcd.print(alt, 1);

  lcd.print(" m");

}

void print_lcd_velocita_direzione(double vel, double dir)

{

  char* dirText = " --- ";

  if (dir >= 0 && dir <= 7)

  {

    int intDir = (int) dir;

    dirText = directions[intDir];

  }

  lcd.clear();

  lcd.setCursor(0, 0);

  lcd.print("Vel : ");

  lcd.print(vel, 1);

  lcd.print(" m/s");

  lcd.setCursor(0, 1);

  lcd.print("Dir : ");

  lcd.print(dirText);

}

void print_lcd_pioggia(double mm, double cnt)

{

  lcd.clear();

  lcd.setCursor(0, 0);

  lcd.print("mm pioggia : ");

  lcd.print(mm, 1);

  lcd.setCursor(0, 1);

  lcd.print("basculate  : ");

  lcd.print(cnt, 1);

}

void print_ora_stato()

{

  lcd.clear();

  lcd.setCursor(0, 0);

  lcd.print("Ora corrente : ");

  lcd.print(seconds(), 1);

  lcd.setCursor(0, 1);

  lcd.print("Ultima misura: ");

  lcd.print(0, 1);

}

void print_lcd_informazioni(byte id_pannello)

{

  switch (id_pannello) {

      case PAN_TEMP:

        print_lcd_temp_umid(dati[D_TEMP_CUR], dati[D_UMID_CUR]);

        break;

      case PAN_TEMP_MIN_MAX:

        print_lcd_min_max(dati[D_TEMP_MIN], dati[D_TEMP_MAX]);

        break;

      case PAN_PRESS_A:

        print_lcd_temp_press(dati[D_TEMP_CUR], dati[D_PRESS_CUR]);

        break;

      case PAN_PRESS_R:

        print_lcd_pr_altitudine_lcd(dati[D_PREL_CUR], dati[D_ALT_CUR]);

        break;

      case PAN_WIND:

        print_lcd_velocita_direzione(dati[D_WIND_SPEED], dati[D_WIND_DIR]);

        break;

      case PAN_PIOGGIA:

        print_lcd_pioggia(dati[D_MM_PIOGGIA], dati[D_BASCULATE_CNT]);

        break;

      default:

        print_ora_stato();

  }

}

void print_lcd_misura(char* info_text)

{

  lcd.clear();

  lcd.setCursor(0,0);

  lcd.print("Misura in corso...");

  lcd.setCursor(0,1);

  lcd.print(info_text);

}

void print_dati_console()

{

  Serial.println("=======================================");

  Serial.println("Dati rilevati DHT22");

  Serial.println("=======================================");

  Serial.print  ("Umidita' (%)      : "); Serial.println(dati[D_UMID_CUR], 1);

  Serial.print  ("Temp. (C)         : "); Serial.println(dati[D_TEMP_CUR], 1);

  Serial.print  ("Temp. MIN (C)     : "); Serial.println(dati[D_TEMP_MIN], 1);

  Serial.print  ("Temp. MAX (C)     : "); Serial.println(dati[D_TEMP_MAX], 1);

  Serial.println("=======================================");

  Serial.println("Dati rilevati BMP180");

  Serial.println("========================================");

  Serial.print  ("Temperatura (C)   : "); Serial.println(dati[D_TEMP2_CUR], 1);

  Serial.print  ("Pr. assoluta (mb) : "); Serial.println(dati[D_PRESS_CUR], 1);

  Serial.print  ("Pr. relativa (mb) : "); Serial.println(dati[D_PREL_CUR], 1);

  Serial.print  ("Altitudine (m)    : "); Serial.println(dati[D_ALT_CUR], 1);

  Serial.println("=======================================");

  Serial.println("Dati rilevati Pioggia");

  Serial.println("========================================");

  Serial.print  ("Numero basculate  : "); Serial.println(dati[D_BASCULATE_CNT], 1);

  Serial.print  ("mm di pioggia     : "); Serial.println(dati[D_MM_PIOGGIA], 1);

  char* dirText = " --- ";

  if (dati[D_WIND_DIR] >= 0 && dati[D_WIND_DIR] <= 7)

  {

    int intDir = (int) dati[D_WIND_DIR];

    dirText = directions[intDir];

  }

 

  Serial.println("=======================================");

  Serial.println("Dati rilevati Anemometro");

  Serial.println("========================================");

  Serial.print  ("Velocità vento    : "); Serial.println(dati[D_WIND_SPEED]);

  Serial.print  ("Direzione vento   : "); Serial.println(dirText);

}

//--------------------------------------------------

// funzione interrupt

//--------------------------------------------------

void conta_basculate()

{

  basculate++; // incrementa numero basculate

  mmPioggia = mmPioggia + MM_GOCCIA; // sommatoria millimetri pioggia

  //--- Led usato in fase di test ------------

  //statoLed = !statoLed;

  //digitalWrite(pinLed_inter, statoLed ? HIGH : LOW);

}

//-------------------------------------------------

// Banderuola

//-------------------------------------------------

int banderuola()

{

  //----------------------------------------------------------------

  // lettura Banderuola e media dei valori

  //----------------------------------------------------------------

  int sommadir = 0;

  int Vdir = 0;

  for (int i = 0; i < 9; i++)

  {

    Vdir = analogRead(WIND_DIR_PIN); // 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)))

  {

    return DIR_VENTO_NORD;

    //char Direzione[] = "Direzione = Nord";

    //Serial.print(Direzione);

  }

  if  ((Vdir > (nordest - 25)) && (Vdir < (nordest + 25)))

  {

    return DIR_VENTO_NORD_EST;

    //char Direzione[] = "Direzione = Nord-Est ";

    //Serial.print(Direzione);

  }

  if  ((Vdir > (est - 25)) && (Vdir < (est + 25)))

  {

    return DIR_VENTO_EST;

    //char Direzione[] = "Direzione = Est ";

    //Serial.print(Direzione);

  }

  if ((Vdir > (sudest - 25)) && (Vdir < (sudest + 25)))

  {

    return DIR_VENTO_SUD_EST;

    //char Direzione[] = "Direzione = Sud-Est ";

    //Serial.print(Direzione);

  }

  if ((Vdir > (sud - 25)) && (Vdir < (sud + 25)))

  {

    return DIR_VENTO_SUD;

    //char Direzione[] = "Direzione = Sud ";

    //Serial.print(Direzione);

  }

  if ((Vdir > (sudovest - 25)) && (Vdir < (sudovest + 25)))

  {

    return DIR_VENTO_SUD_OVEST;

    //char Direzione[] = "Direzione = Sud-Ovest ";

    //Serial.print(Direzione);

  }

  if ((Vdir > (ovest - 25)) && (Vdir < (ovest + 25)))

  {

    return DIR_VENTO_OVEST;

    //char Direzione[] = "Direzione = Ovest ";

    //Serial.print(Direzione);

  }

  if ((Vdir > (nordovest - 25)) && (Vdir < (nordovest + 25)))

  {

    return DIR_VENTO_NORD_OVEST;

    //char Direzione[] = "Direzione = Nord-Ovest ";

    //Serial.print(Direzione);

  }

}

//----------------------------------------

// fine banderuola

//------------------------------------------

//--------------------------------------------

// loop principale anemometro + banderuola

//--------------------------------------------

boolean leggi_velocita_e_direzione_vento(double& vel_vento, double& dir_vento)

{

  int stato_reed = 0;

  int stato_reed_old = 1;

  int conteggio = 0;                // variabile che contiene

//il conteggio delle pulsazioni

  int direzione = -1;

  unsigned long tempo_lettura = 0;  // indica da quanti millisecondi

//stiamo osservando l'anemometro  

  unsigned long tempo_start;        // memorizza i  millisecondi

//dalla prima pulsazione conteggiata

 

  tempo_start =  millis();          // si memorizza il tempo di partenza

  stato_reed_old = stato_reed = digitalRead(REED_PIN); // legge il contatto reed

 

  while (tempo_lettura < DURATA_LETTURA_VENTO)

  {

    stato_reed = digitalRead(REED_PIN);  // legge il contatto reed

    if (stato_reed != stato_reed_old)   // si verifica se è cambiato

    {

      stato_reed_old = stato_reed;      // se SI si aggiorna lo stato

      if (stato_reed == HIGH)           // si controlla SE è alto (passaggio magnete)

      {

        conteggio = conteggio + 1;      // si aggiorna il contatore

        direzione = banderuola();       // sembra esserci vento,

//chiama ed esegue banderuola

      }

    }

    tempo_lettura = (millis() - tempo_start); // si conteggia il tempo

//trascorso dallo start conteggio

  }

  // se il tempo trascorso è maggiore o uguale al tempo impostato

  // si eseguono i calcoli e la stampa della velocità

  double deltaTempo = (DURATA_LETTURA_VENTO / 1000.0); // si trasforma in secondi

  double Metris = (conteggio * Pi * raggio) / deltaTempo; // si calcola la velocità

//in metri/s

  double Kmora = (3.6 * conteggio * Pi * raggio) / deltaTempo; //formula per

//il calcolo della velocità in Km/h

  double Node = (Metris / 0.514444); // si porta in nodi

  vel_vento = Metris;

  dir_vento = direzione;

  return true;

}

// -------------------------------------------------------------------------

// Logica per lettura e aggiornamento dati

// -------------------------------------------------------------------------

// ritorna true se dall'ultima lettura è trascorso il tempo fissato

boolean check_timeout(byte timerID)

{

  unsigned long ora_corrente = seconds();

  return ora_corrente > ora_lettura[timerID];

}

void reimposta_timer(char timerID)

{

  //imposta l'ora della prossima lettura, da ora a "DELAY_LETTURE" millisecondi

  ora_lettura[timerID] = seconds() + DELAY_LETTURE[timerID];

}

void effettua_lettura_TH()

{

  double temp_corrente = 0;

  double umid_corrente = 0;

  print_lcd_misura("Temp, Umid");

  // si leggono i dati dal sensore di umidita'

  if (leggi_temperatura_e_umidita(temp_corrente, umid_corrente))

  {

    //..si aggiorna il vettore con tutti i dati

    dati[D_TEMP_CUR] = temp_corrente;

    dati[D_UMID_CUR] = umid_corrente;

    // si controlla se min e max sono cambiati

    aggiorna_min_max(temp_corrente);

  }

}

void effettua_lettura_TP()

{

  double t_corrente = 0;

  double p_corrente = 0;

  double pr_corrente = 0;

  double a_corrente = 0;

  print_lcd_misura("Pressione");

  // si leggono i dati dal sensore di pressione

  if (leggi_temperatura_e_pressione(t_corrente, p_corrente, pr_corrente, a_corrente))

  {

      dati[D_TEMP2_CUR] = t_corrente;

      dati[D_PRESS_CUR] = p_corrente;

      dati[D_PREL_CUR] = pr_corrente;

      dati[D_ALT_CUR] = a_corrente;  

  }

}

void effettua_lettura_AN()

{

  double vento_vel = 0;

  double vento_dir = 0;

  print_lcd_misura("Vel,Dir vento");

  // si leggono i dati da anemometro

  if (leggi_velocita_e_direzione_vento(vento_vel, vento_dir))

  {

      dati[D_WIND_SPEED] = vento_vel;

      dati[D_WIND_DIR] = vento_dir;  

  }

}

void effettua_lettura_Pioggia()

{

  print_lcd_misura("Pluviometro");

  // sospendiamo la rilevazione degli interrupts

  noInterrupts();

 

  // salviamo i dati

  dati[D_BASCULATE_CNT] = basculate;

  dati[D_MM_PIOGGIA] = mmPioggia;  

 

  //azzera millimetri misurati (=> vuota contenitore)

  basculate = 0;

  mmPioggia = 0;

  // si riattivano gli interrupts

  interrupts();

}

// ----------------------------------------------------------------------

// Setup LCD

// ----------------------------------------------------------------------

void setup_LCD()

{

  lcd.begin(20, 2);

}

// -----------------------------------------------------------------------

// Funzioni per il setup dei sensori

// -----------------------------------------------------------------------

void setup_DHT()

{

  Serial.print("Inizializzazione DHT...");

  lcd.clear();

  lcd.print("Conf: DHT");

  // All'avvio il sensore DHT e' disponibile dopo due secondi

  delay(2000);

  Serial.println("OK");

}

void setup_BMP()

{

  Serial.print("Inizializzazione BMP...");

  lcd.clear();

  lcd.print("Conf: BMP");

  // Inizializza il sensore di pressione

  // in questa fase il sensore recupera dei valori memorizzati

// al suo interno che usa per la sua calibrazione

  if (pressure.begin())

  {

    Serial.println("OK");

    Serial.print("Altitudine sensore: ");

    Serial.println(ALTITUDINE);

  }

  else

  {

    // L'inizializzazione puo' fallire a causa di problemi di connessione con il bus

    Serial.println("ERRORE!! ");

    while (1); // Attesa infinita --> resettare arduino

  }

}

void setup_anemometro()

{

  pinMode(REED_PIN, INPUT);// mette in ascolto del reed il pin 2

}

void setup_banderuola()

{

  pinMode(WIND_DIR_PIN, INPUT);// mette in ascolto del reed il pin A0

}

void setup_pluviometro()

{

  // interrupt pluviometro

  attachInterrupt(0, conta_basculate, RISING); // modo da LOW ad HIGH

}

void setup_timers()

{

  //imposta i timers per la prima lettura

  ora_lettura[TMR_TH] = 0;

  ora_lettura[TMR_TP] = 0;

  ora_lettura[TMR_VENTO] = 0;

  ora_lettura[TMR_PIOGGIA] = 0;

}

void setup_dati()

{

  dati[D_TEMP_MAX] = -100;

  dati[D_TEMP_MIN] = 100;

}

void cambia_pannello()

{

  pannello_corrente++;

  if (pannello_corrente > PAN_PIOGGIA)

  {

    pannello_corrente = 0;

  }

  print_lcd_informazioni(pannello_corrente);

}

// --------------------------------------------------

// setup generale e loop principale sketch

// --------------------------------------------------

void setup()

{

  // Per poter mostrare informazioni sul setup deve essere

  // prima di tutto configurato LCD e seriale

  Serial.begin(9600);

  setup_LCD();

  setup_DHT();

  setup_BMP();

  setup_anemometro();

  setup_banderuola();

  setup_pluviometro();

  setup_timers();

  setup_dati();

}

void loop()

{

  //controlla_bottone();

  //int modo = modo_operativo_menu();

  // si controlla se è giunto il momento di effettuare le letture

  if (check_timeout(TMR_TH))

  {

    // se si, allora si recuperano i dati e si imposta l'ora della prossima lettura

    effettua_lettura_TH();

    reimposta_timer(TMR_TH);

    print_dati_console();

  }

  else if (check_timeout(TMR_TP))

  {

    effettua_lettura_TP();

    reimposta_timer(TMR_TP);

    print_dati_console();

  }

  else if (check_timeout(TMR_VENTO))

  {

    effettua_lettura_AN();

    reimposta_timer(TMR_VENTO);

    print_dati_console();

  }

  else if (check_timeout(TMR_PIOGGIA))

  {

    effettua_lettura_Pioggia();

    reimposta_timer(TMR_PIOGGIA);

    print_dati_console();

  }

  else if (check_timeout(TMR_INFO))

  {

    cambia_pannello();

    reimposta_timer(TMR_INFO);

  }

}

// END

Grazie per l'attenzione

Sergio