Guide · 12 min di lettura

Stazione meteo Arduino: DHT22, BMP280, sensore pioggia e LCD

Costruire una stazione meteo Arduino: DHT22 per temperatura e umidità, BMP280 per la pressione, sensore pioggia, LDR, indirizzi I2C, pagine LCD e log su SD.

Una stazione meteo Arduino è uno dei progetti più divertenti per imparare: con pochi sensori economici misuri temperatura, umidità, pressione atmosferica e pioggia sul balcone o in giardino e le vedi su un display. In questa guida collegherai ad Arduino Uno un DHT22 (temperatura e umidità), un BMP280 (pressione), un sensore pioggia e una fotoresistenza LDR per distinguere il giorno dalla notte, e mostrerai i valori su un LCD 16x2 I2C in pagine che cambiano ogni pochi secondi. Aggiungendo un modulo microSD, la stazione scrive una riga di log ogni ora; dopo qualche giorno puoi trasformare i dati in grafici con Excel.

Il progetto non si limita a leggere i sensori: convertiremo la pressione misurata in pressione al livello del mare in base alla tua altitudine, così da poterla confrontare con i siti meteo, calcoleremo il punto di rugiada da temperatura e umidità e capiremo se il tempo sta per peggiorare dalla variazione di pressione delle ultime tre ore. In ordine trovi le tabelle di collegamento e degli indirizzi I2C, il montaggio passo passo, il codice completo, la spiegazione dei calcoli, il log orario, la versione Wi-Fi con ESP32, il posizionamento dei sensori all'aperto e gli errori più comuni.

Sensore di temperatura e umidità DHT22
DHT22 (AM2302): misura temperature da -40 a 80 °C con precisione di ±0,5 °C e l'umidità; è il sensore principale della stazione.

Che cosa misura una stazione meteo Arduino?

Ogni sensore è stato scelto perché fa meglio di tutti un solo lavoro. Il DHT22 fornisce temperatura e umidità relativa su un'unica linea dati ed è molto più preciso del DHT11. Il BMP280 misura la pressione atmosferica in ettopascal (hPa) con una precisione di ±1 hPa; la variazione di pressione è il segnale più affidabile dell'arrivo della pioggia. La piastra del sensore pioggia dà un valore analogico che scende man mano che si bagna. La LDR è una semplice fotoresistenza la cui resistenza cambia con la luce, sufficiente per distinguere il giorno dalla notte. Tutto viene mostrato sull'LCD I2C; il display e il BMP280 condividono gli stessi due fili (SDA e SCL).

MisuraSensoreCampo e precisioneCollegamento
Temperatura e umiditàDHT22 (AM2302)-40…80 °C ±0,5 °C; 0–100 % ±2–5 %Una linea dati (D2)
Pressione atmosfericaBMP280300–1100 hPa, ±1 hPaI2C (A4, A5)
PioggiaPiastra FC-37 / YL-83 e modulo LM393Percentuale di bagnato (calibrata nel codice)Analogico A0, alimentazione D7
Giorno / notteLDR (GL5528) e resistenza da 10 kΩLivello di luce indicativoAnalogico A1
DisplayLCD 16x2 con modulo I2C (PCF8574)2 righe × 16 caratteriI2C (A4, A5)
Log (facoltativo)Modulo microSDFAT32, file CSVSPI (D10–D13)

Lista dei materiali

  • Arduino Uno (Arduino Nano funziona con gli stessi pin)
  • Modulo DHT22 (tre pin, resistenza di pull-up sulla scheda) oppure DHT22 a quattro piedini e una resistenza da 10 kΩ
  • Modulo BMP280 (meglio la versione a 5 V con regolatore) oppure un BME280, che misura anche l'umidità
  • Piastra del sensore pioggia e modulo comparatore LM393
  • LDR e resistenza da 10 kΩ
  • LCD 16x2 con modulo I2C saldato sul retro
  • Modulo microSD con regolatore e una scheda fino a 32 GB formattata FAT32 (facoltativo)
  • Breadboard, cavetti jumper e un alimentatore USB da 5 V che eroghi almeno 1 A
BMP280
BMP280
Sensore di pioggia
Sensore di pioggia
LDR
LDR
I2C 16x2 LCD
I2C 16x2 LCD
Modulo scheda MicroSD
Modulo scheda MicroSD

Schema di collegamento: tabella dei pin e indirizzi I2C

L'idea chiave del circuito è il bus I2C condiviso: l'LCD e il BMP280 sono collegati in parallelo agli stessi pin SDA (A4) e SCL (A5) e Arduino li raggiunge con indirizzi diversi. Il modulo SD usa il bus SPI (D10–D13), quindi non va in conflitto con l'I2C. Il VCC del modulo pioggia non va direttamente al 5V ma a D7: il codice alimenta la piastra solo per pochi millisecondi durante la misura, e questo rallenta molto la corrosione. Abbiamo spiegato come funziona il bus I2C in Che cos'è l'I2C?.

