AHT10 Arduino-gids: AHT20 temperatuur- en vochtigheidssensor
Sluit de AHT10 en AHT20 aan op Arduino: I2C-bedrading op 0x38, AHTX0-bibliotheek, vergelijking met DHT11/DHT22, OLED-vochtigheidsdisplay, plus code voor ESP32 en Pico.
De AHT10 is uitgegroeid tot een van de populairste keuzes voor Arduino-projecten die temperatuur en luchtvochtigheid samen moeten meten. De AHT10 en zijn verbeterde opvolger, de AHT20, gemaakt door Aosong (ASAIR), sluit je met slechts vier draden aan via I2C. Ze meten de temperatuur tot op ongeveer ±0,3 °C en de relatieve luchtvochtigheid tot op ±2% en leveren in de fabriek gekalibreerde digitale waarden. Kortom: veel nauwkeuriger dan de DHT11, en goedkoper en sneller dan de DHT22.
In dit bericht zie je de verschillen tussen de AHT10 en AHT20, hoe je ze aansluit op een Arduino Uno, ESP32 en Raspberry Pi Pico, je eerste meting met de Adafruit AHTX0-bibliotheek en hoe temperatuur en luchtvochtigheid worden berekend uit de ruwe data die de sensor verstuurt. Daarna leer je waarom de luchtvochtigheid binnen in de winter daalt als de radiatoren aan staan, wat het ideale vochtigheidsbereik is en hoe je het dauwpunt berekent om te zien of je ramen gaan beslaan. Tot slot bouw je een praktisch display voor de luchtvochtigheid binnen op een klein OLED-scherm.
Wat zijn de AHT10 en AHT20 en hoe werken ze?
In beide sensoren zitten twee aparte meetelementen. De luchtvochtigheid wordt gemeten met een capacitief element: een dunne polymeerlaag tussen twee elektroden neemt waterdamp uit de lucht op. Als de luchtvochtigheid stijgt, houdt het polymeer meer water vast, verandert de diëlektrische constante en neemt de capaciteit van het element meetbaar toe. De temperatuur wordt gemeten met een halfgeleidersensor op de chip. Deze twee analoge signalen worden door een 20-bits ADC in een speciale processor (ASIC) in dezelfde behuizing omgezet in getallen en gecorrigeerd met kalibratiecoëfficiënten die in de fabriek zijn ingesteld. Wat je microcontroller ontvangt is een set kant-en-klare, gekalibreerde ruwe getallen; jij hoeft ze alleen met een eenvoudige formule om te rekenen naar graden Celsius en procenten.
De AHT10 en AHT20 zien er van buiten bijna identiek uit en hun meetbereik en nauwkeurigheid zijn gelijk. De verschillen zitten in de details: de AHT20 heeft een breder voedingsbereik (2,0–5,5 V), betere stabiliteit op de lange termijn, stuurt een CRC-byte mee waarmee je kunt zien of de data beschadigd is en gebruikt een ander initialisatiecommando (0xE1 bij de AHT10, 0xBE bij de AHT20). De AHT10 kan dankzij een adreskeuzepin 0x38 of 0x39 gebruiken, terwijl het adres van de AHT20 vast op 0x38 staat. Van sommige AHT10-modules is ook bekend dat ze problemen geven als ze de I2C-bus delen met andere apparaten; voor een nieuw project is de AHT20 meestal de betere koop.
| Eigenschap | AHT10 | AHT20 |
|---|---|---|
| Fabrikant | Aosong (ASAIR) | Aosong (ASAIR) |
| Interface en adres | I2C, 0x38 (0x39 met de ADR-pin) | I2C, vast 0x38 |
| Voedingsspanning van de chip | 1,8–3,6 V | 2,0–5,5 V |
| Temperatuurbereik / nauwkeurigheid | -40…+85 °C / ±0,3 °C | -40…+85 °C / ±0,3 °C |
| Vochtigheidsbereik / nauwkeurigheid | 0–100% RV / ±2% RV | 0–100% RV / ±2% RV |
| Resolutie | 0,01 °C / 0,024% RV | 0,01 °C / 0,024% RV |
| Meettijd | Ongeveer 75 ms | Ongeveer 80 ms |
| Slaapstroom | Minder dan 1 µA | Minder dan 1 µA |
| Initialisatiecommando | 0xE1 0x08 0x00 | 0xBE 0x08 0x00 |
| CRC-controle | Nee | Ja (7e byte) |
AHT20 vs DHT11 vs DHT22
In de Arduino-wereld zijn de DHT11 en DHT22 de bekendste temperatuur- en vochtigheidssensoren. Ze communiceren via één datalijn met een tijdgevoelig eigen protocol; de bibliotheek schakelt bij elke meting enkele milliseconden de interrupts uit, en de DHT11 kun je één keer per seconde uitlezen, de DHT22 één keer per twee seconden. De AHT20 gebruikt standaard I2C: een OLED-display, RTC of druksensor kan dezelfde twee draden delen, en je krijgt geen gemiste metingen door timingfouten. RV staat voor relatieve vochtigheid.
| Eigenschap | AHT10 / AHT20 | DHT11 | DHT22 (AM2302) |
|---|---|---|---|
| Communicatie | I2C (2 draden) | Eigen protocol met één draad | Eigen protocol met één draad |
| Temperatuurbereik | -40…+85 °C | 0…50 °C | -40…+80 °C |
| Nauwkeurigheid temperatuur | ±0,3 °C | ±2 °C | ±0,5 °C |
| Vochtigheidsbereik | 0–100% RV | 20–90% RV | 0–100% RV |
| Nauwkeurigheid vochtigheid | ±2% RV | ±5% RV | ±2–5% RV |
| Resolutie | 0,01 °C / 0,024% RV | 1 °C / 1% RV | 0,1 °C / 0,1% RV |
| Uitleesinterval | Ongeveer 80 ms (2 s aanbevolen) | 1 s | 2 s |
| Andere apparaten op dezelfde bus | Ja (I2C) | Nee | Nee |
| Prijs | Laag | Laagst | Gemiddeld |
Welke kies je? Voor een eenvoudig project dat alleen controleert op "warm of koud" is de DHT11 genoeg. Maar met een fout van ±5% kun je 40% niet van 45% luchtvochtigheid onderscheiden, en dat verschil telt bij het volgen van de luchtvochtigheid binnen, in kassen of in broedmachines. De DHT22 komt qua nauwkeurigheid in de buurt van de AHT20, maar is duurder en langzamer. Wil je ook de luchtdruk meten, dan is de BME280 een goed alternatief; voor een uitgebreide vergelijking zie je de berichten vergelijking van temperatuursensoren en BME280 en BMP280.
AHT10 / AHT20 aansluiten: Uno, ESP32 en Pico
| Pin van de AHT-module | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VIN / VCC | 5V (of 3.3V) | 3V3 | 3V3(OUT), pin 36 |
| GND | GND | GND | GND (bijv. pin 38) |
| SCL | A5 | GPIO 22 | GP5 (pin 7) |
| SDA | A4 | GPIO 21 | GP4 (pin 6) |
De meeste AHT10- en AHT20-modules in de handel hebben een kleine 3,3 V-regelaar en pull-upweerstanden voor de I2C-lijnen, zodat je ze rechtstreeks op de 5 V van de Uno kunt aansluiten. Op de Uno R3 zijn de pins SDA en SCL ook beschikbaar op twee pins naast AREF; intern zijn dat dezelfde lijnen als A4 en A5. Een andere veelvoorkomende print combineert de AHT20 met een BMP280: de AHT20 zit op 0x38 en de BMP280 meestal op 0x77, zodat je met één aansluiting temperatuur, luchtvochtigheid en luchtdruk samen kunt uitlezen. Wat is I2C is een goede plek om met de basis te beginnen.
Stap voor stap: je eerste meting met Arduino
- Open de Library Manager in de Arduino IDE, zoek naar Adafruit AHTX0 en installeer de bibliotheek; kies als er naar afhankelijkheden wordt gevraagd Install all, zodat ook Adafruit BusIO en Adafruit Unified Sensor worden geïnstalleerd.
- Sluit de sensor aan volgens de tabel hierboven: VIN op 5V, GND op GND, SCL op A5, SDA op A4.
- Als je niet zeker weet of de sensor op de bus verschijnt, draai dan eerst een I2C-scannersketch; je zou adres 0x38 in de lijst moeten zien.
- Upload de onderstaande code en open de Serial Monitor op 9600 baud.
- Blaas zachtjes op de sensor: je ziet de vochtigheidswaarde binnen een paar seconden snel stijgen en daarna langzaam terugkeren naar de oude waarde.
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}| Regel | Wat het doet |
|---|---|
| aht.begin() | Zoekt de sensor op adres 0x38, reset hem en controleert de kalibratiestatus. Geeft false terug als de sensor niet wordt gevonden. |
| aht.getEvent(&humidity, &temp) | Stuurt het meetcommando (0xAC), wacht tot de meting klaar is en leest beide waarden in één keer uit. |
| temp.temperature | Temperatuur in graden Celsius (float). |
| humidity.relative_humidity | Relatieve luchtvochtigheid in procenten (float). |
| delay(2000) | Wacht 2 seconden tussen metingen; voorkomt dat de chip zichzelf opwarmt. |
Van ruwe data naar temperatuur en luchtvochtigheid: de formules
De sensor uitlezen zonder bibliotheek is ook makkelijk, want het protocol bestaat uit maar een paar commando's. Om een meting te starten schrijf je de bytes 0xAC 0x33 0x00 naar de sensor; na ongeveer 80 ms lees je zes bytes, waarvan de eerste de statusbyte is. Als het meest significante bit (bit 7, 0x80) 1 is, is de sensor nog aan het meten; als bit 3 (0x08) 1 is, is de sensor gekalibreerd. De volgende vijf bytes bevatten naast elkaar de 20-bits vochtigheidswaarde (S_RH) en de 20-bits temperatuurwaarde (S_T). De omrekenformules zijn: RH = S_RH / 2^20 × 100 en T = S_T / 2^20 × 200 − 50. Als de ruwe vochtigheidswaarde bijvoorbeeld 471.859 is, is de luchtvochtigheid 471.859 / 1.048.576 × 100 ≈ 45,0%; als de ruwe temperatuur 372.244 is, is de temperatuur 372.244 / 1.048.576 × 200 − 50 ≈ 21,0 °C. De MicroPython-code in het Pico-gedeelte volgt precies deze stappen.
De luchtvochtigheid binnen volgen in de winter: waarom het ertoe doet
Achter winterklachten als een droge keel, statische schokjes of gesprongen lippen zit vaak een lage luchtvochtigheid. De reden is een simpele natuurwet: de hoeveelheid waterdamp die lucht kan bevatten stijgt snel met de temperatuur. Bij 0 °C kan een kubieke meter lucht hooguit ongeveer 4,8 gram waterdamp bevatten, terwijl die grens bij 21 °C stijgt naar ongeveer 18,3 gram. Buitenlucht van 0 °C en 80% vochtigheid bevat ongeveer 3,9 g/m³ water. Als die lucht naar binnen komt en door de radiator wordt verwarmd tot 21 °C, verandert de hoeveelheid water erin niet, maar de hoeveelheid die de lucht kan bevatten wordt ongeveer viermaal zo groot; de relatieve luchtvochtigheid daalt naar 3,9 / 18,3 ≈ 21%. Dankzij de nauwkeurigheid van ±2% van de AHT20 zie je zulke veranderingen gemakkelijk, en ook of je luchtbevochtiger echt werkt.
| Relatieve luchtvochtigheid | Situatie | Wat te doen |
|---|---|---|
| Onder 30% | Erg droog: droge keel, ogen en huid, statische elektriciteit | Gebruik een luchtbevochtiger, zet de verwarming iets lager |
| 30–40% | Licht droog, gebruikelijk in de winter | Een kom water in de kamer zetten of de was binnen drogen helpt |
| 40–60% | Ideaal bereik | Houd het zo |
| 60–70% | Vochtig: ramen beginnen te beslaan | Ventileer kort en vaak |
| Boven 70% | Groot risico op schimmel en huisstofmijt | Ventileer en gebruik zo nodig een ontvochtiger |
Een ander voordeel van het meten van de luchtvochtigheid is dat je het dauwpunt kunt berekenen. Het dauwpunt is de temperatuur waarbij waterdamp in de lucht begint te condenseren. Als een ruit of het binnenoppervlak van een buitenmuur onder deze temperatuur komt, vormen zich daar waterdruppels en uiteindelijk begint er schimmel. Het wordt berekend met de Magnus-formule: γ = ln(RH/100) + 17.62·T / (243.12 + T) en Td = 243.12·γ / (17.62 − γ). Als de kamer bijvoorbeeld 21 °C is bij 60% luchtvochtigheid, is het dauwpunt ongeveer 12,9 °C; in de winter kan het binnenoppervlak van het glas gemakkelijk onder 10 °C komen, waardoor het raam beslaat. Als de luchtvochtigheid in dezelfde kamer daalt naar 45%, zakt het dauwpunt naar 8,6 °C en neemt het risico op beslaan merkbaar af. In de ESP32-code laten we deze berekening rechtstreeks op het display zien.
Vochtigheidsdisplay op een OLED (Arduino Uno)
Laten we nu samenbrengen wat je hebt geleerd: met een Arduino Uno, een AHT20 en een 0,96-inch SSD1306 OLED-display bouw je een vochtigheidsdisplay dat je op je bureau kunt zetten. Omdat beide modules I2C gebruiken, sluit je ze parallel aan op dezelfde pins A4 (SDA) en A5 (SCL); de OLED zit op 0x3C en de AHT20 op 0x38, dus er is geen conflict. Voor het installeren van de bibliotheek van het display en andere details zie je Een OLED-display (SSD1306) gebruiken.

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}De code doet elke twee seconden een meting; bovenaan schrijft hij de temperatuur in kleine tekst en in het midden de luchtvochtigheid in tekst die drie keer zo groot is. De regel eronder vertelt of de lucht droog, ideaal of vochtig is volgens de bereiken in de tabel hierboven, en de balk onderaan toont de luchtvochtigheid visueel. Omdat de framebuffer van de OLED ongeveer 1 KB van het 2 KB RAM van de Uno gebruikt, hebben we de vaste teksten met de F()-macro geschreven. Als je de sensor een paar centimeter verderop aan het eind van een draad plaatst in plaats van hem direct op het display en de Arduino te plakken, beïnvloedt de warmte van de boards de meting niet.
AHT20 met de ESP32: dauwpunt en min./max. luchtvochtigheid
Dezelfde Adafruit-bibliotheken werken ongewijzigd op de ESP32; het enige verschil zijn de I2C-pins. Op ESP32 DevKit-boards is de standaard SDA-pin GPIO 21 en SCL GPIO 22, en je kunt de pins expliciet opgeven met Wire.begin(21, 22). De onderstaande code toont luchtvochtigheid en temperatuur op de OLED, berekent het dauwpunt met de Magnus-formule en bewaart ook de laagste en hoogste luchtvochtigheid sinds het apparaat is ingeschakeld. Omdat we millis() gebruiken in plaats van delay(), blijft loop() vrij; als je de data later via Wi-Fi naar je telefoon wilt sturen of op een webpagina wilt tonen, hoef je de code niet helemaal opnieuw te schrijven. Voor de Wi-Fi-kant kun je beginnen met Wat is de ESP32.
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 en MicroPython met de AHT20
Op de Raspberry Pi Pico heb je zelfs geen aparte MicroPython-bibliotheek nodig; het protocol is zo eenvoudig dat je het zelf in een paar regels kunt schrijven. De code wacht eerst 40 ms op de opstarttijd van de sensor, controleert het kalibratiebit in de statusbyte en stuurt zo nodig het initialisatiecommando. Daarna stuurt hij bij elke meting het 0xAC-commando, wacht 80 ms, leest tot het busy-bit weer 0 is en berekent het resultaat met de hierboven beschreven formules. Gebruik je een AHT10, roep dan gewoon aht_init(True) aan. De I2C0-bus van de Pico zit hier op de pins GP4 (SDA) en GP5 (SCL); als je een OLED wilt toevoegen, kun je het stuurprogramma ssd1306.py gebruiken met hetzelfde i2c-object. Voor het opzetten van MicroPython zie je Wat is de 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 secondsProjectideeën met de AHT20
- Vochtigheidsdisplay voor de kamer: zet in elke kamer een AHT20 en een kleine OLED om te zien welke kamer in de winter het droogst is.
- Automatische luchtbevochtiger: schakel de luchtbevochtiger met een relaismodule in als de luchtvochtigheid onder 40% komt en schakel hem bij 50% uit.
- Ventilatorbesturing voor de badkamer: laat de afzuigventilator draaien als de luchtvochtigheid na het douchen boven 70% komt; je kunt de schakeling uit Arduino-ventilatorbesturing gebruiken.
- Minikas en broedmachine: regel temperatuur en luchtvochtigheid tegelijk; het slimme-kasproject is een goed beginpunt.
- Datalogger op batterijen: zet de ESP32 in deep sleep en meet elke 10 minuten; de AHT20 verbruikt in slaapstand minder dan een microampère.
- Slimme thermostaat: meet de temperatuur tot op ±0,3 °C en schakel de cv-ketel met een relais aan en uit; details staan in het bericht Arduino-thermostaat.
- Vochtalarm voor kledingkast en opslag: laat een buzzer klinken als de luchtvochtigheid boven 65% komt en onderneem actie voordat er schimmel ontstaat.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Melding "not found", begin() geeft false terug | SDA en SCL verwisseld, losse draad of verkeerde voeding | Controleer de draden en zoek met een I2C-scanner naar adres 0x38 |
| Scanner vindt helemaal geen adres | De module heeft geen pull-upweerstanden of GND is niet gemeenschappelijk | Voeg pull-ups van 4,7 kΩ toe van SDA en SCL naar 3,3 V en verbind de massa's |
| Temperatuur is 2–3 °C te hoog | De sensor wordt beïnvloed door warmte van de Arduino, de regelaar of het display | Verplaats de sensor op een draad weg van de boards en maak luchtgaten in de behuizing |
| Luchtvochtigheid blijft rond 100% of verandert nooit | De sensor is blootgesteld aan condens of het oppervlak is vervuild | Laat hem een paar uur op een droge, warme plek liggen en raak het sensoroppervlak niet aan |
| Af en toe onzinwaarden (bijv. -50 °C) | Uitlezen voordat de meting klaar is, te vaak uitlezen of ruis op de bus | Wacht minstens 2 s tussen metingen, houd draden kort en controleer de CRC op de AHT20 |
| De AHT10 hangt als je hem met de OLED gebruikt | Sommige AHT10-modules hebben problemen met het delen van de I2C-bus | Stap over op de AHT20 of sluit de AHT10 aan op een aparte I2C-bus |
Ondanks de lage prijs biedt de AHT10, en vooral de AHT20, ruim voldoende nauwkeurigheid voor het volgen van het binnenklimaat, en dankzij I2C is hij heel gemakkelijk aan te sluiten en te combineren met andere modules. Als je eerder bent begonnen met de DHT11, kun je hetzelfde project naar de AHT20 overzetten door een paar regels te wijzigen en zelf zien hoeveel stabieler de metingen worden. In de BlueGrays-app vind je stap-voor-stap-schakelschema's en code voor projecten zoals DHT11-temperatuur- en vochtigheidsmeting, een ESP32-temperatuur- en vochtigheidsdisplay met een LCD, een OLED-weerdisplay en een temperatuurlogger die naar een microSD-kaart schrijft, en je kunt ze eenvoudig aanpassen voor de AHT20.
Veelgestelde vragen
Wat is het verschil tussen de AHT10 en AHT20?
Beide hebben hetzelfde meetbereik en ongeveer dezelfde nauwkeurigheid van ±0,3 °C en ±2% RV. De AHT20 biedt een breder voedingsbereik (2,0–5,5 V), CRC-controle van de data en betere stabiliteit op de lange termijn, en ook de initialisatiecommando's verschillen. Voor nieuwe projecten is de AHT20 de betere keuze.
Wat is het I2C-adres van de AHT20?
Het adres van de AHT20 staat vast op 0x38 en kan niet worden gewijzigd. Bij de AHT10 kun je met de ADR-pin kiezen tussen 0x38 of 0x39. Om twee AHT20's te gebruiken heb je een tweede I2C-bus of een I2C-multiplexer zoals de TCA9548A nodig.
Is de AHT20 beter dan de DHT22?
Voor de meeste projecten binnenshuis is de AHT20 beter: de nauwkeurigheid is gelijk aan of beter dan die van de DHT22, hij is goedkoper, meet sneller en deelt dankzij I2C dezelfde twee draden met andere modules. Het voordeel van de DHT22 is dat hij met lange kabels kan werken; I2C werkt over het algemeen het best met korte kabels van minder dan 1 meter.
Kan ik de AHT10 op 5 V op een Arduino aansluiten?
Modules met een ingebouwde regelaar werken veilig op 5 V; controleer of de print een kleine regelaar met drie pootjes en een VIN-opdruk heeft. Bij kale AHT10-printjes zonder regelaar is de bovengrens van de chip 3,6 V, dus je moet de module voeden met 3,3 V.
Waarom toont mijn AHT20 een te hoge temperatuur?
De meest voorkomende reden is dat de sensor wordt beïnvloed door warmte van de Arduino, de spanningsregelaar of het display. Te vaak meten verwarmt de chip ook een beetje. Houd de sensor op een draad weg van de boards en meet niet vaker dan één keer per 2 seconden.
Wat is de ideale luchtvochtigheid in huis?
Binnenshuis wordt 40–60% relatieve luchtvochtigheid over het algemeen als ideaal beschouwd. In de winter kan verwarming de luchtvochtigheid onder 30% duwen, wat een droge keel en droge huid verergert. Boven 60% krijg je beslagen ramen en na verloop van tijd een risico op schimmel.
Projecten om hierna te bouwen
Alle projecten bekijken
Temperatuur en luchtvochtigheid met DHT11
Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
Dit project meet de omgevingstemperatuur en luchtvochtigheid met een DHT22-sensor en toont de gegevens in realtime op een 16x2 I2C-LCD. De data wordt met het one-wire-protocol via de Adafruit DHT-bibliotheek uit de sensor gelezen. Dit project is de basis voor IoT-weerstations, slimme domotica of omgevingsbewaking in kassen. De communicatie met de DHT22 loopt via pin GPIO 4 van de ESP32.

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.

