AHT10 Arduino: AHT20 Temperatur- und Feuchtesensor anschließen
AHT10 und AHT20 am Arduino: I2C-Anschluss (0x38), AHTX0-Bibliothek, Vergleich mit DHT11/DHT22, OLED-Feuchteanzeige sowie Code für ESP32 und Pico.
Der AHT10 ist in den letzten Jahren einer der beliebtesten Sensoren für alle, die in Arduino-Projekten Temperatur und Luftfeuchtigkeit gleichzeitig messen wollen. Der AHT10 von Aosong (ASAIR) und sein verbesserter Nachfolger AHT20 werden mit nur vier Kabeln über I2C angeschlossen, messen die Temperatur mit etwa ±0,3 °C und die relative Luftfeuchtigkeit mit ±2 % Genauigkeit und liefern werkseitig kalibrierte Digitalwerte. Kurz gesagt: viel genauer als der DHT11 und günstiger und schneller als der DHT22.
In diesem Beitrag siehst du Schritt für Schritt die Unterschiede zwischen AHT10 und AHT20, den Anschluss an Arduino Uno, ESP32 und Raspberry Pi Pico, die erste Messung mit der Adafruit-AHTX0-Bibliothek und wie sich aus den Rohdaten des Sensors Temperatur und Feuchte berechnen. Danach erfährst du, warum die Luftfeuchtigkeit im Winter bei laufender Heizung sinkt, wie der ideale Feuchtebereich aussieht und wie du mit dem Taupunkt das Risiko beschlagener Fenster berechnest. Zum Schluss baust du eine praktische Raumfeuchteanzeige auf einem kleinen OLED.
Was sind AHT10 und AHT20 und wie funktionieren sie?
In beiden Sensoren stecken zwei getrennte Messelemente. Die Feuchte wird mit einem kapazitiven Element gemessen: Zwischen zwei Elektroden liegt eine dünne Polymerschicht, die Wasserdampf aus der Luft aufnimmt. Steigt die Luftfeuchtigkeit, nimmt das Polymer mehr Wasser auf, die Dielektrizitätskonstante ändert sich und die Kapazität des Elements steigt messbar. Die Temperatur misst ein Halbleitersensor auf dem Chip. Diese beiden Analogsignale werden von einem speziellen Prozessor (ASIC) im selben Gehäuse mit einem 20-Bit-ADC in Zahlen umgewandelt und mit den werkseitigen Kalibrierkoeffizienten korrigiert. Dein Mikrocontroller bekommt also fertige, kalibrierte Rohwerte; du musst sie nur mit einer einfachen Formel in Grad Celsius und Prozent umrechnen.
AHT10 und AHT20 sehen von außen fast gleich aus, auch Messbereich und Genauigkeit sind identisch. Der Unterschied steckt im Detail: Der AHT20 hat einen größeren Versorgungsspannungsbereich (2,0–5,5 V), eine bessere Langzeitstabilität, sendet ein CRC-Byte, mit dem du prüfen kannst, ob die Daten fehlerfrei sind, und hat einen anderen Initialisierungsbefehl (AHT10: 0xE1, AHT20: 0xBE). Beim AHT10 kannst du über den Adresspin 0x38 oder 0x39 wählen, die Adresse des AHT20 ist fest 0x38. Außerdem machen manche AHT10-Module Probleme, wenn sie den I2C-Bus mit anderen Geräten teilen; für ein neues Projekt ist meist der AHT20 die bessere Wahl.
| Eigenschaft | AHT10 | AHT20 |
|---|---|---|
| Hersteller | Aosong (ASAIR) | Aosong (ASAIR) |
| Schnittstelle und Adresse | I2C, 0x38 (0x39 über ADR-Pin) | I2C, fest 0x38 |
| Versorgungsspannung des Chips | 1,8–3,6 V | 2,0–5,5 V |
| Temperaturbereich / Genauigkeit | -40…+85 °C / ±0,3 °C | -40…+85 °C / ±0,3 °C |
| Feuchtebereich / Genauigkeit | 0–100 % RH / ±2 % RH | 0–100 % RH / ±2 % RH |
| Auflösung | 0,01 °C / 0,024 % RH | 0,01 °C / 0,024 % RH |
| Messdauer | Etwa 75 ms | Etwa 80 ms |
| Ruhestrom | Unter 1 µA | Unter 1 µA |
| Initialisierungsbefehl | 0xE1 0x08 0x00 | 0xBE 0x08 0x00 |
| CRC-Prüfung | Nein | Ja (7. Byte) |
AHT20, DHT11 und DHT22 im Vergleich
Die bekanntesten Sensoren für Temperatur und Luftfeuchtigkeit in der Arduino-Welt sind DHT11 und DHT22. Sie kommunizieren über eine einzige Datenleitung mit einem zeitkritischen Spezialprotokoll; die Bibliothek sperrt bei jeder Messung für einige Millisekunden die Interrupts, der DHT11 kann einmal pro Sekunde, der DHT22 alle zwei Sekunden gelesen werden. Der AHT20 nutzt Standard-I2C: An dieselben zwei Kabel kannst du auch ein OLED, eine RTC oder einen Drucksensor hängen, und es gibt keine verpassten Messungen wegen Timing-Fehlern. RH steht für relative Luftfeuchtigkeit (relative humidity).
| Eigenschaft | AHT10 / AHT20 | DHT11 | DHT22 (AM2302) |
|---|---|---|---|
| Kommunikation | I2C (2 Leitungen) | Eigenes Eindraht-Protokoll | Eigenes Eindraht-Protokoll |
| Temperaturbereich | -40…+85 °C | 0…50 °C | -40…+80 °C |
| Temperaturgenauigkeit | ±0,3 °C | ±2 °C | ±0,5 °C |
| Feuchtebereich | 0–100 % RH | 20–90 % RH | 0–100 % RH |
| Feuchtegenauigkeit | ±2 % RH | ±5 % RH | ±2–5 % RH |
| Auflösung | 0,01 °C / 0,024 % RH | 1 °C / 1 % RH | 0,1 °C / 0,1 % RH |
| Messintervall | Etwa 80 ms (empfohlen 2 s) | 1 s | 2 s |
| Weitere Geräte am selben Bus | Ja (I2C) | Nein | Nein |
| Preis | Niedrig | Am niedrigsten | Mittel |
Welchen solltest du nehmen? Für ein einfaches Projekt, das nur wissen will, ob es warm oder kalt ist, reicht der DHT11. Aber bei ±5 % Fehler siehst du den Unterschied zwischen 40 % und 45 % nicht; für Raumfeuchte-Überwachung, Gewächshaus oder Brutkasten ist das wichtig. Der DHT22 kommt dem AHT20 bei der Genauigkeit nahe, ist aber teurer und langsamer. Wenn du auch den Druck messen willst, ist der BME280 eine gute Alternative; einen ausführlichen Vergleich findest du in den Beiträgen Temperatursensoren im Vergleich und BME280 und BMP280.
AHT10/AHT20 anschließen: Uno, ESP32 und Pico
| AHT-Modulpin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VIN / VCC | 5V (oder 3.3V) | 3V3 | 3V3(OUT), Pin 36 |
| GND | GND | GND | GND (z. B. Pin 38) |
| SCL | A5 | GPIO 22 | GP5 (Pin 7) |
| SDA | A4 | GPIO 21 | GP4 (Pin 6) |
Bei den meisten AHT10- und AHT20-Modulen auf dem Markt sind ein kleiner 3,3-V-Regler und Pull-up-Widerstände für die I2C-Leitungen schon verbaut; deshalb kannst du sie direkt mit 5 V am Uno betreiben. Beim Uno R3 gibt es SDA und SCL zusätzlich auf zwei Pins neben AREF; intern sind das dieselben Leitungen wie A4 und A5. Eine weitere sehr verbreitete Platine kombiniert AHT20 und BMP280: Der AHT20 liegt auf 0x38, der BMP280 meist auf 0x77, und mit einem einzigen Anschluss liest du Temperatur, Feuchte und Druck zusammen. Für die I2C-Grundlagen ist der Beitrag Was ist I2C? ein guter Einstieg.
Schritt für Schritt: die erste Messung mit Arduino
- Öffne in der Arduino IDE die Bibliotheksverwaltung, suche nach Adafruit AHTX0 und installiere sie; wenn nach Abhängigkeiten gefragt wird, wähle Install all, damit auch Adafruit BusIO und Adafruit Unified Sensor installiert werden.
- Schließe den Sensor gemäß der Tabelle oben an: VIN an 5V, GND an GND, SCL an A5, SDA an A4.
- Wenn du nicht sicher bist, ob der Sensor am Bus erscheint, lass zuerst einen I2C-Scanner laufen; in der Liste solltest du die Adresse 0x38 sehen.
- Lade den folgenden Code hoch und öffne den Seriellen Monitor mit 9600 Baud.
- Hauche den Sensor leicht an: Du wirst sehen, dass der Feuchtewert innerhalb weniger Sekunden schnell ansteigt und dann langsam wieder auf den alten Wert zurückgeht.
1#include <Wire.h>
2#include <Adafruit_AHTX0.h>
3
4Adafruit_AHTX0 aht; // AHT10 ve AHT20 için ortak nesne / shared object for AHT10 and AHT20
5
6void setup() {
7 Serial.begin(9600);
8 if (!aht.begin()) { // 0x38 adresinde sensörü ara / look for the sensor at 0x38
9 Serial.println(F("AHT sensor bulunamadi / not found"));
10 while (1) delay(10);
11 }
12 Serial.println(F("AHT sensor hazir / ready"));
13}
14
15void loop() {
16 sensors_event_t humidity, temp;
17 aht.getEvent(&humidity, &temp); // ölçümü başlat ve oku / trigger and read a measurement
18
19 Serial.print(F("Sicaklik / Temp: "));
20 Serial.print(temp.temperature, 1);
21 Serial.print(F(" C Nem / Humidity: %"));
22 Serial.println(humidity.relative_humidity, 1);
23 delay(2000); // kendi kendine ısınmayı önle / avoid self-heating
24}| Zeile | Was sie macht |
|---|---|
| aht.begin() | Sucht den Sensor auf Adresse 0x38, setzt ihn zurück und prüft den Kalibrierstatus. Gibt false zurück, wenn kein Sensor gefunden wird. |
| aht.getEvent(&humidity, &temp) | Sendet den Messbefehl (0xAC), wartet auf das Ende der Messung und liest beide Werte auf einmal. |
| temp.temperature | Temperatur in Grad Celsius (float). |
| humidity.relative_humidity | Relative Luftfeuchtigkeit in Prozent (float). |
| delay(2000) | Wartet 2 Sekunden zwischen den Messungen; verhindert, dass sich der Chip selbst erwärmt. |
Von den Rohdaten zu Temperatur und Feuchte: die Formeln
Du kannst den Sensor auch ohne Bibliothek leicht auslesen, denn das Protokoll besteht nur aus wenigen Befehlen. Um eine Messung zu starten, schreibst du die Bytes 0xAC 0x33 0x00 an den Sensor; nach etwa 80 ms ist das erste der sechs gelesenen Bytes das Statusbyte. Ist dessen höchstes Bit (Bit 7, 0x80) 1, misst der Sensor noch; ist Bit 3 (0x08) 1, ist der Sensor kalibriert. In den nächsten fünf Bytes stehen nebeneinander der 20-Bit-Feuchtewert (S_RH) und der 20-Bit-Temperaturwert (S_T). Die Umrechnungsformeln lauten: RH = S_RH / 2^20 × 100 und T = S_T / 2^20 × 200 − 50. Ist der Roh-Feuchtewert zum Beispiel 471.859, ergibt sich 471.859 / 1.048.576 × 100 ≈ 45,0 % Feuchte; bei einem Roh-Temperaturwert von 372.244 ergibt sich 372.244 / 1.048.576 × 200 − 50 ≈ 21,0 °C. Der MicroPython-Code im Pico-Abschnitt setzt genau diese Schritte um.
Raumfeuchte im Winter überwachen: warum ist das wichtig?
Hinter trockenem Hals, Stromschlägen durch statische Aufladung oder rissigen Lippen im Winter steckt oft zu niedrige Luftfeuchtigkeit. Der Grund ist eine einfache physikalische Regel: Die Menge Wasserdampf, die Luft aufnehmen kann, steigt mit der Temperatur stark an. Bei 0 °C kann ein Kubikmeter Luft höchstens etwa 4,8 Gramm Wasserdampf enthalten, bei 21 °C steigt diese Grenze auf etwa 18,3 Gramm. Draußen enthält Luft mit 0 °C und 80 % Feuchte etwa 3,9 g/m³ Wasser. Kommt diese Luft herein und wird mit der Heizung auf 21 °C erwärmt, bleibt die Wassermenge gleich, aber die mögliche Menge steigt auf etwa das Vierfache; die relative Feuchte sinkt auf 3,9 / 18,3 ≈ 21 %. Dank der ±2 % Genauigkeit des AHT20 siehst du solche Änderungen und ob dein Luftbefeuchter wirklich etwas bringt problemlos.
| Relative Luftfeuchtigkeit | Zustand | Was tun? |
|---|---|---|
| Unter 30 % | Sehr trocken: trockener Hals, trockene Augen und Haut, statische Aufladung | Luftbefeuchter benutzen, Heizung etwas herunterdrehen |
| 30–40 % | Etwas trocken, im Winter häufig | Eine Wasserschale aufstellen oder Wäsche trocknen hilft |
| 40–60 % | Idealer Bereich | Zustand halten |
| 60–70 % | Feucht: Fenster beschlagen | Kurz und oft lüften |
| Über 70 % | Hohes Risiko für Schimmel und Milben | Lüften, bei Bedarf einen Luftentfeuchter einsetzen |
Ein weiterer Vorteil der Feuchtemessung ist, dass du den Taupunkt berechnen kannst. Der Taupunkt ist die Temperatur, bei der der Wasserdampf in der Luft zu kondensieren beginnt. Sinkt die Temperatur einer Fensterscheibe oder der Innenseite einer Außenwand unter diesen Wert, bilden sich dort Wassertröpfchen und mit der Zeit Schimmel. Berechnet wird er mit der Magnus-Formel: γ = ln(RH/100) + 17,62·T / (243,12 + T) und Td = 243,12·γ / (17,62 − γ). Liegt der Raum zum Beispiel bei 21 °C und 60 % Feuchte, beträgt der Taupunkt etwa 12,9 °C; da die Innenseite der Scheibe im Winter leicht unter 10 °C fällt, beschlägt das Fenster. Sinkt die Feuchte im selben Raum auf 45 %, fällt der Taupunkt auf 8,6 °C und das Beschlagrisiko sinkt deutlich. Im ESP32-Code lassen wir diese Berechnung direkt auf dem Display anzeigen.
Feuchteanzeige auf dem OLED (Arduino Uno)
Jetzt kombinieren wir das Gelernte: Mit einem Arduino Uno, einem AHT20 und einem 0,96-Zoll-SSD1306-OLED baust du eine Feuchteanzeige für den Schreibtisch. Da beide Module I2C nutzen, werden sie parallel an dieselben Pins A4 (SDA) und A5 (SCL) angeschlossen; das OLED liegt auf 0x3C, der AHT20 auf 0x38, es gibt also keinen Konflikt. Die Bibliotheksinstallation für das Display und weitere Details findest du im Beitrag OLED-Display (SSD1306) verwenden.

