Estação meteorológica com Arduino: DHT22, BMP280, sensor de chuva e LCD
Monte uma estação meteorológica com Arduino: temperatura e umidade com DHT22, pressão com BMP280, sensor de chuva, LDR, tabela de endereços I2C, páginas alternadas no LCD e registro em SD.
Uma estação meteorológica com Arduino é um dos projetos mais gostosos para aprender: alguns sensores baratos medem a temperatura, a umidade, a pressão do ar e a chuva na sua varanda ou no seu quintal e mostram tudo em um display. Neste guia você vai ligar a um Arduino Uno um DHT22 (temperatura e umidade), um BMP280 (pressão), um sensor de chuva e um LDR para distinguir dia e noite, e mostrar as leituras em um LCD I2C 16x2 em páginas que mudam a cada poucos segundos. Acrescente um módulo microSD e a estação grava uma linha de registro a cada hora; depois de alguns dias, dá para fazer gráficos dos dados no Excel.
O projeto vai além de ler sensores: vamos converter a pressão medida para a pressão ao nível do mar na sua altitude, para você comparar com sites de previsão do tempo, calcular o ponto de orvalho a partir da temperatura e da umidade e prever se o tempo vai virar pela mudança de pressão nas últimas três horas. Na ordem, você vai encontrar as tabelas de ligação e de endereços I2C, a montagem passo a passo, o código completo, as contas explicadas, o registro de hora em hora, uma versão com Wi-Fi usando o ESP32, como instalar os sensores ao ar livre e os erros comuns.

O que uma estação meteorológica com Arduino mede?
Cada sensor foi escolhido por fazer melhor uma tarefa. O DHT22 entrega temperatura e umidade relativa por uma única linha de dados e é bem mais preciso que o DHT11. O BMP280 mede a pressão do ar em hectopascais (hPa) com ±1 hPa; a mudança de pressão é o sinal mais confiável de chuva chegando. A placa do sensor de chuva dá um valor analógico que cai conforme ela molha. O LDR é um fotorresistor simples cuja resistência muda com a luz, o que basta para distinguir dia e noite. Tudo aparece no LCD I2C; o display e o BMP280 compartilham os mesmos dois fios (SDA e SCL).
| Medida | Sensor | Faixa e precisão | Ligação |
|---|---|---|---|
| Temperatura e umidade | DHT22 (AM2302) | -40…80 °C ±0,5 °C; 0–100 % ±2–5 % | Linha de dados única (D2) |
| Pressão do ar | BMP280 | 300–1100 hPa, ±1 hPa | I2C (A4, A5) |
| Chuva | Placa FC-37 / YL-83 e módulo LM393 | Porcentagem de umidade da placa (calibrada no código) | Analógico A0, alimentação pelo D7 |
| Dia / noite | LDR (GL5528) e resistor de 10 kΩ | Nível de luz aproximado | Analog A1 |
| Display | LCD 16x2 com adaptador I2C (PCF8574) | 2 linhas × 16 caracteres | I2C (A4, A5) |
| Registro (opcional) | Módulo de cartão microSD | FAT32, arquivo CSV | SPI (D10–D13) |
Lista de peças
- Arduino Uno (um Arduino Nano funciona com os mesmos pinos)
- Módulo DHT22 (três pinos, resistor de pull-up na placa) ou um DHT22 de quatro pinos e um resistor de 10 kΩ
- Módulo BMP280 (de preferência a versão de 5 V com regulador) ou um BME280, que também mede umidade
- Placa do sensor de chuva e módulo comparador LM393
- LDR e resistor de 10 kΩ
- LCD 16x2 com adaptador I2C soldado
- Módulo de cartão microSD com regulador e um cartão de até 32 GB formatado em FAT32 (opcional)
- Protoboard, jumpers e um adaptador USB de 5 V que forneça pelo menos 1 A





