Le prove di permeabilità
Dicembre 22, 2019
QGIS: come creare un file kmz da uno shapefile
Febbraio 5, 2020
Show all

Come costruire un stazione meteo con Arduino

La Geologia ha un’importante influenza in ambito meteo-climatico. Ad esempio la conformazione del territorio, le montagne, la posizione e dimensione dei continenti, hanno un peso nell’evoluzione delle masse d’aria, sia a livello sinottico che micro-climatico.

In ambito geologico vi sono inoltre anche fenomeni improvvisi ed intensi, che possono avere un’influenza shock sul meteo e sul clima. Pensa ai vulcani: il 1816 viene ricordato come ” l’anno senza estate” dato fu un anno caratterizzato da una importante variazione del clima estivo, la quale ha provocato gravi danni all’agricoltura.

L’anno senza estate fu dovuto all’eruzione del vulcano Tambora, nell’isola di Sumbawa (Indonesia), avvenuta dal 5 al 15 aprile 1815.
Questa eruzione immesse in atmosfera enormi quantità di ceneri, abbassando la temperatura media dell’aria, in quanto la luce solare faticava ad attraversare la nube cinerea.

Il Tambora, o Tomboro, è uno stratovulcano. La sua origine è legata alla subduzione della Placca australiana al di sotto della Placca della Sonda.
La sua devastante eruzione del 1815 è una delle poche VEI-7 (Volcanic Explosivity IndexIndice di Esplosività Vulcanica) a memoria storica.

vulcano-tamboro-stazione-meteo
Vulcano Tamboro, lo stratovulcano chè “cancellò” l’estate

Ma anche le condizioni meteo influenzano in modo determinante la geologia e i suoi fenomeni. Pensiamo agli eventi pluviometrici estremi – cause di frane e smottamenti – oppure ai repentini sbalzi di temperatura che degradano le rocce e materiali litodi dei monumenti del nostro patrimonio culturale. La presenza di una stazione meteo in una zona interessata da debris flows può essere molto utile per conosce in maniera dettagliata le condizioni meteo che hanno fatto innescare le colate di detrito.

In questo post vedremo come costruire, spendendo poche decine d’euro, una piccola stazione meteo con Arduino – per registrare temperatura, umidità e pressione atmosferica – elenchiamo i componenti necessari alla sua costruzione e i codici per far funzionare tutto. Per la costruzione della stazione meteo vengono usati due metodi: nel primo metodo la restituzione e visualizzazione dei dati si basa sulla registrazione dei dati su una scheda SD ed elaborazione, con Python, di questi dati. Nel secondo metodo i dati vengono trasmessi, grazie ad un modulo wifi, su ThingSpeak dove vengono plottati real-time su dei grafici. Bene, rimbocchiamoci le maniche e procediamo!

stazione-meteo-arduino

Che cosa è Arduino

Secondo il sito ufficiale Arduino é : “una piattaforma elettronica open source basata su hardware e software facili da usare”. Anche se le schede Arduino sono molto piccole ed economiche, esse sono estremamente versatili.

Le schede Arduino si possono usare per controllare le luci di casa, far funzionare un robot, lanciare un razzo amatoriale, realizzare complessi strumenti scientifici e mille altre cose. Essenzialmente una scheda Arduino è un elaboratore che legge un input e restituisce un output; ognuno di noi può programmarlo usano l’Arduino Programing Language e l’Arduino Software (IDE).

La piattaforma Arduino è stata ideata e sviluppata in data 2003 da alcuni membri dell’Interaction Design Institute di Ivrea (il nome della piattaforma deriva da quello del bar di Ivrea frequentato dai fondatori del progetto, nome che richiama a sua volta quello di Arduino d’Ivrea, Re d’Italia nel 1002.).

I progetti sviluppati con Arduino hanno trovato posto nella casa di hobbisti, negli studi di professionisti e in molte scuole, dove Arduino può diventare una grande risorsa didattica.

Il software e l’hardware di Arduino sono distribuiti con licenza copyleft, anche se il nome e il logo sono registrati, quindi terzi ne possono usufruire gratuitamente per creare prodotti propri.

