Estación meteorológica con Arduino: DHT22, BMP280, lluvia y LCD
Cómo hacer una estación meteorológica con Arduino: DHT22, BMP280, sensor de lluvia, LDR, direcciones I2C, LCD con páginas rotativas y registro en microSD.
Una estación meteorológica con Arduino es uno de los proyectos más entretenidos para aprender: con unos cuantos sensores baratos mides la temperatura, la humedad, la presión atmosférica y la lluvia de tu balcón o tu patio y las ves en una pantalla. En esta guía vas a conectar a un Arduino Uno un DHT22 (temperatura y humedad), un BMP280 (presión), un sensor de lluvia y una LDR para distinguir el día de la noche, y vas a mostrar los valores en una LCD 16x2 con módulo I2C en páginas que cambian cada pocos segundos. Si le agregas un módulo microSD, la estación guarda una línea de registro cada hora; después de unos días puedes graficar los datos en Excel.
El proyecto no se queda en leer sensores: vamos a convertir la presión medida en presión a nivel del mar según tu altitud, para compararla con la de los sitios del clima, vamos a calcular el punto de rocío a partir de la temperatura y la humedad, y vamos a anticipar si el tiempo va a empeorar con el cambio de presión de las últimas tres horas. En orden vienen la tabla de conexiones y direcciones I2C, el armado paso a paso, el código completo, la explicación de los cálculos, el registro horario, la versión Wi-Fi con ESP32, cómo colocar los sensores al aire libre y los errores más comunes.

¿Qué mide una estación meteorológica con Arduino?
Cada sensor se eligió por ser el que mejor hace un solo trabajo. El DHT22 entrega la temperatura y la humedad relativa por una sola línea de datos y es mucho más preciso que el DHT11. El BMP280 mide la presión atmosférica en hectopascales (hPa) con ±1 hPa de precisión; el cambio de presión es el aviso más confiable de que se acerca la lluvia. La placa del sensor de lluvia entrega un valor analógico que baja a medida que se moja. La LDR es una fotorresistencia sencilla cuya resistencia cambia con la luz y alcanza para distinguir el día de la noche. Todo se muestra en la LCD I2C; la pantalla y el BMP280 comparten los mismos dos cables (SDA y SCL).
| Medición | Sensor | Rango y precisión | Conexión |
|---|---|---|---|
| Temperatura y humedad | DHT22 (AM2302) | -40…80 °C ±0,5 °C; 0–100 % ±2–5 % | Una línea de datos (D2) |
| Presión atmosférica | BMP280 | 300–1100 hPa, ±1 hPa | I2C (A4, A5) |
| Lluvia | Placa FC-37 / YL-83 y módulo LM393 | Porcentaje de humedad de la placa (se calibra en el código) | Analógica A0, alimentación D7 |
| Día / noche | LDR (GL5528) y resistencia de 10 kΩ | Nivel de luz aproximado | Analógica A1 |
| Pantalla | LCD 16x2 con módulo I2C (PCF8574) | 2 líneas × 16 caracteres | I2C (A4, A5) |
| Registro (opcional) | Módulo de tarjeta microSD | FAT32, archivo CSV | SPI (D10–D13) |
Lista de materiales
- Arduino Uno (el Arduino Nano funciona con los mismos pines)
- Módulo DHT22 (de tres pines, con la resistencia pull-up incluida) o DHT22 de cuatro patas y una resistencia de 10 kΩ
- Módulo BMP280 (mejor la versión de 5 V con regulador) o un BME280, que además mide humedad
- Placa del sensor de lluvia y módulo comparador LM393
- LDR y resistencia de 10 kΩ
- LCD 16x2 con el módulo I2C soldado atrás
- Módulo microSD con regulador y una tarjeta de hasta 32 GB formateada en FAT32 (opcional)
- Protoboard, cables jumper y un cargador USB de 5 V que entregue al menos 1 A