Esquema de ligação: tabela de pinos e endereços I2C
A ideia central do circuito é o barramento I2C compartilhado: o LCD e o BMP280 ficam em paralelo nos mesmos pinos SDA (A4) e SCL (A5), e o Arduino acessa cada um por um endereço diferente. O módulo SD usa o barramento SPI (D10–D13), então não conflita com o I2C. O VCC do módulo de chuva vai no D7, e não direto no 5V: o código alimenta a placa só por alguns milissegundos durante a medição, o que reduz muito a corrosão. Explicamos como funciona o barramento I2C em O que é I2C?.
| Peça e pino | Arduino Uno | ESP32 (versão com Wi-Fi) |
|---|---|---|
| DHT22 VCC / GND | 5V / GND | 3V3 / GND |
| DHT22 DATA | D2 | GPIO 4 |
| BMP280 VCC | 3,3V (6 pinos) ou 5V (com regulador) | 3V3 |
| BMP280 SDA / SCL | A4 / A5 | GPIO 21 / GPIO 22 |
| VCC / SDA / SCL do adaptador I2C do LCD | 5V / A4 / A5 | Não usado (página web) |
| VCC do módulo de chuva | D7 (só durante a medição) | GPIO 25 |
| AO do módulo de chuva | A0 | GPIO 34 (ADC1) |
| Divisor com LDR e 10 kΩ | LDR no 5V, 10 kΩ no GND, ponto do meio no A1 | LDR no 3V3, 10 kΩ no GND, ponto do meio no GPIO 35 |
| CS / MOSI / MISO / SCK do módulo SD | D10 / D11 / D12 / D13 | Não usado |
| VCC do módulo SD | 5V | — |
| Dispositivo I2C | Endereço padrão | Observação |
|---|---|---|
| Adaptador I2C do LCD (PCF8574T) | 0x27 | 0x20–0x27 com os jumpers de solda |
| Adaptador I2C do LCD (PCF8574AT) | 0x3F | 0x38–0x3F com os jumpers de solda |
| BMP280 (módulos roxos) | 0x76 | 0x77 se o pino SDO for ligado a 3,3 V |
| BMP280 (placa da Adafruit) | 0x77 | 0x76 se o SDO for ligado ao GND |
| BME280 (no lugar do BMP280) | 0x76 ou 0x77 | ID do chip 0x60; o do BMP280 é 0x58 |
| RTC DS3231 / DS1307 (opcional) | 0x68 | A EEPROM do módulo DS3231 fica no 0x57 |
Instalando as bibliotecas
- Abra o Gerenciador de Bibliotecas na Arduino IDE e instale a LiquidCrystal I2C (Frank de Brabander).
- Procure Adafruit BMP280 Library; quando perguntar sobre as dependências, escolha Install all, para instalar também a Adafruit Unified Sensor e a Adafruit BusIO.
- Instale a DHT sensor library (Adafruit).
- As bibliotecas SD e SPI já vêm com a Arduino IDE, então não há nada a instalar. Os detalhes de instalação estão em como adicionar bibliotecas no Arduino.
Montagem passo a passo
- Monte primeiro o barramento I2C: ligue o LCD e o BMP280 no A4 e no A5, rode o scanner I2C e anote os dois endereços.
- Acrescente o DHT22: ligue o pino de dados no D2. Se estiver usando o sensor puro de quatro pinos, coloque um resistor de pull-up de 10 kΩ entre o dado e o VCC.
- Ligue o sensor de chuva: ligue a placa ao módulo, o VCC do módulo no D7 e o AO no A0. Meça os valores com a placa seca e molhada e escreva-os nas constantes RAIN_DRY e RAIN_WET do código.
- Monte o divisor do LDR: ligue uma perna do LDR no 5V e a outra no A1, e um resistor de 10 kΩ do A1 ao GND. Quanto mais claro, maior a leitura.
- Acrescente o módulo SD: alimente-o com 5V e ligue CS no D10, MOSI no D11, MISO no D12 e SCK no D13. Sem cartão, a estação continua funcionando sem registrar.
- Informe a sua altitude: procure a altitude do seu local em relação ao nível do mar e coloque na constante ALTITUDE_M; a precisão do cálculo de pressão depende dela.
Código da estação meteorológica: páginas alternadas e registro em SD a cada hora
O código abaixo junta todas as partes. Os sensores são lidos a cada 5 segundos, o display alterna entre três páginas a cada 4 segundos e, se houver um cartão SD, uma linha é gravada ao ligar e depois uma a cada hora. Como usa millis() em vez de delay(), as três tarefas não esperam umas pelas outras. Os rótulos do display são abreviações curtas: T temperatura, H umidade, Dew pt ponto de orvalho e P pressão.
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 ou função | O que faz |
|---|---|
| ALTITUDE_M | Altitude; usada para converter a pressão medida para o nível do mar |
| RAIN_DRY / RAIN_WET | Os valores analógicos que você mediu com a placa seca e molhada |
| RAIN_ON / RAIN_OFF | Limites de início e fim de chuva (%); a diferença entre eles é a histerese |
| DAY_LEVEL / NIGHT_LEVEL | Limites de dia e noite do LDR; a faixa entre eles evita oscilação ao amanhecer |
| readRain() | Alimenta a placa pelo D7, faz a média de 4 leituras, corta a alimentação e converte em porcentagem |
| calcDewPoint() | Calcula o ponto de orvalho com a fórmula de Magnus |
| takeForcedMeasurement() | Faz o BMP280 tirar uma única leitura; evita o autoaquecimento do modo contínuo |
| history[4] e trend3h() | Guardam os valores de pressão de hora em hora e devolvem a mudança das últimas 3 horas |
| logHourly() | Desloca o histórico de pressão e acrescenta uma linha CSV ao cartão SD |
As contas: pressão ao nível do mar, ponto de orvalho e tendência da pressão
O que o BMP280 mede é a pressão local onde você está, e ela cai com a altitude: a pressão que fica em torno de 1013 hPa ao nível do mar é de cerca de 915 hPa a 850 metros, e em uma cidade alta como Denver fica em torno de 835 hPa. Os sites de previsão do tempo, porém, informam a pressão de cada estação reduzida ao nível do mar. A função seaLevelForAltitude() do código faz essa conversão: P0 = P / (1 − h / 44330)^5.255. Para 915 hPa medidos a 850 metros, 1 − 850 / 44330 = 0,9808 e 0,9808^5,255 ≈ 0,903; 915 / 0,903 ≈ 1013 hPa. Errar a altitude em 10 metros desloca o resultado em cerca de 1,2 hPa, então pegue-a de um mapa ou GPS com o máximo de precisão.
O ponto de orvalho é a temperatura em que o ar começa a condensar ao esfriar, e é uma medida de conforto mais significativa que a umidade relativa: até 13 °C o ar é confortável, acima de 16 °C é úmido e acima de 20 °C é abafado. O código usa a fórmula de Magnus: γ = ln(RH / 100) + 17,62·T / (243,12 + T) e Td = 243,12·γ / (17,62 − γ). Para 24 °C e 50 % de umidade, você obtém γ ≈ 0,890 e Td ≈ 12,9 °C. Se a temperatura da noite estiver se aproximando do ponto de orvalho, espere neblina ou orvalho de manhã; se o ponto de orvalho estiver abaixo de 0 °C, forma-se geada em vez de orvalho, o que é um bom gatilho para um alarme de geada.
A ferramenta de previsão mais útil, porém, é a tendência da pressão: a mudança em 3 horas diz muito mais que a pressão em si. O código guarda a pressão em um array a cada hora; quando tem quatro valores, ou seja, 3 horas depois de ligar, mostra a diferença entre o valor mais recente e o de 3 horas antes, escrevendo Falling para quedas de mais de 1,6 hPa e Rising para subidas. A classificação usada na meteorologia é a seguinte.
| Mudança de pressão em 3 horas | Classe | O que costuma significar |
|---|---|---|
| Menos de 0,1 hPa | Estável | O tempo atual continua |
| 0,1–1,5 hPa | Subindo / caindo devagar | Uma mudança pequena; uma queda pode trazer nuvens |
| 1,6–3,5 hPa | Subindo / caindo | Uma queda aumenta a chance de chuva, uma subida traz céu limpo |
| 3,6–6 hPa | Subindo / caindo rápido | Uma queda indica tempo de vento e chuva a caminho |
| Mais de 6 hPa | Muito rápido | Tempestade; uma mudança muito brusca no tempo |
Registro a cada hora no cartão SD e gráficos no Excel
Se houver um cartão SD, a estação cria o WEATHER.CSV na pasta raiz do cartão, escreve os cabeçalhos das colunas na primeira linha e depois acrescenta uma linha a cada hora. A biblioteca SD do Arduino só aceita nomes de arquivo com 8+3 caracteres, por isso o nome é curto. Fechar o arquivo depois de cada registro faz com que uma queda de energia perca no máximo a última linha. Como o Uno não tem relógio de verdade, a primeira coluna são os minutos desde que ligou; se você quer data e hora, acrescente um módulo RTC e pegue o horário dele. Para escolher e formatar o cartão, veja o artigo módulo de cartão 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 |
No exemplo acima, a pressão caiu 2,8 hPa em duas horas e a chuva começou no terceiro registro; é o aviso de chuva pela tendência funcionando. Abra o arquivo no computador com o Excel ou o Planilhas Google e faça gráficos de linha com as colunas de pressão e temperatura. Se o seu Excel usa vírgula como separador decimal, valores como 1016.2 podem aparecer como texto; ao importar, defina a localidade da coluna como inglês (Estados Unidos). O método completo está em enviando dados do Arduino para o Excel.
Estação meteorológica com Wi-Fi usando o ESP32
Se você quer ver as leituras no celular, pode ligar os mesmos sensores a um ESP32. Esta versão troca o LCD por uma página web servida pelo ESP32: abra o endereço IP mostrado no Monitor Serial em um celular na mesma rede Wi-Fi e os valores aparecem, com a página se atualizando sozinha a cada 30 segundos. O endereço /json devolve os mesmos dados em um formato que outros programas conseguem ler. Os pinos do ESP32 trabalham com 3,3 V: alimente os sensores pelo 3V3 e use para as entradas analógicas os pinos ADC1 (GPIO 32–39), que continuam funcionando com o Wi-Fi ligado. O ADC do ESP32 é de 12 bits e lê 0–4095, então você vai precisar medir de novo os limites de chuva.
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 os dados de qualquer lugar, salvá-los no Planilhas Google ou comparar as suas leituras com uma previsão online, veja ESP32 com Google Sheets e API de previsão do tempo no ESP32. O código compila sem mudanças nas versões 2.x e 3.x do core do ESP32, porque só usa funções de WiFi e WebServer que são iguais nas duas.
Posicionando os sensores do jeito certo
- Mantenha o sensor de temperatura na sombra: um DHT22 ao sol pode marcar 5–10 °C acima da temperatura real do ar. Coloque-o em uma caixa branca ventilada ou em um abrigo contra radiação feito de pratos plásticos empilhados.
- Mantenha-o longe das paredes: paredes e caixilhos aquecidos pelo sol empurram a leitura para cima; instale o sensor a pelo menos 30 cm da parede e, se possível, a 1,5–2 m do chão.
- Deixe a eletrônica dentro de casa: o Arduino, o LCD e o BMP280 podem ficar em uma caixa fechada, porque a pressão dentro da caixa é a mesma. Só o DHT22, a placa de chuva e o LDR precisam ficar do lado de fora.
- Instale a placa de chuva inclinada: incline-a 30–45 graus para a água escorrer quando a chuva parar; uma placa plana fica molhada por horas.
- Aponte o LDR para o céu: se um poste ou a luz da varanda iluminar o sensor, a estação vai achar que é dia; coloque-o longe de lâmpadas, virado para cima.
- Cuidado com o comprimento do cabo: o DHT22 aceita bem alguns metros de cabo; se começarem erros de leitura acima de 10 metros, baixe o resistor de pull-up para 4,7 kΩ. O barramento I2C foi feito só para algumas dezenas de centímetros, então mantenha o BMP280 ao lado do Arduino.
Ampliando a estação: ideias de projetos
- Intensidade luminosa: troque o LDR por um BH1750, que mede em lux, e calcule as horas de sol.
- Qualidade do ar: acrescente um sensor de CO2 MH-Z19 a uma estação interna ou um sensor de poeira PMS5003 a uma externa.
- Horários de verdade: use um módulo RTC para gravar data e hora no registro e anotar a máxima e a mínima do dia a cada meia-noite.
- Alertas de geada e estufa: monte um alarme de geada que toca um buzzer abaixo de 2 °C ou uma estufa inteligente que controla a ventilação.
- Energia solar: com um painel pequeno, um módulo de carga TP4056 e uma célula 18650, a estação não precisa mais de tomada; na versão com ESP32, o deep sleep faz a bateria durar semanas.
- Vento e chuva: conte a velocidade do vento com um anemômetro de reed switch e a chuva em milímetros com um pluviômetro de báscula.
Erros comuns e como resolver
| Sintoma | Causa provável | Solução |
|---|---|---|
| O LCD só mostra blocos cheios | Ajuste de contraste ou endereço I2C errado | Gire o trimpot azul atrás do adaptador e tente 0x3F em vez de 0x27 |
| O display mostra nan | O DHT22 não é lido: ligação, pull-up ou leitura com intervalo menor que 2 segundos | Confira o fio de dados e o resistor de 10 kΩ; o código mantém o valor antigo quando a leitura falha |
| A pressão é nan ou nunca muda | BMP280 não encontrado: endereço 0x77 ou módulo de 3,3 V alimentado errado | Tente begin(0x77) e alimente o módulo com a tensão certa |
| A pressão fica 80–100 hPa abaixo da previsão | Altitude não informada, então aparece a pressão local | Atualize ALTITUDE_M com a sua altitude real |
| A temperatura fica alta demais durante o dia | O sensor está no sol ou esquentando dentro da caixa | Use um abrigo na sombra e ventilado |
| Porcentagem de chuva alta mesmo com tempo seco | A placa está suja, com orvalho ou mal calibrada | Limpe a placa, meça de novo o RAIN_DRY e suba o limite RAIN_ON |
| O display mostra SD:off | Sem cartão, cartão em exFAT ou módulo alimentado com 3,3 V | Formate um cartão de até 32 GB em FAT32 e ligue o módulo no 5V |
| Ao amanhecer, alterna entre Day e Night | Os limites estão próximos demais | Deixe pelo menos 100 unidades entre DAY_LEVEL e NIGHT_LEVEL |
Esta estação junta quase tudo o que você aprendeu no Arduino: leituras digitais e analógicas, os barramentos I2C e SPI, multitarefa com millis, cálculos e registro de dados. Faça cada sensor funcionar sozinho primeiro, depois junte as partes e só então coloque tudo na caixa. No app BlueGrays você encontra medição de temperatura e umidade com DHT11, leitura de luz com LDR, medição com ESP32 e DHT22 em LCD, um registrador de temperatura que grava em SD e uma estação meteorológica com display de matriz de pontos, cada um com esquema de ligação passo a passo e código pronto.
Perguntas frequentes
Como fazer uma estação meteorológica com Arduino?
Ligue a um Arduino Uno um DHT22 para temperatura e umidade, um BMP280 para pressão, um sensor de chuva e um LDR para a luz, mostre os valores em um LCD I2C e, se quiser, grave-os em um cartão SD. Teste cada sensor sozinho primeiro e depois junte tudo em um único sketch. Manter os sensores na sombra e em uma caixa ventilada é a condição mais importante para leituras precisas.
Qual é melhor para uma estação meteorológica, DHT22 ou BME280?
O DHT22 é um pouco mais preciso na temperatura, com ±0,5 °C, mas só pode ser lido a cada 2 segundos; o BME280 junta temperatura, umidade e pressão em um único chip I2C. Se você quer menos fios e pinos, um BME280 sozinho basta. Este projeto usa os dois porque o DHT22 fica do lado de fora, enquanto o BMP280 pode ficar dentro da caixa.
Por que a pressão do meu BMP280 é menor que a da previsão do tempo?
O sensor mede a pressão local na sua altitude, enquanto os sites de previsão informam a pressão reduzida ao nível do mar. A pressão cai cerca de 12 hPa a cada 100 metros de altitude. Coloque a sua altitude na constante ALTITUDE_M e a seaLevelForAltitude() deixa o valor comparável.
Uma estação meteorológica com Arduino consegue prever chuva?
Ela não dá uma previsão exata, mas a tendência da pressão é uma boa pista: uma queda de mais de 1,6 hPa em 3 horas costuma indicar nuvens e chuva chegando, enquanto uma subida aponta para céu limpo. O sensor de chuva também pega o momento em que a chuva começa. Juntos, formam um sistema de aviso simples, mas útil.
Por que o sensor de chuva corrói e como evitar?
Quando as trilhas da placa ficam alimentadas o tempo todo, ocorre eletrólise enquanto estão molhadas e o metal se desgasta rápido. Ligar o VCC do módulo a um pino digital e alimentar a placa só durante a medição faz ela durar muitas vezes mais. Instalá-la inclinada, para secar rápido depois da chuva, também retarda a corrosão.
Quanto tempo uma estação meteorológica com Arduino dura com bateria?
Um Arduino Uno com a luz de fundo do LCD e os sensores consome cerca de 70–90 mA, então um power bank de 2000 mAh o mantém funcionando por cerca de um dia. Desligar a luz de fundo aumenta esse tempo, mas para longa duração com bateria um ESP32 com deep sleep é muito mais adequado. Você pode calcular a autonomia do seu circuito com a calculadora de duração de bateria.
Projetos para montar depois desta leitura
Ver todos os projetos
Temperatura e umidade com DHT11
Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

