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.

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öße | Sensor | Bereich und Genauigkeit | Anschluss |
|---|---|---|---|
| Temperatur und Feuchte | DHT22 (AM2302) | -40…80 °C ±0,5 °C; 0–100 % ±2–5 % | Eine Datenleitung (D2) |
| Luftdruck | BMP280 | 300–1100 hPa, ±1 hPa | I2C (A4, A5) |
| Regen | FC-37 / YL-83 Platine und LM393-Modul | Nässe in Prozent (im Code kalibriert) | Analog A0, Versorgung über D7 |
| Tag / Nacht | LDR (GL5528) und 10-kΩ-Widerstand | Grobe Helligkeit | Analog A1 |
| Display | 16x2-LCD mit I2C-Modul (PCF8574) | 2 Zeilen × 16 Zeichen | I2C (A4, A5) |
| Logging (optional) | microSD-Kartenmodul | FAT32, CSV-Datei | SPI (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





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 Pin | Arduino Uno | ESP32 (WLAN-Version) |
|---|---|---|
| DHT22 VCC / GND | 5V / GND | 3V3 / GND |
| DHT22 DATA | D2 | GPIO 4 |
| BMP280 VCC | 3.3V (6-polig) oder 5V (mit Regler) | 3V3 |
| BMP280 SDA / SCL | A4 / A5 | GPIO 21 / GPIO 22 |
| I2C-Modul des LCD VCC / SDA / SCL | 5V / A4 / A5 | Nicht genutzt (Webseite) |
| Regenmodul VCC | D7 (nur während der Messung) | GPIO 25 |
| Regenmodul AO | A0 | GPIO 34 (ADC1) |
| LDR und 10-kΩ-Spannungsteiler | LDR an 5V, 10 kΩ an GND, Mittelpunkt an A1 | LDR an 3V3, 10 kΩ an GND, Mittelpunkt an GPIO 35 |
| SD-Modul CS / MOSI / MISO / SCK | D10 / D11 / D12 / D13 | Nicht genutzt |
| SD-Modul VCC | 5V | — |
| I2C-Gerät | Standardadresse | Hinweis |
|---|---|---|
| I2C-Modul des LCD (PCF8574T) | 0x27 | Mit den Lötbrücken 0x20–0x27 |
| I2C-Modul des LCD (PCF8574AT) | 0x3F | Mit den Lötbrücken 0x38–0x3F |
| BMP280 (lila Module) | 0x76 | 0x77, wenn der SDO-Pin an 3,3 V liegt |
| BMP280 (Adafruit-Platine) | 0x77 | 0x76, wenn SDO an GND liegt |
| BME280 (statt BMP280) | 0x76 oder 0x77 | Chip-ID 0x60; beim BMP280 0x58 |
| RTC DS3231 / DS1307 (optional) | 0x68 | Das EEPROM des DS3231-Moduls liegt auf 0x57 |
Bibliotheken installieren
- Öffne in der Arduino IDE den Bibliotheksverwalter und installiere LiquidCrystal I2C (Frank de Brabander).
- 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.
- Installiere die DHT sensor library (Adafruit).
- 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
- Zuerst den I2C-Bus aufbauen: LCD und BMP280 an A4 und A5 anschließen, den I2C-Scanner starten und die beiden Adressen notieren.
- 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.
- 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.
- 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.
- 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.
- 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.
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 Funktion | Aufgabe |
|---|---|
| ALTITUDE_M | Höhe; zum Umrechnen des gemessenen Drucks auf Meereshöhe |
| RAIN_DRY / RAIN_WET | Die selbst gemessenen Analogwerte bei trockener und nasser Platine |
| RAIN_ON / RAIN_OFF | Schwellen (%) für Regenbeginn und Regenende; der Abstand dazwischen ist die Hysterese |
| DAY_LEVEL / NIGHT_LEVEL | Tag- 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 Stunden | Klasse | Was bedeutet das meistens? |
|---|---|---|
| Weniger als 0,1 hPa | Gleichbleibend | Das aktuelle Wetter bleibt |
| 0,1–1,5 hPa | Langsam steigend / fallend | Kleine Änderung; beim Fallen kann es sich bewölken |
| 1,6–3,5 hPa | Steigend / fallend | Fallend: Regenwahrscheinlichkeit steigt; steigend: es klart auf |
| 3,6–6 hPa | Schnell steigend / fallend | Fallend: windiges, nasses Wetter zieht auf |
| Mehr als 6 hPa | Sehr schnell | Sturm; 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.
| 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 |
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.
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.
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}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
| Symptom | Wahrscheinliche Ursache | Lösung |
|---|---|---|
| Das LCD zeigt nur volle Kästchen | Kontrast falsch eingestellt oder falsche I2C-Adresse | Am blauen Trimmer auf der Rückseite drehen und 0x3F statt 0x27 probieren |
| Auf dem Display steht nan | DHT22 nicht lesbar: Verkabelung, Pull-up oder Abfragen öfter als alle 2 Sekunden | Datenleitung und 10-kΩ-Widerstand prüfen; der Code behält bei Fehlmessung den alten Wert |
| Druck ist nan oder ändert sich nie | BMP280 nicht gefunden: Adresse 0x77 oder 3,3-V-Modul falsch versorgt | begin(0x77) probieren und das Modul mit der richtigen Spannung versorgen |
| Druck liegt 80–100 hPa unter dem Wetterbericht | Keine Höhe eingetragen, angezeigt wird der örtliche Druck | ALTITUDE_M auf deine echte Höhe setzen |
| Tagsüber viel zu hohe Temperatur | Sensor steht in der Sonne oder heizt sich im Gehäuse auf | Schattige, belüftete Wetterhütte verwenden |
| Hoher Regenwert auch bei trockenem Wetter | Platine verschmutzt, betaut oder falsch kalibriert | Platine reinigen, RAIN_DRY neu messen, RAIN_ON-Schwelle anheben |
| Das Display zeigt SD:off | Keine Karte, exFAT-formatiert oder Modul an 3,3 V | Karte bis 32 GB mit FAT32 formatieren, Modul an 5V anschließen |
| Pendelt in der Dämmerung zwischen Day und Night | Die Schwellen liegen zu dicht beieinander | Mindestens 100 Stufen Abstand zwischen DAY_LEVEL und NIGHT_LEVEL lassen |
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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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…

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…

Punktmatrix-Uhr, Kalender und Wetterstation (MAX7219, DS1307)
Eine Laufschrift-Tafel für Tisch oder Wand, die abwechselnd Uhrzeit, Datum und das Raumklima zeigt.

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.

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.

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.

Temperaturmessung mit NTC und 2x16 Lcd Display
Miss die Umgebungstemperatur mit einem Sensor, der aussieht wie eine kleine Perle.

Verwendung des LCD-Bildschirms mit I2C
Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