Componente e pinArduino UnoESP32 (versione Wi-Fi)
DHT22 VCC / GND5V / GND3V3 / GND
DHT22 DATAD2GPIO 4
BMP280 VCC3.3V (6 pin) o 5V (con regolatore)3V3
BMP280 SDA / SCLA4 / A5GPIO 21 / GPIO 22
Modulo I2C dell'LCD VCC / SDA / SCL5V / A4 / A5Non usato (pagina web)
VCC del modulo pioggiaD7 (solo durante la misura)GPIO 25
AO del modulo pioggiaA0GPIO 34 (ADC1)
Partitore LDR e 10 kΩLDR al 5V, 10 kΩ a GND, punto centrale su A1LDR al 3V3, 10 kΩ a GND, punto centrale su GPIO 35
Modulo SD CS / MOSI / MISO / SCKD10 / D11 / D12 / D13Non usato
VCC del modulo SD5V—
Dispositivo I2CIndirizzo predefinitoNota
Modulo I2C dell'LCD (PCF8574T)0x270x20–0x27 con i ponticelli a stagno
Modulo I2C dell'LCD (PCF8574AT)0x3F0x38–0x3F con i ponticelli a stagno
BMP280 (moduli viola)0x760x77 se il pin SDO va a 3,3 V
BMP280 (scheda Adafruit)0x770x76 se SDO va a GND
BME280 (al posto del BMP280)0x76 o 0x77Chip ID 0x60; quello del BMP280 è 0x58
RTC DS3231 / DS1307 (facoltativo)0x68La EEPROM del modulo DS3231 è a 0x57
La maggior parte dei moduli BMP280 viola a 6 pin non ha regolatore; il chip sopporta al massimo 3,6 V, quindi alimentali dal pin 3.3V di Arduino Uno. I moduli a 4 pin con un piccolo regolatore possono andare al 5V. Se non sei sicuro degli indirizzi, fai girare prima lo scanner I2C dell'articolo LCD I2C: dovresti vedere due indirizzi, per esempio 0x27 e 0x76. Nella versione ESP32 non alimentare mai il partitore della LDR dal 5V; i pin analogici dell'ESP32 non reggono più di 3,3 V.

Installare le librerie

  1. Apri il Gestore librerie dell'IDE Arduino e installa LiquidCrystal I2C (Frank de Brabander).
  2. Cerca Adafruit BMP280 Library; quando ti chiede delle dipendenze scegli Install all, così vengono installate anche Adafruit Unified Sensor e Adafruit BusIO.
  3. Installa DHT sensor library (Adafruit).
  4. Le librerie SD e SPI sono incluse nell'IDE Arduino, non serve installarle. I dettagli dell'installazione sono in aggiungere librerie ad Arduino.

Montaggio passo passo

  1. Prima il bus I2C: collega l'LCD e il BMP280 ad A4 e A5, avvia lo scanner I2C e annota i due indirizzi.
  2. Aggiungi il DHT22: collega il pin dati a D2. Se usi il sensore nudo a quattro piedini, metti una resistenza di pull-up da 10 kΩ tra dati e VCC.
  3. Collega il sensore pioggia: unisci la piastra al modulo, il VCC del modulo a D7 e AO ad A0. Misura i valori con la piastra asciutta e bagnata e scrivili nelle costanti RAIN_DRY e RAIN_WET del codice.
  4. Monta il partitore della LDR: un piedino della LDR al 5V, l'altro ad A1, e una resistenza da 10 kΩ da A1 a GND. Più luce c'è, più alta è la lettura.
  5. Aggiungi il modulo SD: alimentalo a 5V e collega CS a D10, MOSI a D11, MISO a D12 e SCK a D13. Senza scheda la stazione continua a funzionare senza log.
  6. Inserisci l'altitudine: trova l'altezza sul livello del mare del tuo luogo e scrivila nella costante ALTITUDE_M; da lei dipende la precisione del calcolo della pressione.

Codice della stazione meteo: pagine a rotazione e log orario su SD

