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.

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).
| Misura | Sensore | Campo e precisione | Collegamento |
|---|---|---|---|
| Temperatura e umidità | DHT22 (AM2302) | -40…80 °C ±0,5 °C; 0–100 % ±2–5 % | Una linea dati (D2) |
| Pressione atmosferica | BMP280 | 300–1100 hPa, ±1 hPa | I2C (A4, A5) |
| Pioggia | Piastra FC-37 / YL-83 e modulo LM393 | Percentuale di bagnato (calibrata nel codice) | Analogico A0, alimentazione D7 |
| Giorno / notte | LDR (GL5528) e resistenza da 10 kΩ | Livello di luce indicativo | Analogico A1 |
| Display | LCD 16x2 con modulo I2C (PCF8574) | 2 righe × 16 caratteri | I2C (A4, A5) |
| Log (facoltativo) | Modulo microSD | FAT32, file CSV | SPI (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





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 pin | Arduino Uno | ESP32 (versione Wi-Fi) |
|---|---|---|
| DHT22 VCC / GND | 5V / GND | 3V3 / GND |
| DHT22 DATA | D2 | GPIO 4 |
| BMP280 VCC | 3.3V (6 pin) o 5V (con regolatore) | 3V3 |
| BMP280 SDA / SCL | A4 / A5 | GPIO 21 / GPIO 22 |
| Modulo I2C dell'LCD VCC / SDA / SCL | 5V / A4 / A5 | Non usato (pagina web) |
| VCC del modulo pioggia | D7 (solo durante la misura) | GPIO 25 |
| AO del modulo pioggia | A0 | GPIO 34 (ADC1) |
| Partitore LDR e 10 kΩ | LDR al 5V, 10 kΩ a GND, punto centrale su A1 | LDR al 3V3, 10 kΩ a GND, punto centrale su GPIO 35 |
| Modulo SD CS / MOSI / MISO / SCK | D10 / D11 / D12 / D13 | Non usato |
| VCC del modulo SD | 5V | — |
| Dispositivo I2C | Indirizzo predefinito | Nota |
|---|---|---|
| Modulo I2C dell'LCD (PCF8574T) | 0x27 | 0x20–0x27 con i ponticelli a stagno |
| Modulo I2C dell'LCD (PCF8574AT) | 0x3F | 0x38–0x3F con i ponticelli a stagno |
| BMP280 (moduli viola) | 0x76 | 0x77 se il pin SDO va a 3,3 V |
| BMP280 (scheda Adafruit) | 0x77 | 0x76 se SDO va a GND |
| BME280 (al posto del BMP280) | 0x76 o 0x77 | Chip ID 0x60; quello del BMP280 è 0x58 |
| RTC DS3231 / DS1307 (facoltativo) | 0x68 | La EEPROM del modulo DS3231 è a 0x57 |
Installare le librerie
- Apri il Gestore librerie dell'IDE Arduino e installa LiquidCrystal I2C (Frank de Brabander).
- Cerca Adafruit BMP280 Library; quando ti chiede delle dipendenze scegli Install all, così vengono installate anche Adafruit Unified Sensor e Adafruit BusIO.
- Installa DHT sensor library (Adafruit).
- 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
- Prima il bus I2C: collega l'LCD e il BMP280 ad A4 e A5, avvia lo scanner I2C e annota i due indirizzi.
- 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.
- 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.
- 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.
- 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.
- 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.
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 funzione | A cosa serve |
|---|---|
| ALTITUDE_M | Altitudine; serve a riportare la pressione misurata al livello del mare |
| RAIN_DRY / RAIN_WET | I valori analogici che hai misurato con la piastra asciutta e bagnata |
| RAIN_ON / RAIN_OFF | Soglie (%) di inizio e fine pioggia; la differenza tra le due è l'isteresi |
| DAY_LEVEL / NIGHT_LEVEL | Soglie 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 ore | Classe | Cosa significa di solito |
|---|---|---|
| Meno di 0,1 hPa | Stazionaria | Il tempo attuale continua |
| 0,1–1,5 hPa | In lento aumento / calo | Piccolo cambiamento; in calo il cielo può annuvolarsi |
| 1,6–3,5 hPa | In aumento / calo | In calo cresce la probabilità di pioggia, in aumento il cielo si rasserena |
| 3,6–6 hPa | In rapido aumento / calo | In calo arriva tempo ventoso e piovoso |
| Più di 6 hPa | Molto rapida | Tempesta; 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.
| minutes | temp_c | hum_pct | press_hpa | dew_c | rain_pct | light |
|---|---|---|---|---|---|---|
| 0 | 21.4 | 58 | 1016.2 | 12.8 | 0 | day |
| 60 | 20.8 | 61 | 1015.1 | 13.0 | 0 | day |
| 120 | 18.9 | 72 | 1013.4 | 13.7 | 34 | night |
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.
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.
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) + " °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
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| L'LCD mostra solo quadratini pieni | Contrasto regolato male o indirizzo I2C sbagliato | Gira il trimmer blu sul retro del modulo e prova 0x3F al posto di 0x27 |
| Sul display compare nan | Il DHT22 non si legge: cablaggio, pull-up o letture più frequenti di una ogni 2 secondi | Controlla 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 mai | BMP280 non trovato: indirizzo 0x77 o modulo a 3,3 V alimentato male | Prova begin(0x77) e alimenta il modulo con la tensione giusta |
| La pressione è 80–100 hPa sotto quella del meteo | Altitudine non inserita, viene mostrata la pressione locale | Aggiorna ALTITUDE_M con la tua altitudine reale |
| Di giorno la temperatura è altissima | Il sensore prende il sole o si scalda dentro la scatola | Usa uno schermo all'ombra e ventilato |
| Percentuale di pioggia alta anche col secco | Piastra sporca, coperta di rugiada o calibrata male | Pulisci la piastra, rimisura RAIN_DRY e alza la soglia RAIN_ON |
| Sul display compare SD:off | Nessuna scheda, scheda in exFAT o modulo alimentato a 3,3 V | Formatta FAT32 una scheda fino a 32 GB e collega il modulo al 5V |
| All'alba salta tra Day e Night | Le soglie sono troppo vicine | Lascia almeno 100 punti tra DAY_LEVEL e NIGHT_LEVEL |
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.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
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…

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…

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.

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.

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.

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.

Misura di temperatura con NTC e display Lcd 2x16
Misura la temperatura dell'ambiente con un sensore che sembra una piccola perlina.

Utilizzo dello schermo LCD con I2C
Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