Diagrama de conexiones: tabla de pines y direcciones I2C
La idea clave del circuito es el bus I2C compartido: la LCD y el BMP280 se conectan en paralelo a los mismos pines SDA (A4) y SCL (A5), y el Arduino llega a cada uno con una dirección distinta. El módulo SD usa el bus SPI (D10–D13), así que no choca con el I2C. El VCC del módulo de lluvia no va directo a 5V sino a D7: el código alimenta la placa solo durante unos milisegundos al medir, y eso frena mucho la corrosión. Explicamos cómo funciona el bus I2C en ¿Qué es I2C?.
| Componente y pin | Arduino Uno | ESP32 (versión Wi-Fi) |
|---|---|---|
| DHT22 VCC / GND | 5V / GND | 3V3 / GND |
| DHT22 DATA | D2 | GPIO 4 |
| BMP280 VCC | 3.3V (6 pines) o 5V (con regulador) | 3V3 |
| BMP280 SDA / SCL | A4 / A5 | GPIO 21 / GPIO 22 |
| Módulo I2C de la LCD VCC / SDA / SCL | 5V / A4 / A5 | No se usa (página web) |
| VCC del módulo de lluvia | D7 (solo al medir) | GPIO 25 |
| AO del módulo de lluvia | A0 | GPIO 34 (ADC1) |
| Divisor LDR y 10 kΩ | LDR a 5V, 10 kΩ a GND, punto medio a A1 | LDR a 3V3, 10 kΩ a GND, punto medio a GPIO 35 |
| Módulo SD CS / MOSI / MISO / SCK | D10 / D11 / D12 / D13 | No se usa |
| VCC del módulo SD | 5V | — |
| Dispositivo I2C | Dirección por defecto | Nota |
|---|---|---|
| Módulo I2C de la LCD (PCF8574T) | 0x27 | Con los puentes de soldadura, 0x20–0x27 |
| Módulo I2C de la LCD (PCF8574AT) | 0x3F | Con los puentes de soldadura, 0x38–0x3F |
| BMP280 (módulos morados) | 0x76 | 0x77 si el pin SDO va a 3,3 V |
| BMP280 (placa Adafruit) | 0x77 | 0x76 si el pin SDO va a GND |
| BME280 (en lugar del BMP280) | 0x76 o 0x77 | Chip ID 0x60; el del BMP280 es 0x58 |
| RTC DS3231 / DS1307 (opcional) | 0x68 | La EEPROM del módulo DS3231 está en 0x57 |
Instalar las librerías
- Abre el Gestor de librerías del IDE de Arduino e instala LiquidCrystal I2C (Frank de Brabander).
- Busca Adafruit BMP280 Library; cuando te pregunte por las dependencias elige Install all, así también se instalan Adafruit Unified Sensor y Adafruit BusIO.
- Instala DHT sensor library (Adafruit).
- Las librerías SD y SPI vienen con el IDE de Arduino, no hace falta instalarlas. Los detalles de la instalación están en cómo agregar librerías en Arduino.
Armado paso a paso
- Primero arma el bus I2C: conecta la LCD y el BMP280 a A4 y A5, corre el escáner I2C y anota las dos direcciones.
- Agrega el DHT22: conecta el pin de datos a D2. Si usas el sensor suelto de cuatro patas, pon una resistencia pull-up de 10 kΩ entre datos y VCC.
- Conecta el sensor de lluvia: une la placa al módulo, el VCC del módulo a D7 y AO a A0. Mide los valores con la placa seca y mojada y escríbelos en las constantes RAIN_DRY y RAIN_WET del código.
- Arma el divisor de la LDR: conecta una pata de la LDR a 5V y la otra a A1, y una resistencia de 10 kΩ de A1 a GND. Cuanta más luz, más alta la lectura.
- Agrega el módulo SD: aliméntalo con 5V y conecta CS a D10, MOSI a D11, MISO a D12 y SCK a D13. Si no hay tarjeta, la estación sigue funcionando sin registro.
- Escribe tu altitud: busca la altura sobre el nivel del mar de tu ubicación y ponla en la constante ALTITUDE_M; de ella depende la precisión del cálculo de presión.
Código de la estación meteorológica: páginas rotativas y registro horario en SD
El código de abajo junta todas las piezas. Los sensores se leen cada 5 segundos, la pantalla rota entre tres páginas cada 4 segundos y, si hay tarjeta SD, se guarda una línea al encender y luego una por hora. Como usa millis() en lugar de delay(), las tres tareas no se esperan entre sí. Los textos de la pantalla son abreviaturas cortas en inglés: T temperatura, H humedad, Dew pt punto de rocío y P presión.
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}| Constante o función | Qué hace |
|---|---|
| ALTITUDE_M | Altitud; sirve para convertir la presión medida a nivel del mar |
| RAIN_DRY / RAIN_WET | Valores analógicos que mediste con la placa seca y mojada |
| RAIN_ON / RAIN_OFF | Umbrales (%) de inicio y fin de la lluvia; la diferencia entre ambos es la histéresis |
| DAY_LEVEL / NIGHT_LEVEL | Umbrales de día y noche de la LDR; la zona intermedia evita parpadeos al amanecer |
| readRain() | Alimenta la placa desde D7, promedia 4 lecturas, corta la alimentación y lo convierte a porcentaje |
| calcDewPoint() | Calcula el punto de rocío con la fórmula de Magnus |
| takeForcedMeasurement() | Pide al BMP280 una sola medición; evita el calentamiento de la medición continua |
| history[4] y trend3h() | Guardan la presión de cada hora y dan el cambio de las últimas 3 horas |
| logHourly() | Desplaza el historial de presión y agrega una línea CSV a la tarjeta SD |
Cálculos: presión a nivel del mar, punto de rocío y tendencia barométrica
Lo que mide el BMP280 es la presión local de tu ubicación, que baja con la altitud: la presión que a nivel del mar ronda los 1013 hPa es de unos 915 hPa a 850 metros, y en ciudades altas como Bogotá o Ciudad de México queda entre 730 y 780 hPa. Los sitios del clima, en cambio, publican la presión de cada estación reducida al nivel del mar. Esa conversión la hace la función seaLevelForAltitude() del código: P0 = P / (1 − h / 44330)^5,255. Para 915 hPa medidos a 850 metros, 1 − 850 / 44330 = 0,9808 y 0,9808^5,255 ≈ 0,903; 915 / 0,903 ≈ 1013 hPa. Un error de 10 metros en la altitud corre el resultado unos 1,2 hPa, así que toma la altitud de un mapa o un GPS con el mayor cuidado posible.
El punto de rocío es la temperatura a la que el aire empieza a condensarse si se enfría, y es una medida de confort más útil que la humedad relativa: hasta 13 °C el aire se siente agradable, por encima de 16 °C húmedo y por encima de 20 °C sofocante. El código usa la fórmula de Magnus: γ = ln(HR / 100) + 17,62·T / (243,12 + T) y Td = 243,12·γ / (17,62 − γ). Para 24 °C y 50 % de humedad resulta γ ≈ 0,890 y Td ≈ 12,9 °C. Si de noche la temperatura se acerca al punto de rocío, a la mañana puede haber niebla o rocío; si el punto de rocío está bajo 0 °C, en lugar de rocío se forma escarcha, y ese es un buen disparador para una alarma de heladas.
La herramienta de pronóstico más útil es la tendencia barométrica: el cambio en 3 horas dice mucho más que la presión en sí. El código guarda la presión cada hora en un arreglo; cuando junta cuatro valores, es decir, 3 horas después de encender, muestra en pantalla la diferencia entre el último valor y el de 3 horas antes, y escribe Falling si cae más de 1,6 hPa o Rising si sube. La clasificación que se usa en meteorología es la siguiente.
| Cambio de presión en 3 horas | Clase | ¿Qué suele significar? |
|---|---|---|
| Menos de 0,1 hPa | Estable | El tiempo actual se mantiene |
| 0,1–1,5 hPa | Sube / baja lentamente | Cambio pequeño; si baja, puede nublarse |
| 1,6–3,5 hPa | Sube / baja | Si baja, aumenta la probabilidad de lluvia; si sube, el cielo se despeja |
| 3,6–6 hPa | Sube / baja rápido | Si baja, se acerca tiempo ventoso y lluvioso |
| Más de 6 hPa | Muy rápido | Tormenta; un cambio de tiempo muy brusco |
Registro horario en la tarjeta SD y gráficos en Excel
Si hay una tarjeta SD, la estación crea el archivo WEATHER.CSV en la raíz, escribe los encabezados de las columnas en la primera línea y luego agrega una línea por hora. La librería SD de Arduino solo acepta nombres de archivo de 8+3 caracteres, por eso el nombre es corto. Cerrar el archivo después de cada registro hace que, si se corta la luz, se pierda como mucho la última línea. Como el Uno no tiene reloj real, la primera columna son los minutos desde que se encendió; si quieres fecha y hora, agrega un módulo RTC y toma la marca de tiempo de él. Para elegir y formatear la tarjeta, mira el artículo del módulo de tarjeta 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 |
En el ejemplo de arriba la presión bajó 2,8 hPa en dos horas y en el tercer registro empezó a llover: ahí ves cómo la tendencia avisa de la lluvia. Abre el archivo en la computadora con Excel o Google Sheets y grafica las columnas de presión y temperatura como líneas. Si tu Excel usa la coma como separador decimal, valores como 1016.2 pueden aparecer como texto; al importar, cambia la configuración regional de la columna a Inglés (Estados Unidos). El método completo está en pasar datos de Arduino a Excel.
Estación meteorológica Wi-Fi con ESP32
Si quieres ver las mediciones en el celular, puedes conectar los mismos sensores a un ESP32. En esta versión, en lugar de la LCD se usa una página web que sirve el propio ESP32: abre en un celular conectado a la misma red Wi-Fi la dirección IP que aparece en el Monitor Serie y verás los valores; la página se actualiza sola cada 30 segundos. La dirección /json entrega los mismos datos en un formato que otro programa puede leer. Los pines del ESP32 trabajan a 3,3 V: alimenta los sensores desde 3V3 y usa para las entradas analógicas los pines ADC1 (GPIO 32–39), que funcionan aunque el Wi-Fi esté encendido. El ADC del ESP32 es de 12 bits y lee de 0 a 4095, así que tienes que volver a medir los umbrales de lluvia.
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}Para ver los datos desde cualquier lugar, guardarlos en Google Sheets o comparar tus mediciones con el pronóstico de internet, mira ESP32 con Google Sheets y API del clima con ESP32. El código compila sin cambios con las versiones 2.x y 3.x del core ESP32, porque solo usa funciones de WiFi y WebServer que son iguales en las dos.
Cómo colocar bien los sensores
- Pon el sensor de temperatura a la sombra: un DHT22 al sol puede marcar 5–10 °C más que la temperatura real del aire. Ponlo en una caja blanca ventilada o en un protector de radiación hecho con platos de plástico apilados.
- Aléjalo de las paredes: las paredes y los marcos de las ventanas que calienta el sol suben la lectura; coloca el sensor a por lo menos 30 cm de la pared y, si puedes, a 1,5–2 m del suelo.
- Deja la electrónica adentro: el Arduino, la LCD y el BMP280 pueden ir en una caja cerrada, porque la presión dentro de la caja es la misma. Solo el DHT22, la placa de lluvia y la LDR tienen que estar afuera.
- Monta inclinada la placa de lluvia: colócala con 30–45 grados de inclinación para que el agua escurra cuando pare de llover; una placa horizontal queda mojada durante horas.
- Apunta la LDR al cielo: si le da la luz de un farol o del balcón, la estación creerá que es de día; colócala lejos de las lámparas y mirando hacia arriba.
- Cuida el largo de los cables: el DHT22 funciona bien con unos metros de cable; si con más de 10 metros empiezan los errores de lectura, baja la resistencia pull-up a 4,7 kΩ. El bus I2C está pensado solo para unas decenas de centímetros, así que deja el BMP280 junto al Arduino.
Cómo ampliar la estación: ideas de proyectos
- Intensidad de luz: en lugar de la LDR usa un BH1750, que mide en lux, y calcula las horas de sol.
- Calidad del aire: agrega a la estación de interior un sensor de CO2 MH-Z19 y a la de exterior un sensor de polvo PMS5003.
- Fecha y hora reales: con un módulo RTC escribe la fecha y la hora en los registros y guarda cada medianoche la máxima y la mínima del día.
- Aviso de heladas y de invernadero: arma una alarma de heladas que haga sonar un buzzer bajo 2 °C o un invernadero inteligente que controle la ventilación.
- Energía solar: con un panel pequeño, un módulo de carga TP4056 y una pila 18650 la estación no depende del enchufe; en la versión ESP32, con deep sleep la batería dura semanas.
- Viento y lluvia acumulada: mide la velocidad del viento con un anemómetro de reed switch y los milímetros de lluvia con un pluviómetro de balancín.
Errores comunes y soluciones
| Síntoma | Causa probable | Solución |
|---|---|---|
| La LCD solo muestra cuadros llenos | Contraste mal ajustado o dirección I2C equivocada | Gira el trimpot azul de atrás del módulo y prueba 0x3F en lugar de 0x27 |
| En la pantalla aparece nan | No se puede leer el DHT22: cable, pull-up o lecturas más seguidas que cada 2 segundos | Revisa el cable de datos y la resistencia de 10 kΩ; el código conserva el valor anterior si falla una lectura |
| La presión da nan o no cambia nunca | No se encontró el BMP280: dirección 0x77 o módulo de 3,3 V mal alimentado | Prueba begin(0x77) y alimenta el módulo con el voltaje correcto |
| La presión está 80–100 hPa por debajo de la del pronóstico | No pusiste la altitud y se muestra la presión local | Actualiza ALTITUDE_M con tu altitud real |
| De día la temperatura sale altísima | Al sensor le da el sol o se calienta dentro de la caja | Usa un protector a la sombra y ventilado |
| El porcentaje de lluvia es alto aunque no llueva | Placa sucia, con rocío o mal calibrada | Limpia la placa, vuelve a medir RAIN_DRY y sube el umbral RAIN_ON |
| La pantalla dice SD:off | No hay tarjeta, está en exFAT o el módulo se alimenta con 3,3 V | Formatea en FAT32 una tarjeta de hasta 32 GB y conecta el módulo a 5V |
| Al amanecer salta entre Day y Night | Los umbrales están demasiado cerca | Deja al menos 100 unidades entre DAY_LEVEL y NIGHT_LEVEL |
Esta estación junta casi todo lo que aprendiste en Arduino: lecturas digitales y analógicas, buses I2C y SPI, multitarea con millis, cálculos y registro de datos. Primero haz funcionar cada sensor por separado, después une las partes y al final mételas en la caja. En la app BlueGrays encontrarás medición de temperatura y humedad con DHT11, lectura de luz con LDR, medición con ESP32 y DHT22 en LCD, un registrador de temperatura que guarda en SD y una estación meteorológica con pantalla de matriz de puntos, cada uno con diagramas paso a paso y código listo para usar.
Preguntas frecuentes
¿Cómo hacer una estación meteorológica con Arduino?
Conectas a un Arduino Uno un DHT22 para temperatura y humedad, un BMP280 para presión, un sensor de lluvia y una LDR para la luz; muestras los valores en una LCD I2C y, si quieres, los guardas en una tarjeta SD. Prueba primero cada sensor por separado y después júntalos en un solo código. Tener los sensores a la sombra y en una caja ventilada es la condición más importante para medir bien.
¿Qué sensor es mejor para una estación meteorológica, DHT22 o BME280?
El DHT22 es un poco más preciso en temperatura (±0,5 °C) pero solo se puede leer cada 2 segundos; el BME280 reúne temperatura, humedad y presión en un solo chip I2C. Si quieres menos cables y pines, el BME280 solo alcanza. En este proyecto se usan los dos porque el DHT22 va afuera y el BMP280 puede quedar dentro de la caja.
¿Por qué la presión del BMP280 es más baja que la del pronóstico?
El sensor mide la presión local a la altura donde estás, mientras que los sitios del clima publican la presión reducida al nivel del mar. Por cada 100 metros de altitud la presión baja unos 12 hPa. Si escribes tu altitud en la constante ALTITUDE_M, seaLevelForAltitude() la vuelve comparable.
¿Una estación meteorológica con Arduino puede predecir la lluvia?
No da un pronóstico exacto, pero la tendencia barométrica es una buena pista: una caída de más de 1,6 hPa en 3 horas suele indicar que se acercan nubes y lluvia, y una subida, que el cielo se va a despejar. El sensor de lluvia, además, detecta el momento en que empieza a llover. Con los dos juntos tienes un sistema de aviso sencillo pero útil.
¿Por qué se oxida el sensor de lluvia y cómo evitarlo?
Cuando las pistas de la placa tienen voltaje todo el tiempo, al mojarse se produce electrólisis y el metal se desgasta rápido. Conectar el VCC del módulo a un pin digital y alimentar la placa solo al medir alarga muchísimo su vida. Montarla inclinada para que se seque rápido después de la lluvia también frena la corrosión.
¿Cuánto dura con batería una estación meteorológica con Arduino?
El Arduino Uno con la luz de fondo de la LCD y los sensores consume unos 70–90 mA; un power bank de 2000 mAh lo mantiene funcionando alrededor de un día. Apagar la luz de fondo alarga el tiempo, pero para usarla mucho tiempo con batería conviene un ESP32 con deep sleep. Puedes calcular la autonomía de tu circuito con la calculadora de duración de batería.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Temperatura y humedad con DHT11
¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