ESP32 HTTPClient + weer-API (met SSD1306 OLED-display)
In dit project doet de ESP32 via internet een REST API-aanroep naar een weer-API (wttr.in) met HTTPClient.h. Anders dan bij de I2C-LCD-versie gebruiken we hier een SSD1306 OLED-display (128×64), met grote tekst en vectoricoontjes voor een rijkere weergave. Zeven weericonen (zonnig, regenachtig, sneeuw en meer) worden direct getekend, zonder bitmapbestanden.

ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)
De Deep Sleep-modus van de ESP32 schakelt de CPU en de meeste randapparatuur uit, waardoor het stroomverbruik daalt tot ongeveer 10µA; dat is cruciaal voor IoT-apparaten op batterijen. Dit project gebruikt drie wekbronnen: een timer (15 s), een externe pin (EXT0, de knop op GPIO 33) en een touchpin (T0/GPIO 4). Tellers met RTC_DATA_ATTR blijven behouden tijdens deep sleep.

Temperatuur meten met NTC en 2x16 LCD-display
Meet de temperatuur om je heen met een sensor die op een klein kraaltje lijkt. Dit onderdeel, een NTC, laat elektriciteit makkelijker door naarmate het warmer wordt; de Arduino leest die verandering…

Dotmatrixklok, kalender en weerstation (MAX7219, DS1307)
Een scrollend tekstbord voor op je bureau of aan de muur dat om de beurt de tijd, de datum en het weer in de kamer toont.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