I componenti necessari

I componenti necessari, con i relativi link Amazon, per costruire la nostra stazione meteo sono i seguenti:

componenti-stazione-meteo
Componenti per costruire la stazione meteo

Degli strumenti utili per la stazione meteo sono il saldatore a stagno, per saldare i pin del sensore BMP180, e l’adattatore per collegare la stazione meteo alla corrente elettrica.

Prima di procedere con l’esposizione dei due metodi con i quali si può costruire la stazione meteo, voglio spendere due parole sulla pressione atmosferica e sul funzionamento del sensore BMP180.

Che cosa è la pressione barometrica

La pressione barometrica (nota anche come pressione atmosferica), è la pressione causata dal peso dell’aria che preme sulla Terra. Immagina una colonna d’aria che sale dalla superficie terrestre fino alla cima dell’atmosfera. L’aria nell’atmosfera ha una massa, quindi la gravità fa sì che il peso di quella colonna eserciti una pressione sulla superficie.

La pressione creata da una colonna d’aria di 1 × 1 pollice che raggiunge la cima dell’atmosfera è definita come un’atmosfera (atm) di pressione. Questa colonna d’aria pesa 14,7 libbre, motivo per cui un atm equivale a 14,7 libbre per pollice quadrato (psi).

L’unità SI per la pressione è la Pascal (Pa). Un Pascal è definito come un Newton di forza per metro quadrato. Il BMP180 genera letture di pressione in Pascal, ma vengono convertiti in hectoPascals (hPa) dalla libreria software che useremo.

Le variazioni della pressione barometrica possono essere utilizzate per prevedere il tempo

Una caduta di pressione barometrica è causata da una massa d’aria che sale dalla superficie terrestre. Il vuoto creato dalla massa d’aria in aumento forma un’area a bassa pressione sulla superficie. Man mano che la massa d’aria aumenta di quota, si raffredda e si comprime. Questo condensa il vapore acqueo nell’aria, formando nuvole di pioggia. Di solito porta anche vento, perché l’aria circostante sulla superficie scorre nell’area di bassa pressione.

Una crescente pressione barometrica è causata da una massa d’aria nell’atmosfera superiore che cade sulla Terra. Il peso della massa in caduta preme sulla superficie, aumentando la pressione dell’aria sotto di essa. La massa d’aria si riscalda e si espande man mano che si avvicina alla superficie. L’aria calda in espansione è generalmente a bassa umidità, il che impedisce la formazione di nuvole. Le crescenti pressioni barometriche di solito indicano che sta arrivando un clima caldo e soleggiato.

alta-e-bassa-pressione

Il sensore BMP180

Il BMP180 è un sensore piezoresistivo che rileva la pressione. I sensori piezoresistivi sono costituiti da un materiale semiconduttore (solitamente silicio) che cambia resistenza quando viene applicata una forza meccanica come la pressione atmosferica.

Il BMP180 misura sia la pressione che la temperatura, poiché la temperatura modifica la densità dei gas come l’aria. A temperature più elevate, l’aria non è così densa e pesante, quindi applica meno pressione sul sensore. A temperature più basse, l’aria è più densa e pesa di più, quindi esercita una maggiore pressione sul sensore. Il sensore utilizza misurazioni della temperatura in tempo reale per compensare le letture della pressione per le variazioni della densità dell’aria.

Il BMP180 emette un valore di temperatura non compensato (UT) e un valore di pressione non compensato (UP). La misura della temperatura viene eseguita per prima, seguita da una misurazione della pressione.  Il BMP180 ha una EEPROM a 176 bit che contiene 11 diversi coefficienti di calibrazione unici per ciascun sensore. Questi, insieme a UP e UT, vengono utilizzati per calcolare la pressione e la temperatura barometriche reali. 

La pressione e la temperatura effettive vengono calcolate utilizzando algoritmi abbastanza complessi che vengono calcolati dalla libreria SFE_BMP180.

Stazione meteo con modulo SD Writer/Reader

I collegamenti della stazione meteo