Il codice qui sotto mette insieme tutti i pezzi. I sensori vengono letti ogni 5 secondi, il display passa tra tre pagine ogni 4 secondi e, se c'è una scheda SD, viene salvata una riga all'accensione e poi una ogni ora. Siccome usa millis() al posto di delay(), i tre compiti non si aspettano a vicenda. I testi sul display sono brevi abbreviazioni inglesi: T temperatura, H umidità, Dew pt punto di rugiada e P pressione.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3#include <Adafruit_BMP280.h>
4#include <DHT.h>
5#include <SPI.h>
6#include <SD.h>
7
8// Pinler / pins
9const byte DHT_PIN = 2;            // DHT22 veri / DHT22 data
10const byte RAIN_POWER_PIN = 7;     // yağmur modülü VCC / rain module VCC
11const byte RAIN_PIN = A0;          // yağmur modülü AO / rain module AO
12const byte LDR_PIN = A1;           // LDR bölücü orta noktası / LDR divider midpoint
13const byte SD_CS_PIN = 10;         // SD modülü CS / SD module CS
14
15// Kendi değerlerinle değiştir / replace with your own values
16const float ALTITUDE_M = 850.0;    // rakım, metre / altitude in metres
17const int RAIN_DRY = 1015;         // kuru pano okuması / dry board reading
18const int RAIN_WET = 350;          // ıslak pano okuması / wet board reading
19const byte RAIN_ON = 25;           // % ve üstü: yağıyor / % and above: raining
20const byte RAIN_OFF = 10;          // % ve altı: kurudu / % and below: dry
21const int DAY_LEVEL = 450;         // LDR bu değerin üstünde: gündüz / above: day
22const int NIGHT_LEVEL = 350;       // LDR bu değerin altında: gece / below: night
23
24const unsigned long READ_MS = 5000UL;     // sensör okuma aralığı / sensor read interval
25const unsigned long PAGE_MS = 4000UL;     // sayfa süresi / page duration
26const unsigned long LOG_MS = 3600000UL;   // saatte bir kayıt / log once an hour
27
28LiquidCrystal_I2C lcd(0x27, 16, 2);       // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
29Adafruit_BMP280 bmp;
30DHT dht(DHT_PIN, DHT22);
31
32float temperature = NAN, humidity = NAN, pressure = NAN, dewPoint = NAN;
33float history[4] = {NAN, NAN, NAN, NAN};  // saatlik basınç geçmişi / hourly pressure history
34int rainPercent = 0, light = 0;
35bool raining = false, isDay = true, bmpOk = false, sdOk = false, firstLog = true;
36byte page = 0;
37unsigned long lastRead = 0, lastPage = 0, lastLog = 0;
38
39float calcDewPoint(float t, float rh) {   // Magnus formülü / Magnus formula
40  const float a = 17.62, b = 243.12;
41  float g = log(rh / 100.0) + a * t / (b + t);
42  return b * g / (a - g);
43}
44
45int readRain() {
46  digitalWrite(RAIN_POWER_PIN, HIGH);     // panoyu yalnız ölçerken besle / power the board only while measuring
47  delay(20);
48  long sum = 0;
49  for (byte i = 0; i < 4; i++) sum += analogRead(RAIN_PIN);
50  digitalWrite(RAIN_POWER_PIN, LOW);      // korozyonu yavaşlatır / slows corrosion
51  return constrain(map(sum / 4, RAIN_DRY, RAIN_WET, 0, 100), 0, 100);
52}
53
54void readSensors() {
55  float t = dht.readTemperature();
56  float h = dht.readHumidity();
57  if (!isnan(t) && !isnan(h)) {           // hatalı okumada eski değer kalır / keep the old value on a failed read
58    temperature = t;
59    humidity = h;
60    dewPoint = calcDewPoint(t, h);
61  }
62  if (bmpOk && bmp.takeForcedMeasurement()) {   // tek ölçüm, az ısınma / one-shot, less self-heating
63    pressure = bmp.seaLevelForAltitude(ALTITUDE_M, bmp.readPressure() / 100.0);   // deniz seviyesi, hPa / sea level, hPa
64  }
65  rainPercent = readRain();
66  if (!raining && rainPercent >= RAIN_ON) raining = true;    // histerezis / hysteresis
67  if (raining && rainPercent <= RAIN_OFF) raining = false;
68  light = analogRead(LDR_PIN);
69  if (!isDay && light >= DAY_LEVEL) isDay = true;
70  if (isDay && light <= NIGHT_LEVEL) isDay = false;
71}
72
73float trend3h() {                         // son 3 saatteki basınç değişimi / pressure change over 3 hours
74  if (isnan(history[0]) || isnan(history[3])) return NAN;
75  return history[3] - history[0];
76}
77
78void showPage() {
79  lcd.clear();
80  if (page == 0) {                        // sıcaklık, nem, çiy noktası / temperature, humidity, dew point
81    lcd.print(F("T "));
82    lcd.print(temperature, 1);
83    lcd.print((char)223);                 // derece işareti / degree sign
84    lcd.print(F("C  H "));
85    lcd.print(humidity, 0);
86    lcd.print('%');
87    lcd.setCursor(0, 1);
88    lcd.print(F("Dew pt "));
89    lcd.print(dewPoint, 1);
90    lcd.print((char)223);
91    lcd.print('C');
92  } else if (page == 1) {                 // basınç ve eğilim / pressure and trend
93    lcd.print(F("P "));
94    lcd.print(pressure, 1);
95    lcd.print(F(" hPa"));
96    lcd.setCursor(0, 1);
97    float tr = trend3h();
98    if (isnan(tr)) {
99      lcd.print(F("3h trend: wait"));     // ilk 3 saat / first 3 hours
100    } else {
101      lcd.print(F("3h "));
102      if (tr > 0) lcd.print('+');
103      lcd.print(tr, 1);
104      if (tr <= -1.6) lcd.print(F(" Falling"));
105      else if (tr >= 1.6) lcd.print(F(" Rising"));
106      else lcd.print(F(" Steady"));
107    }
108  } else {                                // yağmur, ışık, SD durumu / rain, light, SD status
109    lcd.print(F("Rain "));
110    lcd.print(rainPercent);
111    lcd.print(raining ? F("% RAIN") : F("% dry"));
112    lcd.setCursor(0, 1);
113    lcd.print(isDay ? F("Day  ") : F("Night"));
114    lcd.print(sdOk ? F(" SD:ok") : F(" SD:off"));
115  }
116}
117
118void logHourly() {
119  for (byte i = 0; i < 3; i++) history[i] = history[i + 1];   // geçmişi kaydır / shift the history
120  history[3] = pressure;
121  if (!sdOk) return;
122  File f = SD.open("WEATHER.CSV", FILE_WRITE);   // sona ekler / appends
123  if (!f) {
124    sdOk = false;
125    return;
126  }
127  f.print(millis() / 60000UL);            // açılıştan beri dakika / minutes since power-up
128  f.print(',');
129  f.print(temperature, 1);
130  f.print(',');
131  f.print(humidity, 0);
132  f.print(',');
133  f.print(pressure, 1);
134  f.print(',');
135  f.print(dewPoint, 1);
136  f.print(',');
137  f.print(rainPercent);
138  f.print(',');
139  f.println(isDay ? F("day") : F("night"));
140  f.close();                              // elektrik kesilirse veri kaybolmasın / safe against power loss
141}
142
143void setup() {
144  pinMode(RAIN_POWER_PIN, OUTPUT);
145  lcd.init();
146  lcd.backlight();
147  lcd.print(F("Weather station"));
148  dht.begin();
149  bmpOk = bmp.begin(0x76);                // mor modül 0x76, Adafruit 0x77 / purple module 0x76, Adafruit 0x77
150  if (bmpOk) {
151    bmp.setSampling(Adafruit_BMP280::MODE_FORCED, Adafruit_BMP280::SAMPLING_X1,
152                    Adafruit_BMP280::SAMPLING_X1, Adafruit_BMP280::FILTER_OFF);   // hava izleme ayarı / weather monitoring
153  }
154  sdOk = SD.begin(SD_CS_PIN);
155  if (sdOk && !SD.exists("WEATHER.CSV")) {
156    File f = SD.open("WEATHER.CSV", FILE_WRITE);
157    if (f) {
158      f.println(F("minutes,temp_c,hum_pct,press_hpa,dew_c,rain_pct,light"));   // başlık satırı / header row
159      f.close();
160    }
161  }
162  lcd.setCursor(0, 1);
163  lcd.print(bmpOk ? F("BMP280 ok") : F("BMP280 ?"));
164  delay(2000);                            // DHT22 ilk ölçüme hazırlansın / let the DHT22 get ready
165}
166
167void loop() {
168  unsigned long now = millis();
169  if (lastRead == 0 || now - lastRead >= READ_MS) {
170    lastRead = now;
171    readSensors();
172  }
173  if (firstLog || now - lastLog >= LOG_MS) {     // açılışta ve her saat / at power-up and every hour
174    firstLog = false;
175    lastLog = now;
176    logHourly();
177  }
178  if (now - lastPage >= PAGE_MS) {
179    lastPage = now;
180    showPage();
181    page = (page + 1) % 3;                // 3 sayfa arasında dön / cycle through 3 pages
182  }
183}
Costante o funzioneA cosa serve
ALTITUDE_MAltitudine; serve a riportare la pressione misurata al livello del mare
RAIN_DRY / RAIN_WETI valori analogici che hai misurato con la piastra asciutta e bagnata
RAIN_ON / RAIN_OFFSoglie (%) di inizio e fine pioggia; la differenza tra le due è l'isteresi
DAY_LEVEL / NIGHT_LEVELSoglie giorno e notte della LDR; la fascia intermedia evita sfarfallii all'alba
readRain()Alimenta la piastra da D7, fa la media di 4 letture, toglie l'alimentazione e converte in percentuale
calcDewPoint()Calcola il punto di rugiada con la formula di Magnus
takeForcedMeasurement()Fa eseguire al BMP280 una misura singola; evita l'autoriscaldamento della misura continua
history[4] e trend3h()Conservano la pressione di ogni ora e danno la variazione delle ultime 3 ore
logHourly()Fa scorrere lo storico della pressione e aggiunge una riga CSV sulla scheda SD