Medir la intensidad de luz con LDR
¿Quieres ver en números cuánta luz hay en tu habitación? El LDR, una pequeña pieza sensible a la luz, mide la luz ambiente y el Arduino escribe el valor en la pantalla del ordenador cada medio…

Reloj matricial, calendario y estación meteorológica (MAX7219, DS1307)
Un panel de texto en movimiento para tu mesa o tu pared que muestra por turnos la hora, la fecha y el clima de la habitación.

ESP32 DHT22 Temperatura y humedad (con pantalla LCD)
Se trata de un proyecto que mide la temperatura y la humedad ambientales mediante el sensor DHT22 y las muestra en tiempo real en una pantalla LCD I2C 16x2. Los datos del sensor se leen mediante el protocolo de un solo cable (one-wire) utilizando la biblioteca DHT de Adafruit. Este proyecto constituye la base para estaciones meteorológicas IoT, sistemas de automatización doméstica inteligente o sistemas de monitorización ambiental en invernaderos.

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

ESP32 HTTPClient + API del tiempo (con pantalla LCD)
El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. La respuesta JSON se analiza con ArduinoJson v7, y la ciudad, la temperatura, la humedad, el estado del tiempo y el viento aparecen en una LCD I2C. wttr.in no pide clave de API: basta con escribir el nombre de cualquier ciudad.

Medición de temperatura con NTC y pantalla LCD 2x16
Mide la temperatura del ambiente con un sensor que parece una pequeña cuenta. Esta pieza, llamada NTC, deja pasar la electricidad con más facilidad cuanto más se calienta; el Arduino lee ese cambio…

Uso de la pantalla LCD con I2C
Dale a tu Arduino su propia pantalla y haz que escriba su primer mensaje. La pantalla LCD de dos líneas se conecta con solo unos pocos cables; primero aparece un saludo en la línea de arriba, luego…
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