Sensore DHT22 Scheda Arduino
+3.3V
out2
GND
Sensore BMP180 Scheda Arduino
VIN 3.3V
GND GND
SCLA5
SDAA4
Modulo SD Writer/Reader Scheda Arduino
VCC5V
CS4
MOSI11
CLK13
MISO12
GND GND
stazione-meteo-arduino-scheda-SD
Schema grafico con i collegamenti della prima versione della stazione meteo

Il codice Arduino

Una volta fatti i collegamenti, passiamo alla programmazione della stazione meteo.

Innanzitutto dobbiamo scaricare l’IDE di Arduino (clicca qui) ed installarlo.

Fatto questo installiamo le librerie necessarie per far funzionare i sensori: SFE_BMP180, DHT.h e SD.h. La libreria SFE_BMP180 serve per il barometro ed è scaricaricabile da qui. Per installarla si deve aprire l’Arduino IDE e andare a Sketch > Include Library > Add Library e quindi caricare il file zip scaricato.

   
#include <SFE_BMP180.h>
#include <Wire.h>
#include "DHT.h"
#include <SD.h> //Load SD card library

// You will need to create an SFE_BMP180 object, here called "pressure":

SFE_BMP180 pressure;
DHT dht;

unsigned long time;

#define ALTITUDE 170.0 // Altitude of SparkFun's HQ in Boulder, CO. in meters

void setup()
{
  Serial.begin(9600);
  Serial.println("REBOOT");

  // Initialize the sensor (it is important to get calibration values stored on the device).

  if (pressure.begin())
    Serial.println("BMP180 init success");
  else
  {
    // Oops, something went wrong, this is usually a connection problem,
    // see the comments at the top of this sketch for the proper connections.

    Serial.println("BMP180 init fail\n\n");
    while(1); // Pause forever.
  }



  dht.setup(2); // data pin 2
  int CS_PIN = 4;                   //SD reader/writer PIN

  if (!SD.begin(4)) {
    Serial.println("Errore SD");
    return;
  }
  Serial.println("SD pronta");

  if (SD.exists("example.txt")) {
      SD.remove("example.txt");
  }


 
//Scrivo l'header del file LOG.csv

File file = SD.open("meteo.csv", FILE_WRITE);    
if (file)
  {
    String header = "Humidity, Temperature, Pressure, Time"; //These will be the headers for your excel file, CHANGE "" to whatevr headers you would like to use
    file.println(header);
    file.close();
    Serial.println(header);
  }
}