I calcoli: pressione al livello del mare, punto di rugiada e tendenza barometrica

Il BMP280 misura la pressione locale del posto in cui ti trovi, che scende con l'altitudine: la pressione che al livello del mare è intorno a 1013 hPa diventa circa 915 hPa a 850 metri, e a L'Aquila, a circa 700 metri, si aggira sui 930 hPa. I siti meteo invece riportano la pressione di ogni stazione ridotta al livello del mare. Questa conversione la fa la funzione seaLevelForAltitude() del codice: P0 = P / (1 − h / 44330)^5,255. Per 915 hPa misurati a 850 metri, 1 − 850 / 44330 = 0,9808 e 0,9808^5,255 ≈ 0,903; 915 / 0,903 ≈ 1013 hPa. Sbagliare l'altitudine di 10 metri sposta il risultato di circa 1,2 hPa, quindi prendila da una mappa o da un GPS con la massima precisione possibile.

Il punto di rugiada è la temperatura alla quale l'aria, raffreddandosi, comincia a condensare, ed è un indice di comfort più significativo dell'umidità relativa: fino a 13 °C l'aria è piacevole, sopra i 16 °C umida e sopra i 20 °C afosa. Il codice usa la formula di Magnus: γ = ln(UR / 100) + 17,62·T / (243,12 + T) e Td = 243,12·γ / (17,62 − γ). Con 24 °C e 50 % di umidità si ottiene γ ≈ 0,890 e Td ≈ 12,9 °C. Se di notte la temperatura si avvicina al punto di rugiada, al mattino puoi aspettarti nebbia o rugiada; se il punto di rugiada è sotto 0 °C, invece della rugiada si forma la brina, un buon innesco per un allarme gelo.

