Ratgeber · 10 Min. Lesezeit

Wetterstation Arduino: DHT22, BMP280, Regensensor und LCD

Wetterstation mit Arduino bauen: DHT22 für Temperatur und Feuchte, BMP280 für Luftdruck, Regensensor, LDR, I2C-Adressen, LCD-Seiten und SD-Datenlogger.

Eine Wetterstation mit Arduino ist eines der schönsten Lernprojekte: Mit ein paar günstigen Sensoren misst du Temperatur, Luftfeuchtigkeit, Luftdruck und Regen auf deinem Balkon oder im Garten und zeigst die Werte auf einem Display an. In dieser Anleitung schließt du an einen Arduino Uno einen DHT22 (Temperatur und Feuchte), einen BMP280 (Luftdruck), einen Regensensor und einen LDR zur Unterscheidung von Tag und Nacht an und zeigst die Werte auf einem 16x2-I2C-LCD in Seiten an, die alle paar Sekunden wechseln. Mit einem zusätzlichen microSD-Modul schreibt die Station jede Stunde eine Zeile ins Log; nach ein paar Tagen kannst du die Daten in Excel als Diagramm darstellen.

Das Projekt liest aber nicht nur Sensoren aus: Wir rechnen den gemessenen Druck anhand deiner Höhe auf Meereshöhe um, damit er mit den Werten von Wetterseiten vergleichbar wird, berechnen aus Temperatur und Feuchte den Taupunkt und sagen aus der Druckänderung der letzten drei Stunden voraus, ob das Wetter umschlägt. Der Reihe nach folgen Anschluss- und I2C-Adresstabelle, Aufbau Schritt für Schritt, der komplette Code, die Rechnungen, das stündliche Logging, eine WLAN-Version mit dem ESP32, die richtige Platzierung im Freien und häufige Fehler.

DHT22 Temperatur- und Feuchtesensor
DHT22 (AM2302): misst Temperaturen von -40 bis 80 °C auf ±0,5 °C genau sowie die Luftfeuchtigkeit; er ist der Hauptsensor der Station.

Was misst eine Arduino-Wetterstation?

Jeder Sensor wurde gewählt, weil er genau eine Aufgabe am besten erledigt. Der DHT22 liefert Temperatur und relative Luftfeuchtigkeit über eine einzige Datenleitung und ist deutlich genauer als der DHT11. Der BMP280 misst den Luftdruck in Hektopascal (hPa) auf ±1 hPa genau; eine Druckänderung ist der zuverlässigste Vorbote von Regen. Die Platine des Regensensors liefert einen Analogwert, der sinkt, je nasser sie wird. Der LDR ist ein einfacher Fotowiderstand, dessen Widerstand sich mit dem Licht ändert, und reicht aus, um Tag und Nacht zu unterscheiden. Angezeigt wird alles auf dem I2C-LCD; Display und BMP280 teilen sich dieselben zwei Leitungen (SDA und SCL).

MessgrößeSensorBereich und GenauigkeitAnschluss
Temperatur und FeuchteDHT22 (AM2302)-40…80 °C ±0,5 °C; 0–100 % ±2–5 %Eine Datenleitung (D2)
LuftdruckBMP280300–1100 hPa, ±1 hPaI2C (A4, A5)
RegenFC-37 / YL-83 Platine und LM393-ModulNässe in Prozent (im Code kalibriert)Analog A0, Versorgung über D7
Tag / NachtLDR (GL5528) und 10-kΩ-WiderstandGrobe HelligkeitAnalog A1
Display16x2-LCD mit I2C-Modul (PCF8574)2 Zeilen × 16 ZeichenI2C (A4, A5)
Logging (optional)microSD-KartenmodulFAT32, CSV-DateiSPI (D10–D13)

Materialliste

  • Arduino Uno (ein Arduino Nano funktioniert mit denselben Pins)
  • DHT22-Modul (drei Pins, Pull-up-Widerstand auf der Platine) oder ein DHT22 mit vier Beinchen und ein 10-kΩ-Widerstand
  • BMP280-Modul (am besten die 5-V-Version mit Spannungsregler) oder ein BME280, der auch die Feuchte misst
  • Platine des Regensensors und LM393-Komparatormodul
  • LDR und 10-kΩ-Widerstand
  • 16x2-LCD mit aufgelötetem I2C-Modul
  • microSD-Kartenmodul mit Spannungsregler und eine Karte bis 32 GB im FAT32-Format (optional)
  • Steckbrett, Jumperkabel und ein 5-V-USB-Netzteil mit mindestens 1 A