void loop()
{
  char status;
  double T,P,p0,a;

  // Loop here getting pressure readings every 10 seconds.

  // If you want sea-level-compensated pressure, as used in weather reports,
  // you will need to know the altitude at which your measurements are taken.
  // We're using a constant called ALTITUDE in this sketch:
  
  Serial.println();
  Serial.print("provided altitude: ");
  Serial.print(ALTITUDE,0);
  Serial.print(" meters, ");
  Serial.print(ALTITUDE*3.28084,0);
  Serial.println(" feet");
  
  // If you want to measure altitude, and not pressure, you will instead need
  // to provide a known baseline pressure. This is shown at the end of the sketch.

  // You must first get a temperature measurement to perform a pressure reading.
  
  // Start a temperature measurement:
  // If request is successful, the number of ms to wait is returned.
  // If request is unsuccessful, 0 is returned.

  status = pressure.startTemperature();
  if (status != 0)
  {
    // Wait for the measurement to complete:
    delay(status);

    // Retrieve the completed temperature measurement:
    // Note that the measurement is stored in the variable T.
    // Function returns 1 if successful, 0 if failure.

    status = pressure.getTemperature(T);
    if (status != 0)
    {
      // Print out the measurement:
      Serial.print("temperature: ");
      Serial.print(T,2);
      Serial.print(" deg C, ");
      Serial.print((9.0/5.0)*T+32.0,2);
      Serial.println(" deg F");
      
      // Start a pressure measurement:
      // The parameter is the oversampling setting, from 0 to 3 (highest res, longest wait).
      // If request is successful, the number of ms to wait is returned.
      // If request is unsuccessful, 0 is returned.

      status = pressure.startPressure(3);
      if (status != 0)
      {
        // Wait for the measurement to complete:
        delay(status);

        // Retrieve the completed pressure measurement:
        // Note that the measurement is stored in the variable P.
        // Note also that the function requires the previous temperature measurement (T).
        // (If temperature is stable, you can do one temperature measurement for a number of pressure measurements.)
        // Function returns 1 if successful, 0 if failure.

        status = pressure.getPressure(P,T);
        if (status != 0)
        {
          // Print out the measurement:
          Serial.print("absolute pressure: ");
          Serial.print(P,2);
          Serial.print(" mb, ");
          Serial.print(P*0.0295333727,2);
          Serial.println(" inHg");

          // The pressure sensor returns abolute pressure, which varies with altitude.
          // To remove the effects of altitude, use the sealevel function and your current altitude.
          // This number is commonly used in weather reports.
          // Parameters: P = absolute pressure in mb, ALTITUDE = current altitude in m.
          // Result: p0 = sea-level compensated pressure in mb

          p0 = pressure.sealevel(P,ALTITUDE); // we're at 1655 meters (Boulder, CO)
          Serial.print("relative (sea-level) pressure: ");
          Serial.print(p0,2);
          Serial.print(" mb, ");
          Serial.print(p0*0.0295333727,2);
          Serial.println(" inHg");

          // On the other hand, if you want to determine your altitude from the pressure reading,
          // use the altitude function along with a baseline pressure (sea-level or other).
          // Parameters: P = absolute pressure in mb, p0 = baseline pressure in mb.
          // Result: a = altitude in m.

          a = pressure.altitude(P,p0);
          Serial.print("computed altitude: ");
          Serial.print(a,0);
          Serial.print(" meters, ");
          Serial.print(a*3.28084,0);
          Serial.println(" feet");
        }
        else Serial.println("error retrieving pressure measurement\n");
      }
      else Serial.println("error starting pressure measurement\n");
    }
    else Serial.println("error retrieving temperature measurement\n");
  }
  else Serial.println("error starting temperature measurement\n");

   delay(dht.getMinimumSamplingPeriod());

  float humidity = dht.getHumidity();
  float temperature = dht.getTemperature();

  Serial.println("Status\tHumidity (%)\tTemperature (C)\t(F)");
  
  Serial.print(dht.getStatusString());
  Serial.print("\t");
  Serial.print(humidity, 1);
  Serial.print("\t\t");
  Serial.print(temperature, 1);
  Serial.print("\t\t");
  Serial.println(dht.toFahrenheit(temperature), 1);

  delay(150000);  // Pause for 2.5 min.

  //Time
  time = millis();

//Scrivo le accelerazioni nel file LOG.csv
File file = SD.open("meteo.csv", FILE_WRITE);
String parametri = String(humidity) + "," + String(temperature) + "," + String(P) + "," + String(time);
    
  if (parametri)
  {
    file.println(parametri);
    file.close();
    Serial.println(parametri);
  }
}

Nella riga 13 viene definita l’altitudine, in metri, alla quale si trova la stazione: ricordati di cambiarla con la tua!

Acquisiti un pò di dati, possiamo estrarre la scheda SD in modo da visualizzarli con Python.

Il codice Python

[python] #Code written by Antonio Nirta import pandas as pd import matplotlib.pyplot as plt import math #import csv file. “METEO.csv” is the name of file db = pd.read_csv(“METEO.csv”) #Variables with accelerations Temperature= db.iloc[:,0] Humidity= db.iloc[:,1] Pressure= db.iloc[:,2] #Time settings time = db.iloc[:,3] #time in milliseconds, give by arduino tempo = [i/1000 for i in time] #time in seconds Pressione= [] for i in Pressure: Pressione.append(int(i)) print(Pressione) plt.subplot(3, 1, 1) plt.plot(tempo, Temperature, ‘-‘, linewidth=0.8) plt.title(‘Meteo San Luca’) plt.ylabel(‘Umidità (%)’) plt.subplot(3, 1, 2) plt.plot(tempo, Humidity, ‘-‘, color=’red’, linewidth=0.8) plt.xlabel(‘time (s)’) plt.ylabel(‘Temperatura’) plt.subplot(3, 1, 3) plt.plot(tempo, Pressione, ‘-‘, color=’green’, linewidth=0.8) plt.xlabel(‘time (s)’) plt.ylabel(‘P. atmosferica’) plt.show() # Axis’ name plt.xlabel(‘Tempo (s)’) #Show graph plt.show() [/python]

