Guías · 12 min de lectura

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.

Sensor de temperatura y humedad DHT22
DHT22 (AM2302): mide temperatura entre -40 y 80 °C con ±0,5 °C de precisión y humedad; es el sensor principal de la estación.

¿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ónSensorRango y precisiónConexión
Temperatura y humedadDHT22 (AM2302)-40…80 °C ±0,5 °C; 0–100 % ±2–5 %Una línea de datos (D2)
Presión atmosféricaBMP280300–1100 hPa, ±1 hPaI2C (A4, A5)
LluviaPlaca FC-37 / YL-83 y módulo LM393Porcentaje de humedad de la placa (se calibra en el código)Analógica A0, alimentación D7
Día / nocheLDR (GL5528) y resistencia de 10 kΩNivel de luz aproximadoAnalógica A1
PantallaLCD 16x2 con módulo I2C (PCF8574)2 líneas × 16 caracteresI2C (A4, A5)
Registro (opcional)Módulo de tarjeta microSDFAT32, archivo CSVSPI (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
BMP280
BMP280
Sensor de lluvia
Sensor de lluvia
LDR
LDR
I2C 16x2 LCD
I2C 16x2 LCD
Módulo de tarjeta MicroSD
Módulo de tarjeta MicroSD

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 pinArduino UnoESP32 (versión Wi-Fi)
DHT22 VCC / GND5V / GND3V3 / GND
DHT22 DATAD2GPIO 4
BMP280 VCC3.3V (6 pines) o 5V (con regulador)3V3
BMP280 SDA / SCLA4 / A5GPIO 21 / GPIO 22
Módulo I2C de la LCD VCC / SDA / SCL5V / A4 / A5No se usa (página web)
VCC del módulo de lluviaD7 (solo al medir)GPIO 25
AO del módulo de lluviaA0GPIO 34 (ADC1)
Divisor LDR y 10 kΩLDR a 5V, 10 kΩ a GND, punto medio a A1LDR a 3V3, 10 kΩ a GND, punto medio a GPIO 35
Módulo SD CS / MOSI / MISO / SCKD10 / D11 / D12 / D13No se usa
VCC del módulo SD5V—
Dispositivo I2CDirección por defectoNota
Módulo I2C de la LCD (PCF8574T)0x27Con los puentes de soldadura, 0x20–0x27
Módulo I2C de la LCD (PCF8574AT)0x3FCon los puentes de soldadura, 0x38–0x3F
BMP280 (módulos morados)0x760x77 si el pin SDO va a 3,3 V
BMP280 (placa Adafruit)0x770x76 si el pin SDO va a GND
BME280 (en lugar del BMP280)0x76 o 0x77Chip ID 0x60; el del BMP280 es 0x58
RTC DS3231 / DS1307 (opcional)0x68La EEPROM del módulo DS3231 está en 0x57
La mayoría de los módulos BMP280 morados de 6 pines no tienen regulador; el chip funciona con 3,6 V como máximo, así que aliméntalos desde el pin 3.3V del Uno. Los módulos de 4 pines con un pequeño regulador sí se pueden conectar a 5V. Si no estás seguro de las direcciones, primero corre el escáner I2C del artículo LCD I2C: deberías ver dos direcciones, por ejemplo 0x27 y 0x76. En la versión con ESP32 nunca alimentes el divisor de la LDR desde 5V; los pines analógicos del ESP32 no aguantan más de 3,3 V.

Instalar las librerías

  1. Abre el Gestor de librerías del IDE de Arduino e instala LiquidCrystal I2C (Frank de Brabander).
  2. Busca Adafruit BMP280 Library; cuando te pregunte por las dependencias elige Install all, así también se instalan Adafruit Unified Sensor y Adafruit BusIO.
  3. Instala DHT sensor library (Adafruit).
  4. 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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.

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}
Constante o funciónQué hace
ALTITUDE_MAltitud; sirve para convertir la presión medida a nivel del mar
RAIN_DRY / RAIN_WETValores analógicos que mediste con la placa seca y mojada
RAIN_ON / RAIN_OFFUmbrales (%) de inicio y fin de la lluvia; la diferencia entre ambos es la histéresis
DAY_LEVEL / NIGHT_LEVELUmbrales 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 horasClase¿Qué suele significar?
Menos de 0,1 hPaEstableEl tiempo actual se mantiene
0,1–1,5 hPaSube / baja lentamenteCambio pequeño; si baja, puede nublarse
1,6–3,5 hPaSube / bajaSi baja, aumenta la probabilidad de lluvia; si sube, el cielo se despeja
3,6–6 hPaSube / baja rápidoSi baja, se acerca tiempo ventoso y lluvioso
Más de 6 hPaMuy rápidoTormenta; 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.