BMP280
BMP280
Regensensor
Regensensor
LDR
LDR
I2C 16x2 LCD
I2C 16x2 LCD
MicroSD-Kartenmodul
MicroSD-Kartenmodul

Schaltplan: Pintabelle und I2C-Adressen

Die wichtigste Idee der Schaltung ist der gemeinsame I2C-Bus: LCD und BMP280 hängen parallel an denselben Pins SDA (A4) und SCL (A5), und der Arduino spricht beide über unterschiedliche Adressen an. Das SD-Modul nutzt den SPI-Bus (D10–D13) und kommt dem I2C daher nicht in die Quere. Den VCC-Pin des Regenmoduls verbinden wir nicht direkt mit 5V, sondern mit D7: Der Code versorgt die Platine nur für ein paar Millisekunden während der Messung, was die Korrosion stark bremst. Wie der I2C-Bus funktioniert, erklären wir in Was ist I2C?.

Bauteil und PinArduino UnoESP32 (WLAN-Version)
DHT22 VCC / GND5V / GND3V3 / GND
DHT22 DATAD2GPIO 4
BMP280 VCC3.3V (6-polig) oder 5V (mit Regler)3V3
BMP280 SDA / SCLA4 / A5GPIO 21 / GPIO 22
I2C-Modul des LCD VCC / SDA / SCL5V / A4 / A5Nicht genutzt (Webseite)
Regenmodul VCCD7 (nur während der Messung)GPIO 25
Regenmodul AOA0GPIO 34 (ADC1)
LDR und 10-kΩ-SpannungsteilerLDR an 5V, 10 kΩ an GND, Mittelpunkt an A1LDR an 3V3, 10 kΩ an GND, Mittelpunkt an GPIO 35
SD-Modul CS / MOSI / MISO / SCKD10 / D11 / D12 / D13Nicht genutzt
SD-Modul VCC5V—
I2C-GerätStandardadresseHinweis
I2C-Modul des LCD (PCF8574T)0x27Mit den Lötbrücken 0x20–0x27
I2C-Modul des LCD (PCF8574AT)0x3FMit den Lötbrücken 0x38–0x3F
BMP280 (lila Module)0x760x77, wenn der SDO-Pin an 3,3 V liegt
BMP280 (Adafruit-Platine)0x770x76, wenn SDO an GND liegt
BME280 (statt BMP280)0x76 oder 0x77Chip-ID 0x60; beim BMP280 0x58
RTC DS3231 / DS1307 (optional)0x68Das EEPROM des DS3231-Moduls liegt auf 0x57
Die meisten lila BMP280-Module mit 6 Pins haben keinen Spannungsregler; der Chip verträgt höchstens 3,6 V, versorge sie also über den 3.3V-Pin des Uno. Module mit 4 Pins und kleinem Regler dürfen an 5V. Bist du dir bei den Adressen unsicher, lass zuerst den I2C-Scanner aus dem Artikel I2C-LCD laufen: Du solltest zwei Adressen sehen, etwa 0x27 und 0x76. In der ESP32-Version darfst du den LDR-Spannungsteiler nie an 5V hängen; die Analogpins des ESP32 vertragen nicht mehr als 3,3 V.

Bibliotheken installieren

  1. Öffne in der Arduino IDE den Bibliotheksverwalter und installiere LiquidCrystal I2C (Frank de Brabander).
  2. Suche nach Adafruit BMP280 Library; fragt die IDE nach Abhängigkeiten, wähle Install all, damit auch Adafruit Unified Sensor und Adafruit BusIO installiert werden.
  3. Installiere die DHT sensor library (Adafruit).
  4. Die Bibliotheken SD und SPI sind in der Arduino IDE enthalten und müssen nicht installiert werden. Details zur Installation findest du unter Arduino-Bibliotheken hinzufügen.