Il risultato dato da questo script è il seguente grafico

Sei digiuno di Python e vuoi acquisire nozioni su questo potente linguaggio di programmazione? Ti consiglio il corso “Python 3.8 Guida Completa: da Principiante a Esperto” (LINK) presente su Udemy. Sicuramente saper usare questo linguaggio di programmazione e le sue librerie è molto utile, anche perchè possiamo creare degli scripts per le nostre analisi invece che comprare software propietari.

Stazione meteo con modulo Wi-Fi

Per costruire la stazione meteo con questo secondo metodo, invece del modulo SD Writer/Reader, viene usato il modulo WiFi ESP-01 eps8266 per inviare i dati su ThingSpeak.

esp-01-disposizione-pin
Disposizione dei pin nel modulo WiFi
Sensore DHT22Scheda Arduino
+5V
output2
GND
BMP180 Scheda Arduino
VIN3.3V
GND GND
SCLA5
SDAA4
Modulo WIFI Scheda Arduino
VCC3.3V
RST 3.3V
CH_PD 3.3V
RXDpin0 (TX)
TXDpin1 (RX)
stazione-meteo-arduino-modulo-wifi
Schema grafico con i collegamenti della seconda versione della stazione meteo

Visualizzazione on-line dei dati

Prima di presentarti il codice da caricare sulla scheda, vediamo come visualizzare on-line i dati servendoci di ThingSpeak.

Secondo quanto dicono i suoi sviluppatori: “ThingSpeak è una applicazione IoT open-source e API per arhiviare e recuperare dati dalle cose usando i protocolli https e mqtt su internet o una rete locale.”

ThingSpeak ha integrato il supporto del software di calcolo numerico MATLAB (Mathworks) consentendo agli utenti di ThingSpeak di analizzare e visualizzare i dati caricati utilizzando Matlab senza richiedere l’acquisto di una licenza Matlab da Mathworks.

Colleghiamoci al sito www.thingspeak.com e creiamo, con pochi clicks, un account free. Entriamo nel nostro account generiamo un nuovo canale, nel quale aggiungiamo (cliccando su Channel settings) 3 fields: Temperature, Humidity e Pressure. Aggiungiamo anche il nome del canale.

Scrollando in basso la pagina delle impostazioni troviamo anche l’opzione per inserire l’ubicazione della nostra stazione: basta spuntare “Show Channel Locations” ed inserire latitudine e longitudine. Fatto questo non ci resta che salvare le impostazioni cliccando su “Save Channel”.

Adesso dobbiamo prestare attenzione alla Write API Key e al ThingSpeak ip :la prima la troviamo nella scheda “API Keys” del nostro canale mentre il secondo è 184.106.153.149. Questi due parametri ci serviranno per il codice che va caricato sulla scheda.

Il codice Arduino

//Libraires
#include <SFE_BMP180.h>
#include <Wire.h>
#include <DHT.h>
#include <stdlib.h>

// You will need to create an SFE_BMP180 object, here called "pressure":

SFE_BMP180 bmp180;
int Altitude = 170; //current altitude in meters

/*------------------------DHT SENSOR------------------------*/
#define DHTPIN 2         // DHT data pin connected to Arduino pin 2
#define DHTTYPE DHT22     // DHT 22 (or AM2302)
DHT dht(DHTPIN, DHTTYPE); // Initialize the DHT sensor
/*----------------------------------------------------------*/

/*-----------------ESP8266 Serial WiFi Module---------------*/
#define SSID ""     // "SSID-WiFiname" 
#define PASS ""       // "password"
#define IP "184.106.153.149"// thingspeak.com ip
String msg = "GET /update?key="; //change it with your key...
/*-----------------------------------------------------------*/

//Variables
float temp;
float hum;
String tempC;
float pressione;


int error;