1#include <Wire.h>
2#include <Adafruit_GFX.h>
3#include <Adafruit_SSD1306.h>
4#include <Adafruit_AHTX0.h>
5
6Adafruit_SSD1306 display(128, 64, &Wire, -1); // 128x64 OLED, reset pini yok / no reset pin
7Adafruit_AHTX0 aht;
8
9void setup() {
10 if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // OLED adresi / OLED address
11 for (;;); // ekran yok / no display
12 }
13 display.setTextColor(SSD1306_WHITE);
14 if (!aht.begin()) { // AHT20 adresi 0x38 / AHT20 address 0x38
15 display.clearDisplay();
16 display.setCursor(0, 0);
17 display.print(F("AHT sensor yok!"));
18 display.display();
19 for (;;);
20 }
21}
22
23void loop() {
24 sensors_event_t humidity, temp;
25 aht.getEvent(&humidity, &temp);
26 float t = temp.temperature;
27 float h = humidity.relative_humidity;
28
29 display.clearDisplay();
30 display.setTextSize(1);
31 display.setCursor(0, 0);
32 display.print(F("Sicaklik: "));
33 display.print(t, 1);
34 display.print(F(" C"));
35
36 display.setTextSize(3); // nem büyük puntoyla / humidity in large font
37 display.setCursor(0, 16);
38 display.print(F("%"));
39 display.print(h, 0);
40
41 display.setTextSize(1);
42 display.setCursor(0, 46);
43 if (h < 30) display.print(F("Hava cok kuru")); // %30 alti / below 30 %
44 else if (h < 40) display.print(F("Biraz kuru"));
45 else if (h <= 60) display.print(F("Ideal nem"));
46 else display.print(F("Nemli: kuf riski")); // %60 ustu / above 60 %
47
48 display.drawRect(0, 56, 128, 8, SSD1306_WHITE); // çubuk çerçevesi / bar frame
49 display.fillRect(2, 58, (int)(h / 100.0 * 124), 4, SSD1306_WHITE); // nem kadar dolu / filled by humidity
50 display.display(); // tamponu gönder / push the buffer
51 delay(2000);
52}Der Code misst alle zwei Sekunden; oben zeigt er die Temperatur in kleiner Schrift, in der Mitte die Feuchte in dreifacher Größe. Die Zeile darunter sagt anhand der Bereiche aus der Tabelle oben, ob die Luft trocken, ideal oder feucht ist; der Balken ganz unten zeigt die Feuchte grafisch. Weil der OLED-Bildspeicher etwa 1 KB der 2 KB RAM des Uno belegt, haben wir feste Texte mit dem F()-Makro geschrieben. Wenn du den Sensor nicht direkt an Display und Arduino klebst, sondern ein paar Zentimeter entfernt am Kabelende platzierst, beeinflusst die Abwärme der Platinen die Messung nicht.
ESP32 mit AHT20: Taupunkt sowie minimale und maximale Feuchte
Auf dem ESP32 laufen dieselben Adafruit-Bibliotheken unverändert; der einzige Unterschied sind die I2C-Pins. Bei ESP32-DevKit-Boards ist SDA standardmäßig GPIO 21 und SCL GPIO 22, und du kannst die Pins mit Wire.begin(21, 22) ausdrücklich angeben. Der folgende Code zeigt Feuchte und Temperatur auf dem OLED an, berechnet mit der Magnus-Formel den Taupunkt und speichert die niedrigste und höchste Feuchte seit dem Einschalten. Da wir millis() statt delay() verwenden, bleibt loop() frei; wenn du die Daten später per WLAN aufs Handy schicken oder auf einer Webseite anzeigen willst, musst du den Code nicht von vorn schreiben. Für den WLAN-Teil kannst du mit dem Beitrag Was ist der ESP32? beginnen.
1#include <Wire.h>
2#include <math.h>
3#include <Adafruit_GFX.h>
4#include <Adafruit_SSD1306.h>
5#include <Adafruit_AHTX0.h>
6
7#define SDA_PIN 21 // ESP32 I2C SDA
8#define SCL_PIN 22 // ESP32 I2C SCL
9
10Adafruit_SSD1306 display(128, 64, &Wire, -1);
11Adafruit_AHTX0 aht;
12
13float minH = 100.0;
14float maxH = 0.0;
15unsigned long lastRead = 0;
16
17// Magnus formülü ile çiy noktası / dew point with the Magnus formula
18float dewPoint(float t, float h) {
19 const float b = 17.62;
20 const float c = 243.12;
21 if (h < 1.0) h = 1.0; // ln(0) hatasını önle / avoid ln(0)
22 float g = log(h / 100.0) + (b * t) / (c + t);
23 return (c * g) / (b - g);
24}
25
26void setup() {
27 Serial.begin(115200);
28 Wire.begin(SDA_PIN, SCL_PIN); // I2C pinlerini seç / select I2C pins
29 if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
30 Serial.println("OLED bulunamadi / OLED not found");
31 for (;;) delay(10);
32 }
33 if (!aht.begin(&Wire)) {
34 Serial.println("AHT bulunamadi / AHT not found");
35 for (;;) delay(10);
36 }
37 display.setTextColor(SSD1306_WHITE);
38}
39
40void loop() {
41 if (millis() - lastRead < 2000) return; // 2 saniyede bir ölç / measure every 2 s
42 lastRead = millis();
43
44 sensors_event_t humidity, temp;
45 aht.getEvent(&humidity, &temp);
46 float t = temp.temperature;
47 float h = humidity.relative_humidity;
48 if (h < minH) minH = h;
49 if (h > maxH) maxH = h;
50 float td = dewPoint(t, h);
51
52 Serial.printf("T=%.1f C RH=%.1f %% Td=%.1f C\n", t, h, td);
53
54 display.clearDisplay();
55 display.setTextSize(1);
56 display.setCursor(0, 0);
57 display.print("Sicaklik: ");
58 display.print(t, 1);
59 display.print(" C");
60
61 display.setTextSize(3);
62 display.setCursor(0, 12);
63 display.print("%");
64 display.print(h, 1);
65
66 display.setTextSize(1);
67 display.setCursor(0, 42);
68 display.print("Ciy noktasi: ");
69 display.print(td, 1);
70 display.print(" C");
71 display.setCursor(0, 54);
72 display.print("Min %");
73 display.print(minH, 0);
74 display.print(" Maks %");
75 display.print(maxH, 0);
76 display.display();
77}Raspberry Pi Pico und MicroPython mit AHT20
Auf dem Raspberry Pi Pico brauchst du für MicroPython nicht einmal eine eigene Bibliothek; das Protokoll ist so einfach, dass du es mit ein paar Zeilen selbst schreiben kannst. Der Code wartet zuerst 40 ms für die Startzeit des Sensors, prüft das Kalibrierbit im Statusbyte und sendet bei Bedarf den Initialisierungsbefehl. Danach sendet er bei jeder Messung den Befehl 0xAC, wartet 80 ms, liest, bis das Busy-Bit gelöscht ist, und berechnet das Ergebnis mit den oben erklärten Formeln. Wenn du einen AHT10 nutzt, genügt der Aufruf aht_init(True). Der I2C0-Bus des Pico liegt hier an GP4 (SDA) und GP5 (SCL); willst du ein OLED ergänzen, kannst du den Treiber ssd1306.py mit demselben i2c-Objekt verwenden. Für die MicroPython-Installation schau in den Beitrag Was ist der Raspberry Pi Pico?.
1from machine import Pin, I2C
2import time
3
4ADDR = 0x38 # AHT10/AHT20 I2C adresi / I2C address
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=100000)
6print("I2C:", [hex(a) for a in i2c.scan()]) # 0x38 görünmeli / 0x38 should appear
7
8def aht_init(aht10=False):
9 time.sleep_ms(40) # açılış süresi / power-up time
10 status = i2c.readfrom(ADDR, 1)[0]
11 if not status & 0x08: # kalibre değilse / if not calibrated
12 cmd = 0xE1 if aht10 else 0xBE # AHT10: 0xE1, AHT20: 0xBE
13 i2c.writeto(ADDR, bytes([cmd, 0x08, 0x00]))
14 time.sleep_ms(10)
15
16def aht_read():
17 i2c.writeto(ADDR, bytes([0xAC, 0x33, 0x00])) # ölçümü başlat / trigger measurement
18 time.sleep_ms(80)
19 d = i2c.readfrom(ADDR, 6)
20 while d[0] & 0x80: # meşgulse bekle / wait while busy
21 time.sleep_ms(10)
22 d = i2c.readfrom(ADDR, 6)
23 raw_h = (d[1] << 12) | (d[2] << 4) | (d[3] >> 4)
24 raw_t = ((d[3] & 0x0F) << 16) | (d[4] << 8) | d[5]
25 h = raw_h * 100 / 1048576 # RH = S_RH / 2^20 * 100
26 t = raw_t * 200 / 1048576 - 50 # T = S_T / 2^20 * 200 - 50
27 return t, h
28
29aht_init() # AHT10 için aht_init(True) / use aht_init(True) for AHT10
30while True:
31 t, h = aht_read()
32 print("Sicaklik: {:.1f} C Nem: %{:.1f}".format(t, h))
33 time.sleep(2) # 2 saniyede bir / every 2 secondsProjektideen mit dem AHT20
- Raumfeuchteanzeige: Stelle in jeden Raum einen AHT20 mit kleinem OLED und sieh, welcher Raum im Winter am trockensten ist.
- Automatischer Luftbefeuchter: Schalte den Luftbefeuchter über ein Relaismodul ein, wenn die Feuchte unter 40 % fällt, und bei 50 % wieder aus.
- Badlüfter-Steuerung: Schalte den Abluftventilator ein, wenn die Feuchte nach dem Duschen über 70 % steigt; die Schaltung aus dem Beitrag Arduino-Lüftersteuerung kannst du dafür nutzen.
- Mini-Gewächshaus und Brutkasten: Steuere Temperatur und Feuchte gleichzeitig; das smarte Gewächshaus-Projekt ist ein guter Ausgangspunkt.
- Batteriebetriebener Datenlogger: Schicke den ESP32 in den Deep Sleep und miss alle 10 Minuten; der AHT20 zieht im Schlaf weniger als ein Mikroampere.
- Smartes Thermostat: Miss die Temperatur mit ±0,3 °C Genauigkeit und schalte den Heizkessel per Relais ein und aus; Details im Beitrag Arduino-Thermostat.
- Feuchtealarm für Kleiderschrank und Abstellraum: Warne per Buzzer, wenn die Feuchte über 65 % steigt, und werde aktiv, bevor Schimmel entsteht.
Häufige Fehler und ihre Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Meldung "nicht gefunden", begin() gibt false zurück | SDA und SCL vertauscht, loses Kabel oder falsche Versorgung | Kabel prüfen, mit einem I2C-Scanner nach Adresse 0x38 suchen |
| Scanner findet keine Adresse | Modul hat keine Pull-up-Widerstände oder GND ist nicht gemeinsam | 4,7-kΩ-Pull-ups von SDA und SCL nach 3,3 V ergänzen, GNDs verbinden |
| Temperatur 2–3 °C zu hoch | Sensor wird von der Wärme von Arduino, Regler oder Display beeinflusst | Sensor am Kabelende von den Platinen entfernen, Lüftungslöcher ins Gehäuse machen |
| Feuchte dauerhaft nahe 100 % oder ändert sich nie | Sensor war Kondensation ausgesetzt oder die Oberfläche ist verschmutzt | Einige Stunden in trockener, warmer Umgebung liegen lassen, die Sensoroberfläche nicht berühren |
| Gelegentlich unsinnige Werte (z. B. -50 °C) | Lesen vor Ende der Messung, zu häufiges Lesen oder Störungen auf der Leitung | Mindestens 2 s zwischen den Messungen warten, Kabel kurz halten, beim AHT20 den CRC prüfen |
| Mit OLED zusammen hängt der AHT10 | Manche AHT10-Module haben Probleme, den I2C-Bus zu teilen | Auf den AHT20 wechseln oder den AHT10 an einen separaten I2C-Bus anschließen |
Der AHT10 und besonders der AHT20 bieten trotz des niedrigen Preises mehr als genug Genauigkeit für die Raumklima-Überwachung und lassen sich dank I2C sehr leicht anschließen und mit anderen Modulen kombinieren. Wenn du früher mit dem DHT11 angefangen hast, kannst du dasselbe Projekt mit wenigen Zeilen Änderung auf den AHT20 umstellen und selbst sehen, wie viel stabiler die Messungen werden. In der BlueGrays-App findest du Projekte wie Temperatur- und Feuchtemessung mit dem DHT11, eine Temperatur- und Feuchteanzeige mit LCD am ESP32, eine Wetteranzeige mit OLED und einen Temperaturlogger mit microSD-Karte, jeweils mit Schaltplänen und Code Schritt für Schritt; als Sensor kannst du dort einfach den AHT20 einsetzen.
Häufige Fragen
Was ist der Unterschied zwischen AHT10 und AHT20?
Beide haben denselben Messbereich und etwa ±0,3 °C bzw. ±2 % RH Genauigkeit. Der AHT20 bietet einen größeren Versorgungsbereich (2,0–5,5 V), Datenprüfung per CRC und bessere Langzeitstabilität; auch die Initialisierungsbefehle sind anders. Für neue Projekte solltest du den AHT20 wählen.
Welche I2C-Adresse hat der AHT20?
Die Adresse des AHT20 ist fest 0x38 und lässt sich nicht ändern. Beim AHT10 kannst du über den ADR-Pin 0x38 oder 0x39 wählen. Um zwei AHT20 am selben Bus zu nutzen, brauchst du einen zweiten I2C-Bus oder einen I2C-Multiplexer wie den TCA9548A.
Ist der AHT20 oder der DHT22 besser?
Für die meisten Projekte im Haus ist der AHT20 besser: Die Genauigkeit ist so gut wie oder besser als beim DHT22, er ist günstiger und schneller und teilt sich dank I2C dieselben zwei Kabel mit anderen Modulen. Der Vorteil des DHT22 ist, dass er auch mit langen Kabeln funktioniert; I2C läuft meist am zuverlässigsten mit kurzen Kabeln unter 1 Meter.
Kann ich den AHT10 mit 5 V an den Arduino anschließen?
Module mit Spannungsregler laufen problemlos mit 5 V; achte darauf, ob auf der Platine ein kleiner dreibeiniger Regler und die Beschriftung VIN zu sehen sind. Bei nackten AHT10-Platinen ohne Regler liegt die Obergrenze des Chips bei 3,6 V, daher musst du das Modul mit 3,3 V versorgen.
Warum zeigt mein AHT20 eine zu hohe Temperatur an?
Meist wird der Sensor von der Abwärme des Arduino, des Spannungsreglers oder des Displays beeinflusst. Auch zu häufiges Messen erwärmt den Chip ein wenig. Halte den Sensor am Kabelende von den Platinen fern und miss höchstens alle 2 Sekunden.
Wie hoch sollte die ideale Luftfeuchtigkeit in der Wohnung sein?
Für Innenräume gelten allgemein 40–60 % relative Luftfeuchtigkeit als ideal. Im Winter kann die Feuchte durch die Heizung unter 30 % fallen; dann nehmen trockener Hals und trockene Haut zu. Über 60 % beginnt das Risiko für beschlagene Fenster und mit der Zeit Schimmel.
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…

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 SSD1306-OLED-Display)
Der ESP32 ruft über das Internet mit HTTPClient.h eine Wetter-API (wttr.in) per REST auf. Anders als die I2C-LCD-Version nutzt dieses Projekt ein SSD1306-OLED (128×64) mit großer Schrift und Vektor-Icons für eine reichere Darstellung. Sieben Wetter-Icons (sonnig, Regen, Schnee und mehr) werden ohne Bitmap-Dateien direkt gezeichnet.

ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
Im Deep-Sleep-Modus schaltet der ESP32 die CPU und die meisten Peripheriegeräte ab und senkt den Strom auf etwa 10µA, entscheidend für batteriebetriebene IoT-Geräte. Das Projekt nutzt drei Weckquellen: einen Timer (15 s), einen externen Pin (EXT0, Taster an GPIO 33) und einen Touch-Pin (T0/GPIO 4). Mit RTC_DATA_ATTR markierte Zähler bleiben im Deep Sleep erhalten.

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

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