Aufbau Schritt für Schritt

  1. Zuerst den I2C-Bus aufbauen: LCD und BMP280 an A4 und A5 anschließen, den I2C-Scanner starten und die beiden Adressen notieren.
  2. DHT22 ergänzen: Den Datenpin an D2 anschließen. Beim nackten Sensor mit vier Beinchen gehört ein 10-kΩ-Pull-up zwischen Daten und VCC.
  3. Regensensor anschließen: Platine mit dem Modul verbinden, VCC des Moduls an D7 und AO an A0. Miss die Werte bei trockener und nasser Platine und trage sie in die Konstanten RAIN_DRY und RAIN_WET im Code ein.
  4. LDR-Spannungsteiler aufbauen: Ein Bein des LDR an 5V, das andere an A1, dazu einen 10-kΩ-Widerstand von A1 nach GND. Je heller es ist, desto höher der Messwert.
  5. SD-Modul ergänzen: Mit 5V versorgen und CS an D10, MOSI an D11, MISO an D12, SCK an D13 anschließen. Ohne Karte läuft die Station ohne Logging weiter.
  6. Höhe eintragen: Ermittle die Höhe deines Standorts über dem Meeresspiegel und trage sie in die Konstante ALTITUDE_M ein; davon hängt die Genauigkeit der Druckberechnung ab.

Code der Wetterstation: wechselnde Seiten und stündliches SD-Logging

Der folgende Code fügt alle Teile zusammen. Die Sensoren werden alle 5 Sekunden gelesen, das Display wechselt alle 4 Sekunden zwischen drei Seiten, und bei eingelegter SD-Karte wird beim Start einmal und danach jede Stunde eine Zeile gespeichert. Da millis() statt delay() verwendet wird, warten die drei Aufgaben nicht aufeinander. Die Displaytexte sind kurze englische Abkürzungen: T Temperatur, H Feuchte, Dew pt Taupunkt und P Luftdruck.

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}
Konstante oder FunktionAufgabe
ALTITUDE_MHöhe; zum Umrechnen des gemessenen Drucks auf Meereshöhe
RAIN_DRY / RAIN_WETDie selbst gemessenen Analogwerte bei trockener und nasser Platine
RAIN_ON / RAIN_OFFSchwellen (%) für Regenbeginn und Regenende; der Abstand dazwischen ist die Hysterese
DAY_LEVEL / NIGHT_LEVELTag- und Nachtschwelle des LDR; der Bereich dazwischen verhindert Flackern in der Dämmerung
readRain()Versorgt die Platine über D7, mittelt 4 Messungen, schaltet die Versorgung ab und rechnet in Prozent um
calcDewPoint()Berechnet den Taupunkt mit der Magnus-Formel
takeForcedMeasurement()Lässt den BMP280 eine Einzelmessung machen; vermeidet die Eigenerwärmung im Dauerbetrieb
history[4] und trend3h()Speichern die stündlichen Druckwerte und liefern die Änderung der letzten 3 Stunden
logHourly()Verschiebt die Druckhistorie und hängt eine CSV-Zeile an die SD-Karte

Die Rechnungen: Luftdruck auf Meereshöhe, Taupunkt und Drucktendenz

Der BMP280 misst den örtlichen Luftdruck an deinem Standort, und der sinkt mit der Höhe: Was auf Meereshöhe um 1013 hPa liegt, sind in 850 Metern Höhe etwa 915 hPa und in München auf rund 520 Metern etwa 950 hPa. Wetterdienste geben den Druck jeder Station dagegen auf Meereshöhe reduziert an. Diese Umrechnung übernimmt die Funktion seaLevelForAltitude() im Code: P0 = P / (1 − h / 44330)^5,255. Für 915 hPa in 850 Metern ergibt sich 1 − 850 / 44330 = 0,9808 und 0,9808^5,255 ≈ 0,903; 915 / 0,903 ≈ 1013 hPa. Liegst du bei der Höhe um 10 Meter daneben, verschiebt sich das Ergebnis um etwa 1,2 hPa, also nimm die Höhe so genau wie möglich aus einer Karte oder vom GPS.