Lo strumento di previsione più utile, però, è la tendenza barometrica: la variazione in 3 ore dice molto più della pressione in sé. Il codice salva la pressione ogni ora in un array; quando ha quattro valori, cioè 3 ore dopo l'accensione, mostra la differenza tra l'ultimo valore e quello di 3 ore prima e scrive Falling per cali oltre 1,6 hPa e Rising per gli aumenti. La classificazione usata in meteorologia è la seguente.

Variazione di pressione in 3 oreClasseCosa significa di solito
Meno di 0,1 hPaStazionariaIl tempo attuale continua
0,1–1,5 hPaIn lento aumento / caloPiccolo cambiamento; in calo il cielo può annuvolarsi
1,6–3,5 hPaIn aumento / caloIn calo cresce la probabilità di pioggia, in aumento il cielo si rasserena
3,6–6 hPaIn rapido aumento / caloIn calo arriva tempo ventoso e piovoso
Più di 6 hPaMolto rapidaTempesta; un cambiamento del tempo molto brusco

Log orario su scheda SD e grafici in Excel

Se c'è una scheda SD, la stazione crea nella cartella principale il file WEATHER.CSV, scrive le intestazioni delle colonne nella prima riga e poi aggiunge una riga ogni ora. La libreria SD di Arduino accetta solo nomi di file nel formato 8+3, per questo il nome è corto. Chiudere il file dopo ogni registrazione fa sì che, se va via la corrente, si perda al massimo l'ultima riga. Arduino Uno non ha un orologio vero, quindi la prima colonna contiene i minuti trascorsi dall'accensione; se vuoi data e ora, aggiungi un modulo RTC e prendi da lì la marca temporale. Per scegliere e formattare la scheda guarda l'articolo sul modulo scheda SD.

minutestemp_chum_pctpress_hpadew_crain_pctlight
021.4581016.212.80day
6020.8611015.113.00day
12018.9721013.413.734night

Nell'esempio qui sopra la pressione è scesa di 2,8 hPa in due ore e alla terza registrazione ha cominciato a piovere: ecco come la tendenza annuncia la pioggia. Apri il file sul computer con Excel o Fogli Google e traccia le colonne di pressione e temperatura come grafici a linee. Excel in italiano si aspetta la virgola come separatore decimale, quindi valori come 1016.2 possono comparire come testo o come data; durante l'importazione imposta le impostazioni internazionali della colonna su Inglese (Stati Uniti). Il metodo completo è in esportare i dati di Arduino in Excel.

Questo codice usa circa il 61 % dei 2 KB di RAM di Arduino Uno e il 76 % dei suoi 32 KB di memoria programma; la parte più grossa della RAM va al buffer da 512 byte della libreria SD. Scrivere i testi fissi dentro F("...") fa risparmiare RAM. Se aggiungendo funzioni l'IDE segnala "Low memory available", puoi disattivare il log su SD oppure spostare la stazione su un Arduino Mega o un ESP32, che hanno più memoria; i dettagli sono in memoria insufficiente su Arduino.

Stazione meteo Wi-Fi con ESP32