void setup() {
  Serial.begin(115200); //or use default 115200.  
  Serial.println("AT");
  delay(5000);
  if(Serial.find("OK")){
    connectWiFi();
  }

  //Serial.begin(9600);
  bool success = bmp180.begin();

  if (success) {
    Serial.println("BMP180 init success");
  }

}

void loop() {
  
  //Read temperature and humidity values from DHT sensor:
  start: //label 
  error=0;
  temp = dht.readTemperature();
  hum = dht.readHumidity();
  char buffer[10];
  
  // there is a useful c function called dtostrf() which will convert a float to a char array 
  //so it can then be printed easily.  The format is: dtostrf(floatvar, StringLengthIncDecimalPoint, numVarsAfterDecimal, charbuf);
  tempC = dtostrf(temp, 4, 1, buffer); 



  //PRESSURE 

  char status;
  double T, P;
  bool success = false;

  status = bmp180.startTemperature();

  if (status != 0) {
    delay(1000);
    status = bmp180.getTemperature(T);

    if (status != 0) {
      status = bmp180.startPressure(3);

      if (status != 0) {
        delay(status);
        status = bmp180.getPressure(P, T);

        if (status != 0) {
          pressione = bmp180.sealevel(P, Altitude);
          
          //Serial.print("Pressure: ");
          //Serial.print(comp);
          //Serial.println(" hPa");

          //Serial.print("Temperature: ");
          //Serial.print(T);
          //Serial.println(" C");
        }
      }
    }
  }
  
  //pressione= a;

  updateTemp();
  //Resend if transmission is not completed 
  if (error==1){
    goto start; //go to label "start"
  }
  
  delay(60000); //Update every 1 minute

}



void updateTemp(){
  String cmd = "AT+CIPSTART=\"TCP\",\"";
  cmd += IP;
  cmd += "\",80";
  Serial.println(cmd);
  delay(2000);
  if(Serial.find("Error")){
    return;
  }
  cmd = msg ;
  cmd += "&field1=";     //field 1 for temperature
  cmd += tempC;
  cmd += "&field2=";  //field 2 for humidity
  cmd += String(hum);
  cmd += "&field3=";  //field 3 for Pressure
  cmd += String(pressione);
  cmd += "\r\n\r\n";
  
  Serial.print("AT+CIPSEND=");
  Serial.println(cmd.length());
  if(Serial.find(">")){
    Serial.print(cmd);
  }
  else{
    Serial.println("AT+CIPCLOSE");
    //Resend...
    error=1;
  }
}

 
boolean connectWiFi(){
  Serial.println("AT+CWMODE=1");
  delay(2000);
  String cmd="AT+CWJAP=\"";
  cmd+=SSID;
  cmd+="\",\"";
  cmd+=PASS;
  cmd+="\"";
  Serial.println(cmd);
  delay(5000);
  if(Serial.find("OK")){
    return true;
  }else{
    return false;
  }
}

Nella riga 10 del nostro codice si deve inserire l’altitudine, espressa in metri, alla quale si trova la stazione, nella riga 19 devi inserire il nome della rete Wi-Fi a cui vuoi connetterti, nella riga 20 la password della stessa rete mentre nella riga 22 la Write API Key.

Con il comando espresso in riga 108 c’è indicato il tempo con cui i dati vengono inviati a ThingSpeak. Nelle schede Arduino il tempo è impostato in millisecondi, motivo per cui nel nostro codice – che invia i dati ogni minuto – fra le parentesi c’è 60000.

A questo punto possiamo caricare il codice sulla scheda, ma dobbiamo fare attenzione: prima di procedere devi togliere i cavi da TX e RX, caricare il codice e poi rimettere i cavi in TX e RX.

Siamo alla fine, la stazione meteo è pronta! Se vuoi consultare i dati acquisiti dalla mia stazione, clicca su questo link: https://thingspeak.com/channels/954764 .

thinkspeak-stazione-meteo

Se avete dei suggerimenti, o se qualcosa nel post non è chiaro, potete contattarmi commentando questo posttramite e-mail e attraverso i canali social di IntraGeo.