Der Taupunkt ist die Temperatur, bei der Luft beim Abkühlen zu kondensieren beginnt, und als Behaglichkeitsmaß aussagekräftiger als die relative Feuchte: Bis 13 °C fühlt sich die Luft angenehm an, über 16 °C schwül und über 20 °C drückend. Der Code nutzt die Magnus-Formel: γ = ln(rF / 100) + 17,62·T / (243,12 + T) und Td = 243,12·γ / (17,62 − γ). Für 24 °C und 50 % Feuchte ergibt sich γ ≈ 0,890 und Td ≈ 12,9 °C. Nähert sich die Nachttemperatur dem Taupunkt, ist am Morgen mit Nebel oder Tau zu rechnen; liegt der Taupunkt unter 0 °C, bildet sich statt Tau Reif, ein guter Auslöser für einen Frostalarm.

Das nützlichste Vorhersagewerkzeug ist aber die Drucktendenz: Die Änderung über 3 Stunden sagt viel mehr als der Druck selbst. Der Code speichert den Druck jede Stunde in einem Array; sobald vier Werte da sind, also 3 Stunden nach dem Einschalten, zeigt er die Differenz zwischen dem neuesten und dem 3 Stunden alten Wert an und schreibt bei einem Fall um mehr als 1,6 hPa Falling, bei einem Anstieg Rising. Die in der Meteorologie übliche Einteilung sieht so aus.

Druckänderung in 3 StundenKlasseWas bedeutet das meistens?
Weniger als 0,1 hPaGleichbleibendDas aktuelle Wetter bleibt
0,1–1,5 hPaLangsam steigend / fallendKleine Änderung; beim Fallen kann es sich bewölken
1,6–3,5 hPaSteigend / fallendFallend: Regenwahrscheinlichkeit steigt; steigend: es klart auf
3,6–6 hPaSchnell steigend / fallendFallend: windiges, nasses Wetter zieht auf
Mehr als 6 hPaSehr schnellSturm; ein sehr abrupter Wetterumschwung

Stündliches Logging auf SD-Karte und Diagramme in Excel

Ist eine SD-Karte eingelegt, legt die Station im Hauptverzeichnis die Datei WEATHER.CSV an, schreibt die Spaltenüberschriften in die erste Zeile und hängt dann jede Stunde eine Zeile an. Die SD-Bibliothek des Arduino akzeptiert nur Dateinamen im 8+3-Format, deshalb ist der Name kurz. Weil die Datei nach jedem Eintrag geschlossen wird, geht bei einem Stromausfall höchstens die letzte Zeile verloren. Der Uno hat keine echte Uhr, deshalb steht in der ersten Spalte die Zahl der Minuten seit dem Einschalten; für Datum und Uhrzeit ergänzt du ein RTC-Modul und nimmst den Zeitstempel von dort. Kartenwahl und Formatierung findest du im Artikel zum SD-Kartenmodul.

minutestemp_chum_pctpress_hpadew_crain_pctlight
021.4581016.212.80day
6020.8611015.113.00day
12018.9721013.413.734night

Im Beispiel oben ist der Druck in zwei Stunden um 2,8 hPa gefallen, und beim dritten Eintrag hat der Regen eingesetzt; hier siehst du, wie die Tendenz den Regen ankündigt. Öffne die Datei am Rechner in Excel oder Google Tabellen und stelle die Spalten für Druck und Temperatur als Liniendiagramm dar. Ein deutsches Excel erwartet ein Komma als Dezimaltrennzeichen, deshalb erscheinen Werte wie 1016.2 womöglich als Text oder als Datum; stelle beim Import das Gebietsschema der Spalte auf Englisch (USA) um. Die genaue Vorgehensweise steht in Arduino-Daten nach Excel übertragen.

Dieser Code belegt etwa 61 % der 2 KB RAM des Arduino Uno und 76 % seiner 32 KB Programmspeicher; den größten Teil des RAM beansprucht der 512-Byte-Puffer der SD-Bibliothek. Feste Texte in F("...") zu schreiben, spart RAM. Meldet die IDE beim Erweitern "Low memory available", kannst du das SD-Logging abschalten oder die Station auf einen Arduino Mega oder einen ESP32 mit mehr Speicher umziehen; Details unter Arduino-Speicher reicht nicht.

WLAN-Wetterstation mit dem ESP32