Se vuoi vedere le misure sul telefono, puoi collegare gli stessi sensori a un ESP32. In questa versione, al posto dell'LCD c'è una pagina web servita dall'ESP32 stesso: apri su un telefono collegato alla stessa rete Wi-Fi l'indirizzo IP mostrato nel Monitor seriale e compaiono i valori; la pagina si aggiorna da sola ogni 30 secondi. L'indirizzo /json restituisce gli stessi dati in un formato leggibile da altri programmi. I pin dell'ESP32 lavorano a 3,3 V: alimenta i sensori dal 3V3 e per gli ingressi analogici usa i pin ADC1 (GPIO 32–39), che funzionano anche con il Wi-Fi acceso. L'ADC dell'ESP32 è a 12 bit e legge da 0 a 4095, quindi devi rimisurare le soglie della pioggia.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <Wire.h>
4#include <Adafruit_BMP280.h>
5#include <DHT.h>
6
7const char* ssid = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
8const char* password = "Sifre123";   // Wi-Fi şifren / your Wi-Fi password
9
10const int DHT_PIN = 4;               // DHT22 veri / DHT22 data
11const int RAIN_POWER_PIN = 25;       // yağmur modülü VCC / rain module VCC
12const int RAIN_PIN = 34;             // yağmur AO, ADC1 / rain AO, ADC1
13const int LDR_PIN = 35;              // LDR bölücü, ADC1 / LDR divider, ADC1
14const float ALTITUDE_M = 850.0;      // rakım, metre / altitude in metres
15const int RAIN_DRY = 4095;           // 12 bit: kuru pano / 12-bit: dry board
16const int RAIN_WET = 1400;           // kendi ıslak ölçümün / your own wet reading
17
18WebServer server(80);
19Adafruit_BMP280 bmp;
20DHT dht(DHT_PIN, DHT22);
21float temperature = NAN, humidity = NAN, pressure = NAN;
22int rainPercent = 0, lightPercent = 0;
23unsigned long lastRead = 0;
24
25String num(float v, int digits) {    // okunamayan değer için null / null for a missing value
26  return isnan(v) ? String("null") : String(v, digits);
27}
28
29void readSensors() {
30  float t = dht.readTemperature();
31  float h = dht.readHumidity();
32  if (!isnan(t) && !isnan(h)) {
33    temperature = t;
34    humidity = h;
35  }
36  if (bmp.takeForcedMeasurement()) {
37    pressure = bmp.seaLevelForAltitude(ALTITUDE_M, bmp.readPressure() / 100.0);
38  }
39  digitalWrite(RAIN_POWER_PIN, HIGH);          // yalnız ölçerken besle / power only while measuring
40  delay(20);
41  int raw = analogRead(RAIN_PIN);
42  digitalWrite(RAIN_POWER_PIN, LOW);
43  rainPercent = constrain(map(raw, RAIN_DRY, RAIN_WET, 0, 100), 0, 100);
44  lightPercent = map(analogRead(LDR_PIN), 0, 4095, 0, 100);
45}
46
47void handleRoot() {
48  String html = "<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width,initial-scale=1'>"
49                "<meta http-equiv='refresh' content='30'><title>Weather</title></head>"
50                "<body style='font-family:sans-serif;font-size:1.3em;padding:1em'><h2>Weather station</h2>";
51  html += "<p>Temp: " + num(temperature, 1) + " &deg;C</p>";
52  html += "<p>Humidity: " + num(humidity, 0) + " %</p>";
53  html += "<p>Pressure: " + num(pressure, 1) + " hPa</p>";
54  html += "<p>Rain: " + String(rainPercent) + " %</p>";
55  html += "<p>Light: " + String(lightPercent) + " %</p></body></html>";
56  server.send(200, "text/html", html);
57}
58
59void handleJson() {                  // başka programlar için / for other programs
60  String json = "{\"temp\":" + num(temperature, 1) + ",\"hum\":" + num(humidity, 0) +
61                ",\"press\":" + num(pressure, 1) + ",\"rain\":" + String(rainPercent) +
62                ",\"light\":" + String(lightPercent) + "}";
63  server.send(200, "application/json", json);
64}
65
66void setup() {
67  Serial.begin(115200);
68  pinMode(RAIN_POWER_PIN, OUTPUT);
69  dht.begin();
70  if (!bmp.begin(0x76)) Serial.println(F("BMP280 yok / not found"));
71  bmp.setSampling(Adafruit_BMP280::MODE_FORCED, Adafruit_BMP280::SAMPLING_X1,
72                  Adafruit_BMP280::SAMPLING_X1, Adafruit_BMP280::FILTER_OFF);
73  WiFi.begin(ssid, password);
74  while (WiFi.status() != WL_CONNECTED) delay(300);
75  Serial.print(F("IP: "));
76  Serial.println(WiFi.localIP());    // bu adresi telefonda aç / open this address on your phone
77  server.on("/", handleRoot);
78  server.on("/json", handleJson);
79  server.begin();
80}
81
82void loop() {
83  server.handleClient();
84  if (lastRead == 0 || millis() - lastRead >= 5000) {   // 5 sn'de bir oku / read every 5 s
85    lastRead = millis();
86    readSensors();
87  }
88}

Per vedere i dati da qualsiasi posto, salvarli su Fogli Google o confrontare le tue misure con le previsioni online, guarda ESP32 con Google Sheets e API meteo con ESP32. Il codice si compila senza modifiche con le versioni 2.x e 3.x del core ESP32, perché usa solo funzioni WiFi e WebServer identiche nelle due versioni.