Antonio Nirta
Antonio Nirta
Ciao, mi chiamo Antonio Nirta e sono un geologo. Mi sono laureato all'Università di Pisa e dal 2017 svolgo la libera professione. Attraverso i post presenti in questo blog cercherò di trasmettere la mia passione per le Scienze Geologiche e di fornire informazioni che riguardano il bellissimo settore della Geologia.

14 Comments

  1. Elvio De santis ha detto:

    Buon giorno.
    È possibile integrare con un rivelatore di velocità del vento e direzione del vento?
    E con un misuratore di pioggia?

  2. Andrea Camusso ha detto:

    Ciao,
    complimenti per il progetto. È una guida ben scritta e comprensibile.

    Vorrei misurare i dati esterni, hai qualche suggerimento per impermiabilizzare e alimentare “l’accrocchio”?
    Grazie.

    • Antonio Nirta ha detto:

      Ciao Andrea, grazie mille per i complimenti. Si, ci sono diverse “custodie” impermeabili per le schede Arduino. Faccio qualche ricerca su Amazon e metto qualche link dentro il post.
      Per quanto riguarda l’alimentazione all’esterno si potrebbe usare una prolunga e un adattore usb-presa elettrica se si è vicini casa. Alrimenti si può collegare un piccolo pannellino solare se non si è nelle vicinanza di una presa elettrica.

      • Gianluca Santilli ha detto:

        Ciao Antonio,

        sei riuscito a trovare le custodie impermeabili per Arduino?
        Il progetto funziona anche utilizzando una scheda Arduino originale’

        • Antonio Nirta ha detto:

          Ciao Gianluca.

          Si, su Amazon ce ne sono tante. Inserirò presto qualche link all’interno del post.
          Il progetto funziona benissimo anche con una scheda Arduino originale (Arduino Uno R3).

          Sto pensando ad implementare il progetto aggiungendo un pluviometro, un anemometro e un sensore per la qualità dell’aria.

          Infine colgo l’occasione per segnalarti la campagna di crowdfunding che ho creato per supportare IntraGeo. Il tutto avviene su PayPal tramite offerta libera.
          Le offerte raccolte saranno spesi per migliorare il sito e per comprare strumenti per la creazione di nuovi contenuti da divulgare.

          Se sei soddisfatto di IntraGeo e vuoi aiutarlo a crescere ti allego il link per una donazione:

          https://paypal.me/pools/c/8q7WTvOMLR

          Con l’aiuto di tutti, anche piccolo, faremo grandi cose!

          Per qualsiasi altra informazione, non esitare a contattarmi.

          Antonio

  3. Giancarlo ha detto:

    Sono un neofita di Arduino.
    Complimenti, bel progetto.
    Cercavo una cosa simile. Ottimo spunto di partenza.

  4. Andrea Camusso ha detto:

    Grazie per la risposta!
    Ancora una curiosità: perché hai scelto una scheda Elegoo anziché un’ Arduino Uno originale?

    • Antonio Nirta ha detto:

      Prima di questo progetto ho sviluppato un’altro usando un kit Elegoo starter. Mi sono trovato bene con la scheda Elegoo quindi l’ho riutilizzata anche per costruire la stazione meteo.

  5. michel ha detto:

    ciao Antonio, bel progetto, sono abbastanza newbie, e la verifica dello sketch mi restituisce errori sin dall’inizio .
    esempio sulle righe 2,3,4 e 5: questo l’errore restituito :
    METEO:2:10: error: #include expects “FILENAME” or
    #include <SFE_BMP180.h>

  6. Andrea Scantamburlo ha detto:

    Che figata! Per caso hai aggiunto il sensore della qualità dell’aria? sarebbe pazzesco e quello proprio quello che sto cercando

    • Antonio Nirta ha detto:

      Si, è venuto proprio un bel lavoretto! Ancora il sensore per misurare la qualità dell’aria non l’ho aggiunto: se tutto va bene lo integrerò a breve!
      Nel frattempo puoi cominciare a montare la stazione meteo così come è: i pezzi li puoi acquistare cliccando sui link che ho inserito e che ti rimandano direttamente ad Amazon! Non appena faccio gli aggiornamenti li integrerò nell’articolo!

      A presto!

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *