Bauteile · 10 Min. Lesezeit

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.

EigenschaftAHT10AHT20
HerstellerAosong (ASAIR)Aosong (ASAIR)
Schnittstelle und AdresseI2C, 0x38 (0x39 über ADR-Pin)I2C, fest 0x38
Versorgungsspannung des Chips1,8–3,6 V2,0–5,5 V
Temperaturbereich / Genauigkeit-40…+85 °C / ±0,3 °C-40…+85 °C / ±0,3 °C
Feuchtebereich / Genauigkeit0–100 % RH / ±2 % RH0–100 % RH / ±2 % RH
Auflösung0,01 °C / 0,024 % RH0,01 °C / 0,024 % RH
MessdauerEtwa 75 msEtwa 80 ms
RuhestromUnter 1 µAUnter 1 µA
Initialisierungsbefehl0xE1 0x08 0x000xBE 0x08 0x00
CRC-PrüfungNeinJa (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).

EigenschaftAHT10 / AHT20DHT11DHT22 (AM2302)
KommunikationI2C (2 Leitungen)Eigenes Eindraht-ProtokollEigenes Eindraht-Protokoll
Temperaturbereich-40…+85 °C0…50 °C-40…+80 °C
Temperaturgenauigkeit±0,3 °C±2 °C±0,5 °C
Feuchtebereich0–100 % RH20–90 % RH0–100 % RH
Feuchtegenauigkeit±2 % RH±5 % RH±2–5 % RH
Auflösung0,01 °C / 0,024 % RH1 °C / 1 % RH0,1 °C / 0,1 % RH
MessintervallEtwa 80 ms (empfohlen 2 s)1 s2 s
Weitere Geräte am selben BusJa (I2C)NeinNein
PreisNiedrigAm niedrigstenMittel

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-ModulpinArduino UnoESP32Raspberry Pi Pico
VIN / VCC5V (oder 3.3V)3V33V3(OUT), Pin 36
GNDGNDGNDGND (z. B. Pin 38)
SCLA5GPIO 22GP5 (Pin 7)
SDAA4GPIO 21GP4 (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.

Gib nicht 5 V auf das Modul, wenn du nicht sicher bist, dass es einen Regler hat. Siehst du auf der Platine nur den Sensorchip und ein paar Widerstände (besonders bei manchen nackten AHT10-Platinen), musst du das Modul mit 3,3 V versorgen; die Obergrenze des AHT10-Chips liegt bei 3,6 V. Da sich die Adresse des AHT20 nicht ändern lässt, kannst du außerdem nicht zwei AHT20 an denselben I2C-Bus hängen; für den zweiten Sensor nutzt du den zweiten I2C-Bus von ESP32 und Pico oder einen I2C-Multiplexer wie den TCA9548A.

Schritt für Schritt: die erste Messung mit Arduino

  1. Ö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.
  2. Schließe den Sensor gemäß der Tabelle oben an: VIN an 5V, GND an GND, SCL an A5, SDA an A4.
  3. 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.
  4. Lade den folgenden Code hoch und öffne den Seriellen Monitor mit 9600 Baud.
  5. 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.
C++ (Arduino IDE)
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}
ZeileWas 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.temperatureTemperatur in Grad Celsius (float).
humidity.relative_humidityRelative 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.

Es ist verlockend, den Sensor mehrmals pro Sekunde zu lesen, aber jede Messung erwärmt den Chip, wenn auch nur minimal. Der Hersteller empfiehlt, die Messungen auf alle 2 Sekunden zu begrenzen, damit die Eigenerwärmung vernachlässigbar bleibt. Für sich langsam ändernde Größen wie die Raumfeuchte reicht schon eine Messung alle 5–10 Sekunden völlig aus.

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 LuftfeuchtigkeitZustandWas tun?
Unter 30 %Sehr trocken: trockener Hals, trockene Augen und Haut, statische AufladungLuftbefeuchter benutzen, Heizung etwas herunterdrehen
30–40 %Etwas trocken, im Winter häufigEine Wasserschale aufstellen oder Wäsche trocknen hilft
40–60 %Idealer BereichZustand halten
60–70 %Feucht: Fenster beschlagenKurz und oft lüften
Über 70 %Hohes Risiko für Schimmel und MilbenLü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.

0,96-Zoll-I2C-OLED-Display SSD1306
Das 0,96-Zoll-SSD1306-OLED teilt sich den I2C-Bus mit dem AHT20: Das Display liegt auf 0x3C, der Sensor auf 0x38.
C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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?.

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

Projektideen 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

SymptomMögliche UrsacheLösung
Meldung "nicht gefunden", begin() gibt false zurückSDA und SCL vertauscht, loses Kabel oder falsche VersorgungKabel prüfen, mit einem I2C-Scanner nach Adresse 0x38 suchen
Scanner findet keine AdresseModul hat keine Pull-up-Widerstände oder GND ist nicht gemeinsam4,7-kΩ-Pull-ups von SDA und SCL nach 3,3 V ergänzen, GNDs verbinden
Temperatur 2–3 °C zu hochSensor wird von der Wärme von Arduino, Regler oder Display beeinflusstSensor am Kabelende von den Platinen entfernen, Lüftungslöcher ins Gehäuse machen
Feuchte dauerhaft nahe 100 % oder ändert sich nieSensor war Kondensation ausgesetzt oder die Oberfläche ist verschmutztEinige 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 LeitungMindestens 2 s zwischen den Messungen warten, Kabel kurz halten, beim AHT20 den CRC prüfen
Mit OLED zusammen hängt der AHT10Manche AHT10-Module haben Probleme, den I2C-Bus zu teilenAuf den AHT20 wechseln oder den AHT10 an einen separaten I2C-Bus anschließen
Damit der Sensor richtig misst, muss er Kontakt zur Luft haben. Wenn du ihn in ein geschlossenes Gehäuse setzt, bohre unbedingt ein Loch davor und platziere ihn in einem eigenen Fach, getrennt vom warmen Regler und Mikrocontroller. Orte wie direkte Sonne, die Oberseite eines Heizkörpers oder eine Außenwandecke geben nicht den wahren Wert des Raums wieder; miss auf Sitzhöhe und möglichst nahe der Raummitte.

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.

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
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 SSD1306-OLED-Display)
ES-32Fortgeschritten
Premium

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.

4.3(10)
22
ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
ES-33Fortgeschritten
Premium

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.

4.3(10)
16
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
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