Willst du die Messwerte auf dem Handy sehen, kannst du dieselben Sensoren an einen ESP32 anschließen. In dieser Version ersetzt eine Webseite, die der ESP32 selbst ausliefert, das LCD: Öffne auf einem Handy im selben WLAN die im seriellen Monitor angezeigte IP-Adresse, dann erscheinen die Werte, und die Seite aktualisiert sich alle 30 Sekunden selbst. Unter /json gibt es dieselben Daten in einer Form, die andere Programme lesen können. Die Pins des ESP32 arbeiten mit 3,3 V: Versorge die Sensoren aus 3V3 und nutze für die Analogeingänge die ADC1-Pins (GPIO 32–39), die auch bei eingeschaltetem WLAN funktionieren. Der ADC des ESP32 hat 12 Bit und liefert 0–4095, deshalb musst du die Regenschwellen neu messen.

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}

Um die Daten von überall zu sehen, in Google Tabellen zu speichern oder deine Messwerte mit der Vorhersage aus dem Internet zu vergleichen, sieh dir ESP32 mit Google Sheets und Wetter-API mit dem ESP32 an. Der Code lässt sich ohne Änderung mit den Versionen 2.x und 3.x des ESP32-Cores kompilieren, weil er nur WiFi- und WebServer-Funktionen nutzt, die in beiden gleich sind.

Die Sensoren richtig platzieren

  • Temperatursensor in den Schatten: Ein DHT22 in der Sonne kann 5–10 °C mehr anzeigen als die echte Lufttemperatur. Setze ihn in eine belüftete weiße Box oder in eine Wetterhütte aus übereinandergestapelten Kunststofftellern.
  • Abstand zur Wand: Von der Sonne aufgeheizte Wände und Fensterrahmen treiben den Messwert nach oben; montiere den Sensor mindestens 30 cm von der Wand entfernt und möglichst 1,5–2 m über dem Boden.
  • Elektronik bleibt drinnen: Arduino, LCD und BMP280 dürfen in einem geschlossenen Gehäuse sitzen, denn der Luftdruck ist dort derselbe. Nur DHT22, Regenplatine und LDR müssen nach draußen.
  • Regenplatine schräg montieren: Mit 30–45 Grad Neigung läuft das Wasser ab, wenn der Regen aufhört; eine waagerechte Platine bleibt stundenlang nass.
  • LDR zum Himmel richten: Fällt das Licht einer Straßen- oder Balkonlampe auf den LDR, hält die Station die Nacht für den Tag; montiere ihn fern von Lampen und nach oben gerichtet.
  • Auf die Kabellänge achten: Der DHT22 arbeitet mit einigen Metern Kabel problemlos; treten ab 10 Metern Lesefehler auf, senke den Pull-up auf 4,7 kΩ. Der I2C-Bus ist nur für wenige Dutzend Zentimeter gedacht, lass den BMP280 also direkt beim Arduino.

Die Station erweitern: Projektideen

  • Lichtstärke: Ersetze den LDR durch einen BH1750, der in Lux misst, und berechne die Sonnenstunden.
  • Luftqualität: Ergänze die Innenstation um einen MH-Z19-CO2-Sensor und die Außenstation um einen PMS5003-Feinstaubsensor.
  • Echte Zeitstempel: Schreibe mit einem RTC-Modul Datum und Uhrzeit ins Log und speichere jede Mitternacht Höchst- und Tiefstwert des Tages.
  • Frost- und Gewächshauswarnung: Baue einen Frostalarm, der unter 2 °C einen Summer auslöst, oder ein smartes Gewächshaus, das die Lüftung steuert.
  • Solarbetrieb: Mit einem kleinen Solarpanel, einem TP4056-Lademodul und einer 18650-Zelle wird die Station steckdosenunabhängig; in der ESP32-Version hält der Akku mit Deep Sleep wochenlang.
  • Wind und Niederschlagsmenge: Zähle die Windgeschwindigkeit mit einem Reed-Kontakt-Anemometer und den Niederschlag in Millimetern mit einem Kippwaagen-Regenmesser.

Häufige Fehler und Lösungen