Medição da intensidade da luz com LDR
Quer ver a luminosidade do seu quarto em números? O LDR, um pequeno componente sensível à luz, mede a luz ambiente, e o Arduino exibe o valor na tela do computador a cada meio segundo.

Relógio, calendário e estação meteorológica de matriz de pontos (MAX7219, DS1307)
Um painel com texto em rolagem para sua mesa ou parede que mostra, em sequência, a hora, a data e as condições do ambiente.

Temperatura e umidade com ESP32 e DHT22 (com display LCD)
Este projeto mede a temperatura e a umidade do ambiente com um sensor DHT22 e exibe os dados em tempo real em um LCD I2C 16x2. Os dados são lidos do sensor pelo protocolo de um fio (one-wire) com a biblioteca Adafruit DHT. Este projeto serve de base para estações meteorológicas IoT, automação residencial ou sistemas de monitoramento ambiental em estufas. A comunicação com o DHT22 é feita pelo pino GPIO 4 do ESP32.

Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Monte um registrador de temperatura com data e hora usando ESP32. O DHT22 mede a temperatura e a umidade a cada minuto, o DS1307 RTC fornece a hora real e cada leitura é gravada em CSV no cartão microSD. O OLED mostra em letras grandes a temperatura atual, além da umidade, da data e hora e do total de registros. Abra o arquivo /temp_log.csv no Excel, no Google Sheets ou com pandas para acompanhar uma estufa ou a temperatura de casa.

ESP32 HTTPClient + API de clima (com display LCD)
Neste projeto, usamos o ESP32 para fazer uma chamada REST à API de clima wttr.in pela internet com HTTPClient.h. Interpretamos a resposta JSON com ArduinoJson v7 e mostramos cidade, temperatura, umidade, condições do tempo e vento em um display LCD I2C, em turco e inglês. O wttr.in é grátis e não exige chave de API — basta informar o nome de uma cidade para consultar o clima atual. Os dados se atualizam sozinhos a cada 30 minutos, e o LED dá um retorno visual diferente para cada tela.

Medição de temperatura com NTC e display LCD 2x16
Meça a temperatura ao seu redor com um sensor que parece uma pequena conta. Esse componente, chamado NTC, deixa a eletricidade passar com mais facilidade à medida que aquece; o Arduino lê essa…

Uso do display LCD com I2C
Dê ao seu Arduino um display próprio e faça-o escrever sua primeira mensagem. O display LCD de duas linhas é conectado com poucos fios; primeiro aparece uma saudação na linha de cima, depois uma…
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

