Guias · 12 min de leitura

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.

Sensor de temperatura e umidade DHT22
DHT22 (AM2302): mede temperatura de -40 a 80 °C com ±0,5 °C, além da umidade; é o sensor principal da estação.

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).

MedidaSensorFaixa e precisãoLigação
Temperatura e umidadeDHT22 (AM2302)-40…80 °C ±0,5 °C; 0–100 % ±2–5 %Linha de dados única (D2)
Pressão do arBMP280300–1100 hPa, ±1 hPaI2C (A4, A5)
ChuvaPlaca FC-37 / YL-83 e módulo LM393Porcentagem de umidade da placa (calibrada no código)Analógico A0, alimentação pelo D7
Dia / noiteLDR (GL5528) e resistor de 10 kΩNível de luz aproximadoAnalog A1
DisplayLCD 16x2 com adaptador I2C (PCF8574)2 linhas × 16 caracteresI2C (A4, A5)
Registro (opcional)Módulo de cartão microSDFAT32, arquivo CSVSPI (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
BMP280
BMP280
Sensor de chuva
Sensor de chuva
LDR
LDR
I2C 16x2 LCD
I2C 16x2 LCD
Módulo de cartão microSD
Módulo de cartão microSD

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 pinoArduino UnoESP32 (versão com Wi-Fi)
DHT22 VCC / GND5V / GND3V3 / GND
DHT22 DATAD2GPIO 4
BMP280 VCC3,3V (6 pinos) ou 5V (com regulador)3V3
BMP280 SDA / SCLA4 / A5GPIO 21 / GPIO 22
VCC / SDA / SCL do adaptador I2C do LCD5V / A4 / A5Não usado (página web)
VCC do módulo de chuvaD7 (só durante a medição)GPIO 25
AO do módulo de chuvaA0GPIO 34 (ADC1)
Divisor com LDR e 10 kΩLDR no 5V, 10 kΩ no GND, ponto do meio no A1LDR no 3V3, 10 kΩ no GND, ponto do meio no GPIO 35
CS / MOSI / MISO / SCK do módulo SDD10 / D11 / D12 / D13Não usado
VCC do módulo SD5V—
Dispositivo I2CEndereço padrãoObservação
Adaptador I2C do LCD (PCF8574T)0x270x20–0x27 com os jumpers de solda
Adaptador I2C do LCD (PCF8574AT)0x3F0x38–0x3F com os jumpers de solda
BMP280 (módulos roxos)0x760x77 se o pino SDO for ligado a 3,3 V
BMP280 (placa da Adafruit)0x770x76 se o SDO for ligado ao GND
BME280 (no lugar do BMP280)0x76 ou 0x77ID do chip 0x60; o do BMP280 é 0x58
RTC DS3231 / DS1307 (opcional)0x68A EEPROM do módulo DS3231 fica no 0x57
A maioria dos módulos BMP280 roxos de 6 pinos não tem regulador; o chip trabalha com no máximo 3,6 V, então alimente-os pelo pino 3,3V do Uno. Módulos de 4 pinos com um pequeno regulador podem ir no 5V. Se não tiver certeza dos endereços, rode primeiro o scanner I2C do artigo LCD I2C: você deve ver dois endereços, como 0x27 e 0x76. Na versão com ESP32, nunca alimente o divisor do LDR com 5V; os pinos analógicos do ESP32 não aguentam mais de 3,3 V.

Instalando as bibliotecas

  1. Abra o Gerenciador de Bibliotecas na Arduino IDE e instale a LiquidCrystal I2C (Frank de Brabander).
  2. 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.
  3. Instale a DHT sensor library (Adafruit).
  4. 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

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

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 ou funçãoO que faz
ALTITUDE_MAltitude; usada para converter a pressão medida para o nível do mar
RAIN_DRY / RAIN_WETOs valores analógicos que você mediu com a placa seca e molhada
RAIN_ON / RAIN_OFFLimites de início e fim de chuva (%); a diferença entre eles é a histerese
DAY_LEVEL / NIGHT_LEVELLimites 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 horasClasseO que costuma significar
Menos de 0,1 hPaEstávelO tempo atual continua
0,1–1,5 hPaSubindo / caindo devagarUma mudança pequena; uma queda pode trazer nuvens
1,6–3,5 hPaSubindo / caindoUma queda aumenta a chance de chuva, uma subida traz céu limpo
3,6–6 hPaSubindo / caindo rápidoUma queda indica tempo de vento e chuva a caminho
Mais de 6 hPaMuito rápidoTempestade; 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.

minutestemp_chum_pctpress_hpadew_crain_pctlight
021,4581016,212,80day
6020,8611015,113,00day
12018,9721013,413,734night

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.

Este código usa cerca de 61 % dos 2 KB de RAM do Arduino Uno e 76 % dos 32 KB de memória de programa; a maior parte da RAM vai para o buffer de 512 bytes da biblioteca SD. Colocar textos fixos dentro de F("...") economiza RAM. Se a IDE avisar "Low memory available" conforme você acrescenta recursos, dá para desligar o registro em SD ou passar a estação para um Arduino Mega ou um ESP32, que têm mais memória; os detalhes estão em pouca memória no Arduino.

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.

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 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

SintomaCausa provávelSolução
O LCD só mostra blocos cheiosAjuste de contraste ou endereço I2C erradoGire o trimpot azul atrás do adaptador e tente 0x3F em vez de 0x27
O display mostra nanO DHT22 não é lido: ligação, pull-up ou leitura com intervalo menor que 2 segundosConfira 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 mudaBMP280 não encontrado: endereço 0x77 ou módulo de 3,3 V alimentado erradoTente begin(0x77) e alimente o módulo com a tensão certa
A pressão fica 80–100 hPa abaixo da previsãoAltitude não informada, então aparece a pressão localAtualize ALTITUDE_M com a sua altitude real
A temperatura fica alta demais durante o diaO sensor está no sol ou esquentando dentro da caixaUse um abrigo na sombra e ventilado
Porcentagem de chuva alta mesmo com tempo secoA placa está suja, com orvalho ou mal calibradaLimpe a placa, meça de novo o RAIN_DRY e suba o limite RAIN_ON
O display mostra SD:offSem cartão, cartão em exFAT ou módulo alimentado com 3,3 VFormate um cartão de até 32 GB em FAT32 e ligue o módulo no 5V
Ao amanhecer, alterna entre Day e NightOs limites estão próximos demaisDeixe pelo menos 100 unidades entre DAY_LEVEL e NIGHT_LEVEL
Para suavizar saltos repentinos no registro, você pode gravar em cada linha de hora em hora a média das últimas 12 leituras em vez de uma leitura única; os filtros de média móvel e de mediana estão em filtrando dados de sensores.

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.

Ver todos os projetos
Temperatura e umidade com DHT11
AR-55Intermediário

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…

4.7(47)
83
Medição da intensidade da luz com LDR
AR-11Iniciante

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.

4.6(83)
143
Relógio, calendário e estação meteorológica de matriz de pontos (MAX7219, DS1307)
AR-85Intermediário
Premium

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.

5.0(50)
66
Temperatura e umidade com ESP32 e DHT22 (com display LCD)
ES-15Intermediário

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.

4.8(38)
57
Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avançado
Premium

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.

4.7(7)
12
ESP32 HTTPClient + API de clima (com display LCD)
ES-31Avançado
Premium

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.

4.7(13)
20
Medição de temperatura com NTC e display LCD 2x16
AR-44Iniciante
Premium

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…

4.5(33)
44
Uso do display LCD com I2C
AR-32Iniciante
Premium

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…

4.8(53)
70