SymptomWahrscheinliche UrsacheLösung
Das LCD zeigt nur volle KästchenKontrast falsch eingestellt oder falsche I2C-AdresseAm blauen Trimmer auf der Rückseite drehen und 0x3F statt 0x27 probieren
Auf dem Display steht nanDHT22 nicht lesbar: Verkabelung, Pull-up oder Abfragen öfter als alle 2 SekundenDatenleitung und 10-kΩ-Widerstand prüfen; der Code behält bei Fehlmessung den alten Wert
Druck ist nan oder ändert sich nieBMP280 nicht gefunden: Adresse 0x77 oder 3,3-V-Modul falsch versorgtbegin(0x77) probieren und das Modul mit der richtigen Spannung versorgen
Druck liegt 80–100 hPa unter dem WetterberichtKeine Höhe eingetragen, angezeigt wird der örtliche DruckALTITUDE_M auf deine echte Höhe setzen
Tagsüber viel zu hohe TemperaturSensor steht in der Sonne oder heizt sich im Gehäuse aufSchattige, belüftete Wetterhütte verwenden
Hoher Regenwert auch bei trockenem WetterPlatine verschmutzt, betaut oder falsch kalibriertPlatine reinigen, RAIN_DRY neu messen, RAIN_ON-Schwelle anheben
Das Display zeigt SD:offKeine Karte, exFAT-formatiert oder Modul an 3,3 VKarte bis 32 GB mit FAT32 formatieren, Modul an 5V anschließen
Pendelt in der Dämmerung zwischen Day und NightDie Schwellen liegen zu dicht beieinanderMindestens 100 Stufen Abstand zwischen DAY_LEVEL und NIGHT_LEVEL lassen
Um plötzliche Sprünge im Log zu glätten, kannst du in jede Stundenzeile statt einer Einzelmessung den Mittelwert der letzten 12 Messungen schreiben; gleitenden Mittelwert und Medianfilter findest du unter Sensordaten filtern.

Diese Station vereint fast alles, was du am Arduino gelernt hast: digitale und analoge Messungen, I2C- und SPI-Bus, Multitasking mit millis, Berechnungen und Datenlogging. Bring zuerst jeden Sensor einzeln zum Laufen, füge dann die Teile zusammen und baue erst am Ende alles ins Gehäuse. In der BlueGrays-App findest du Temperatur- und Feuchtemessung mit dem DHT11, Lichtmessung mit dem LDR, Messung mit ESP32 und DHT22 am LCD, einen Temperaturlogger mit SD-Karte und eine Wetterstation mit Punktmatrix-Anzeige, jeweils mit Schritt-für-Schritt-Schaltplan und fertigem Code.

Häufige Fragen

Wie baue ich eine Wetterstation mit Arduino?

Du schließt an einen Arduino Uno einen DHT22 für Temperatur und Feuchte, einen BMP280 für den Luftdruck, einen Regensensor und einen LDR für das Licht an, zeigst die Werte auf einem I2C-LCD an und speicherst sie auf Wunsch auf einer SD-Karte. Teste zuerst jeden Sensor einzeln und führe sie dann in einem Sketch zusammen. Die wichtigste Voraussetzung für genaue Werte ist ein schattiger, belüfteter Platz für die Sensoren.

DHT22 oder BME280: Was ist besser für eine Wetterstation?

Der DHT22 ist bei der Temperatur mit ±0,5 °C etwas genauer, lässt sich aber nur alle 2 Sekunden abfragen; der BME280 vereint Temperatur, Feuchte und Luftdruck in einem I2C-Chip. Willst du weniger Kabel und Pins, reicht ein BME280 allein. Dieses Projekt nutzt beide, weil der DHT22 draußen sitzt und der BMP280 im Gehäuse bleiben kann.

Warum zeigt der BMP280 weniger Luftdruck an als der Wetterbericht?

Der Sensor misst den örtlichen Druck auf deiner Höhe, Wetterdienste geben dagegen den auf Meereshöhe reduzierten Druck an. Pro 100 Meter Höhe sinkt der Druck um etwa 12 hPa. Trägst du deine Höhe in die Konstante ALTITUDE_M ein, macht seaLevelForAltitude() den Wert vergleichbar.

Kann eine Arduino-Wetterstation Regen vorhersagen?

Eine genaue Vorhersage schafft sie nicht, aber die Drucktendenz ist ein guter Hinweis: Ein Fall um mehr als 1,6 hPa in 3 Stunden kündigt meist Wolken und Regen an, ein Anstieg dagegen Aufklaren. Der Regensensor erkennt zusätzlich den Moment, in dem der Regen einsetzt. Zusammen ergeben beide ein einfaches, aber nützliches Warnsystem.