Posizionare correttamente i sensori

  • Metti il sensore di temperatura all'ombra: un DHT22 al sole può segnare 5–10 °C più della vera temperatura dell'aria. Mettilo in una scatola bianca ventilata o in uno schermo antiradiazioni fatto con piatti di plastica impilati.
  • Tienilo lontano dai muri: muri e telai delle finestre scaldati dal sole alzano la lettura; monta il sensore ad almeno 30 cm dal muro e, se puoi, a 1,5–2 m da terra.
  • Lascia l'elettronica al chiuso: Arduino, LCD e BMP280 possono stare in una scatola chiusa, perché la pressione all'interno è la stessa. Solo il DHT22, la piastra della pioggia e la LDR devono stare fuori.
  • Monta inclinata la piastra della pioggia: con un'inclinazione di 30–45 gradi l'acqua scivola via quando smette di piovere; una piastra orizzontale resta bagnata per ore.
  • Punta la LDR verso il cielo: se la colpisce la luce di un lampione o del balcone, la stazione crederà che sia giorno; mettila lontana dalle lampade e rivolta verso l'alto.
  • Attenzione alla lunghezza dei cavi: il DHT22 funziona bene con qualche metro di cavo; se oltre i 10 metri compaiono errori di lettura, abbassa la resistenza di pull-up a 4,7 kΩ. Il bus I2C è pensato solo per poche decine di centimetri, quindi tieni il BMP280 vicino ad Arduino.

Ampliare la stazione: idee di progetto

  • Intensità luminosa: sostituisci la LDR con un BH1750, che misura in lux, e calcola le ore di sole.
  • Qualità dell'aria: aggiungi alla stazione per interni un sensore di CO2 MH-Z19 e a quella per esterni un sensore di polveri PMS5003.
  • Data e ora reali: con un modulo RTC scrivi data e ora nel log e salva ogni mezzanotte la massima e la minima del giorno.
  • Allarme gelo e serra: costruisci un allarme gelo che fa suonare un buzzer sotto i 2 °C o una serra intelligente che gestisce la ventilazione.
  • Alimentazione solare: con un piccolo pannello, un modulo di ricarica TP4056 e una cella 18650 la stazione non dipende dalla presa; nella versione ESP32, con il deep sleep la batteria dura settimane.
  • Vento e pioggia caduta: conta la velocità del vento con un anemometro a reed e i millimetri di pioggia con un pluviometro a vaschetta basculante.

Errori comuni e soluzioni

SintomoCausa probabileSoluzione
L'LCD mostra solo quadratini pieniContrasto regolato male o indirizzo I2C sbagliatoGira il trimmer blu sul retro del modulo e prova 0x3F al posto di 0x27
Sul display compare nanIl DHT22 non si legge: cablaggio, pull-up o letture più frequenti di una ogni 2 secondiControlla il filo dati e la resistenza da 10 kΩ; il codice tiene il valore precedente se una lettura fallisce
La pressione è nan o non cambia maiBMP280 non trovato: indirizzo 0x77 o modulo a 3,3 V alimentato maleProva begin(0x77) e alimenta il modulo con la tensione giusta
La pressione è 80–100 hPa sotto quella del meteoAltitudine non inserita, viene mostrata la pressione localeAggiorna ALTITUDE_M con la tua altitudine reale
Di giorno la temperatura è altissimaIl sensore prende il sole o si scalda dentro la scatolaUsa uno schermo all'ombra e ventilato
Percentuale di pioggia alta anche col seccoPiastra sporca, coperta di rugiada o calibrata malePulisci la piastra, rimisura RAIN_DRY e alza la soglia RAIN_ON
Sul display compare SD:offNessuna scheda, scheda in exFAT o modulo alimentato a 3,3 VFormatta FAT32 una scheda fino a 32 GB e collega il modulo al 5V
All'alba salta tra Day e NightLe soglie sono troppo vicineLascia almeno 100 punti tra DAY_LEVEL e NIGHT_LEVEL
Per smussare i salti improvvisi nel log, in ogni riga oraria puoi scrivere la media delle ultime 12 misure invece di una sola; media mobile e filtro mediano li trovi in filtrare i dati dei sensori.

Questa stazione mette insieme quasi tutto quello che hai imparato con Arduino: letture digitali e analogiche, bus I2C e SPI, multitasking con millis, calcoli e registrazione dei dati. Fai funzionare prima ogni sensore da solo, poi unisci le parti e solo alla fine mettile nella scatola. Nell'app BlueGrays trovi la misura di temperatura e umidità con DHT11, la lettura della luce con LDR, la misura con ESP32 e DHT22 su LCD, un registratore di temperatura su SD e una stazione meteo con display a matrice di punti, ognuno con schema del circuito passo passo e codice pronto.

Domande frequenti

Come si costruisce una stazione meteo con Arduino?