minutestemp_chum_pctpress_hpadew_crain_pctlight
021.4581016.212.80day
6020.8611015.113.00day
12018.9721013.413.734night

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.

Este código usa cerca del 61 % de los 2 KB de RAM del Arduino Uno y el 76 % de sus 32 KB de memoria de programa; la mayor parte de la RAM se la lleva el búfer de 512 bytes de la librería SD. Escribir los textos fijos dentro de F("...") ahorra RAM. Si al agregar funciones el IDE avisa "Low memory available", puedes desactivar el registro en SD o pasar la estación a un Arduino Mega o a un ESP32, que tienen más memoria; los detalles están en memoria insuficiente en Arduino.

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.

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}

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íntomaCausa probableSolución
La LCD solo muestra cuadros llenosContraste mal ajustado o dirección I2C equivocadaGira el trimpot azul de atrás del módulo y prueba 0x3F en lugar de 0x27
En la pantalla aparece nanNo se puede leer el DHT22: cable, pull-up o lecturas más seguidas que cada 2 segundosRevisa 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 nuncaNo se encontró el BMP280: dirección 0x77 o módulo de 3,3 V mal alimentadoPrueba begin(0x77) y alimenta el módulo con el voltaje correcto
La presión está 80–100 hPa por debajo de la del pronósticoNo pusiste la altitud y se muestra la presión localActualiza ALTITUDE_M con tu altitud real
De día la temperatura sale altísimaAl sensor le da el sol o se calienta dentro de la cajaUsa un protector a la sombra y ventilado
El porcentaje de lluvia es alto aunque no lluevaPlaca sucia, con rocío o mal calibradaLimpia la placa, vuelve a medir RAIN_DRY y sube el umbral RAIN_ON
La pantalla dice SD:offNo hay tarjeta, está en exFAT o el módulo se alimenta con 3,3 VFormatea en FAT32 una tarjeta de hasta 32 GB y conecta el módulo a 5V
Al amanecer salta entre Day y NightLos umbrales están demasiado cercaDeja al menos 100 unidades entre DAY_LEVEL y NIGHT_LEVEL
Para suavizar los saltos bruscos en el registro, puedes guardar en la línea de cada hora el promedio de las últimas 12 mediciones en lugar de una sola; encontrarás el promedio móvil y el filtro de mediana en filtrado de datos de sensores.

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.

Ver todos los proyectos
Temperatura y humedad con DHT11
AR-55Intermedio

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…

4.7(47)
83
Medir la intensidad de luz con LDR
AR-11Principiante

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…

4.6(83)
143
Reloj matricial, calendario y estación meteorológica (MAX7219, DS1307)
AR-85Intermedio
Premium

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.

5.0(50)
66
ESP32 DHT22 Temperatura y humedad (con pantalla LCD)
ES-15Intermedio

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.

4.8(38)
57
Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzado
Premium

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.

4.7(7)
12
ESP32 HTTPClient + API del tiempo (con pantalla LCD)
ES-31Avanzado
Premium

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.

4.7(13)
20
Medición de temperatura con NTC y pantalla LCD 2x16
AR-44Principiante
Premium

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…

4.5(33)
44
Uso de la pantalla LCD con I2C
AR-32Principiante
Premium

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…

4.8(53)
70