Warum korrodiert der Regensensor und wie verhindere ich das?

Liegt dauerhaft Spannung an den Leiterbahnen, entsteht bei Nässe Elektrolyse und das Metall trägt sich schnell ab. Verbindest du VCC des Moduls mit einem Digitalpin und versorgst die Platine nur während der Messung, hält sie ein Vielfaches länger. Eine schräge Montage, bei der die Platine nach dem Regen schnell trocknet, bremst die Korrosion zusätzlich.

Wie lange läuft eine Arduino-Wetterstation mit Akku?

Ein Arduino Uno mit LCD-Hintergrundbeleuchtung und Sensoren zieht etwa 70–90 mA; eine Powerbank mit 2000 mAh hält das etwa einen Tag lang durch. Abgeschaltete Hintergrundbeleuchtung verlängert die Laufzeit, für langen Akkubetrieb ist aber ein ESP32 mit Deep Sleep deutlich besser geeignet. Die Laufzeit deiner Schaltung berechnest du mit dem Akkulaufzeit-Rechner.

Alle Projekte ansehen
Temperatur und Luftfeuchtigkeit mit DHT11
AR-55Mittel

Temperatur und Luftfeuchtigkeit mit DHT11

Wie warm ist dein Zimmer, und ist die Luft feucht oder trocken? Der DHT11-Sensor misst Temperatur und Luftfeuchtigkeit, und der Arduino schreibt die Werte auf ein zweizeiliges LCD und aktualisiert…

4.7(47)
83
Lichtstärke messen mit LDR
AR-11Anfänger

Lichtstärke messen mit LDR

Willst du sehen, wie hell dein Zimmer ist, und zwar als Zahl? Der LDR, ein kleines lichtempfindliches Bauteil, misst das Umgebungslicht, und der Arduino schreibt den Wert jede halbe Sekunde auf…

4.6(83)
143
Punktmatrix-Uhr, Kalender und Wetterstation (MAX7219, DS1307)
AR-85Mittel
Premium

Punktmatrix-Uhr, Kalender und Wetterstation (MAX7219, DS1307)

Eine Laufschrift-Tafel für Tisch oder Wand, die abwechselnd Uhrzeit, Datum und das Raumklima zeigt.

5.0(50)
66
ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
ES-15Mittel

ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)

Bei diesem Projekt werden die Umgebungstemperatur und die Luftfeuchtigkeit mit einem DHT22-Sensor gemessen und in Echtzeit auf einem 16x2 I2C-LCD angezeigt. Mithilfe der Adafruit-DHT-Bibliothek werden die Daten über das One-Wire-Protokoll vom Sensor ausgelesen. Dieses Projekt bildet die Grundlage für IoT-Wetterstationen, Smart-Home-Automatisierung oder Umgebungsüberwachungssysteme in Gewächshäusern. Die Kommunikation mit dem DHT22 erfolgt über den GPIO-4-Pin des ESP32.

4.8(38)
57
ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Fortgeschritten
Premium

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)

Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.

4.7(7)
12
ESP32 HTTPClient + Wetter-API (mit LCD-Display)
ES-31Fortgeschritten
Premium

ESP32 HTTPClient + Wetter-API (mit LCD-Display)

Der ESP32 ruft über das Internet mit HTTPClient.h eine Wetter-API (wttr.in) per REST auf. Die JSON-Antwort wird mit ArduinoJson v7 ausgewertet; Stadt, Temperatur, Luftfeuchtigkeit, Wetterlage und Wind erscheinen auf einem I2C-LCD. wttr.in braucht keinen API-Schlüssel, du gibst einfach den Namen einer beliebigen Stadt ein.

4.7(13)
20
Temperaturmessung mit NTC und 2x16 Lcd Display
AR-44Anfänger
Premium

Temperaturmessung mit NTC und 2x16 Lcd Display

Miss die Umgebungstemperatur mit einem Sensor, der aussieht wie eine kleine Perle.

4.5(33)
44
Verwendung des LCD-Bildschirms mit I2C
AR-32Anfänger
Premium

Verwendung des LCD-Bildschirms mit I2C

Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.

4.8(53)
70