Colleghi ad Arduino Uno un DHT22 per temperatura e umidità, un BMP280 per la pressione, un sensore pioggia e una LDR per la luce; mostri i valori su un LCD I2C e, se vuoi, li salvi su una scheda SD. Prova prima ogni sensore da solo, poi uniscili in un unico sketch. Tenere i sensori all'ombra in uno schermo ventilato è la condizione più importante per misure corrette.

Meglio DHT22 o BME280 per una stazione meteo?

Il DHT22 è un po' più preciso sulla temperatura (±0,5 °C) ma si può leggere solo ogni 2 secondi; il BME280 riunisce temperatura, umidità e pressione in un solo chip I2C. Se vuoi meno fili e meno pin, un BME280 da solo basta. Questo progetto li usa entrambi perché il DHT22 sta fuori, mentre il BMP280 può restare dentro la scatola.

Perché la pressione del BMP280 è più bassa di quella del meteo?

Il sensore misura la pressione locale alla tua altitudine, mentre i siti meteo riportano la pressione ridotta al livello del mare. Ogni 100 metri di quota la pressione cala di circa 12 hPa. Se inserisci la tua altitudine nella costante ALTITUDE_M, seaLevelForAltitude() rende il valore confrontabile.

Una stazione meteo Arduino può prevedere la pioggia?

Non fa previsioni esatte, ma la tendenza barometrica è un ottimo indizio: un calo di oltre 1,6 hPa in 3 ore di solito annuncia nuvole e pioggia, un aumento invece un miglioramento. Il sensore pioggia, poi, rileva il momento in cui comincia a piovere. Insieme formano un sistema di avviso semplice ma utile.

Perché il sensore pioggia si ossida e come evitarlo?

Se le piste della piastra sono sempre sotto tensione, quando si bagnano avviene l'elettrolisi e il metallo si consuma in fretta. Collegare il VCC del modulo a un pin digitale e alimentare la piastra solo durante la misura ne allunga moltissimo la vita. Montarla inclinata, così che si asciughi presto dopo la pioggia, rallenta ulteriormente la corrosione.

Quanto dura a batteria una stazione meteo Arduino?

Arduino Uno con la retroilluminazione dell'LCD e i sensori assorbe circa 70–90 mA; un power bank da 2000 mAh lo fa funzionare per circa un giorno. Spegnere la retroilluminazione allunga la durata, ma per un uso prolungato a batteria è molto più adatto un ESP32 con deep sleep. L'autonomia del tuo circuito la calcoli con il calcolatore di durata della batteria.

Vedi tutti i progetti
Temperatura e umidità con DHT11
AR-55Intermedio

Temperatura e umidità con DHT11

Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

4.7(47)
83
Misurare l'intensità luminosa con LDR
AR-11Principiante

Misurare l'intensità luminosa con LDR

Vuoi vedere quanto è luminosa la tua stanza sotto forma di numero? L'LDR, un piccolo componente sensibile alla luce, misura la luce ambiente e l'Arduino scrive il valore sullo schermo del computer…

4.6(83)
143
Orologio a matrice di punti, calendario e stazione meteo (MAX7219, DS1307)
AR-85Intermedio
Premium

Orologio a matrice di punti, calendario e stazione meteo (MAX7219, DS1307)

Un pannello a scritte scorrevoli per la scrivania o la parete che mostra a turno l'ora, la data e il clima della stanza.

5.0(50)
66
ESP32 DHT22 Temperatura e umidità (con display LCD)
ES-15Intermedio

ESP32 DHT22 Temperatura e umidità (con display LCD)

Si tratta di un progetto che misura la temperatura e l'umidità dell'ambiente tramite il sensore DHT22 e le visualizza in tempo reale su un display LCD I2C 16x2. I dati vengono letti dal sensore utilizzando il protocollo one-wire tramite la libreria Adafruit DHT. Questo progetto costituisce la base per stazioni meteorologiche IoT, sistemi di automazione domestica intelligente o sistemi di monitoraggio ambientale nelle serre. La comunicazione con il DHT22 avviene tramite il pin GPIO 4 dell'ESP32.

4.8(38)
57
Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzato
Premium

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.

4.7(7)
12
ESP32 HTTPClient + API meteo (con schermo LCD)
ES-31Avanzato
Premium

ESP32 HTTPClient + API meteo (con schermo LCD)

L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. La risposta JSON viene analizzata con ArduinoJson v7 e città, temperatura, umidità, condizioni meteo e vento compaiono su un display LCD I2C. wttr.in non richiede una chiave API: basta scrivere il nome di una città qualsiasi.

4.7(13)
20
Misura di temperatura con NTC e display Lcd 2x16
AR-44Principiante
Premium

Misura di temperatura con NTC e display Lcd 2x16

Misura la temperatura dell'ambiente con un sensore che sembra una piccola perlina.

4.5(33)
44
Utilizzo dello schermo LCD con I2C
AR-32Principiante
Premium

Utilizzo dello schermo LCD con I2C

Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

4.8(53)
70