Composants · 12 min de lecture

Capteur AHT10 AHT20 Arduino : guide température et humidité

Branche l'AHT10 ou l'AHT20 sur Arduino : câblage I2C 0x38, bibliothèque AHTX0, comparatif DHT11/DHT22, afficheur OLED, codes ESP32 et Raspberry Pi Pico.

L'AHT10 est devenu ces dernières années l'un des capteurs préférés de ceux qui veulent mesurer en même temps la température et l'humidité avec Arduino. Fabriqué par Aosong (ASAIR), l'AHT10 et sa version améliorée, l'AHT20, se branchent en I2C avec seulement quatre fils, mesurent la température avec une précision d'environ ±0,3 °C et l'humidité relative à ±2 %, et fournissent une valeur numérique calibrée en usine. Bref, c'est un choix bien plus précis que le DHT11, et moins cher et plus rapide que le DHT22.

Dans cet article, tu vas voir pas à pas les différences entre l'AHT10 et l'AHT20, le branchement sur Arduino Uno, ESP32 et Raspberry Pi Pico, la première mesure avec la bibliothèque Adafruit AHTX0 et la façon dont la température et l'humidité se calculent à partir des données brutes envoyées par le capteur. Ensuite, tu comprendras pourquoi l'humidité chute dans la maison quand le chauffage tourne en hiver, quelle est la plage d'humidité idéale et comment le calcul du point de rosée indique le risque de buée sur les vitres, puis tu réaliseras un petit afficheur d'humidité d'intérieur sur écran OLED.

Qu'est-ce que l'AHT10 / AHT20 et comment ça marche ?

Chacun de ces capteurs contient deux éléments de mesure distincts. L'humidité est mesurée par un élément capacitif : entre deux électrodes se trouve une fine couche de polymère qui absorbe la vapeur d'eau de l'air. Plus l'humidité ambiante augmente, plus le polymère retient d'eau, sa constante diélectrique change et la capacité de l'élément augmente de façon mesurable. La température, elle, est mesurée par un capteur à semi-conducteur placé sur la puce. Ces deux signaux analogiques sont convertis en nombres par un ASIC situé dans le même boîtier, avec un CAN de 20 bits, puis corrigés par des coefficients de calibration définis en usine. Ton microcontrôleur reçoit donc des nombres bruts déjà calibrés ; ton seul travail est de les convertir en degrés Celsius et en pourcentage avec une formule simple.

L'AHT10 et l'AHT20 sont presque identiques de l'extérieur, et leurs plages de mesure et leurs précisions sont les mêmes. La différence tient aux détails : l'AHT20 accepte une plage d'alimentation plus large (2,0–5,5 V), a une meilleure stabilité à long terme, envoie un octet CRC pour vérifier que les données lues ne sont pas corrompues, et sa commande d'initialisation est différente (0xE1 pour l'AHT10, 0xBE pour l'AHT20). Sur l'AHT10, la broche de sélection d'adresse permet d'utiliser 0x38 ou 0x39, alors que l'adresse de l'AHT20 est fixée à 0x38. On sait aussi que certains modules AHT10 posent problème quand ils partagent le bus I2C avec d'autres composants ; pour un nouveau projet, il est généralement plus judicieux de prendre un AHT20.

CaractéristiqueAHT10AHT20
FabricantAosong (ASAIR)Aosong (ASAIR)
Interface et adresseI2C, 0x38 (0x39 avec la broche ADR)I2C, 0x38 fixe
Tension d'alimentation de la puce1,8–3,6 V2,0–5,5 V
Plage / précision de température-40…+85 °C / ±0,3 °C-40…+85 °C / ±0,3 °C
Plage / précision d'humidité0–100 % HR / ±2 % HR0–100 % HR / ±2 % HR
Résolution0,01 °C / 0,024 % HR0,01 °C / 0,024 % HR
Durée de mesureEnviron 75 msEnviron 80 ms
Courant en veilleMoins de 1 µAMoins de 1 µA
Commande d'initialisation0xE1 0x08 0x000xBE 0x08 0x00
Contrôle CRCNonOui (7e octet)

Comparatif AHT20, DHT11 et DHT22

Dans le monde Arduino, les capteurs de température et d'humidité les plus connus sont le DHT11 et le DHT22. Ils communiquent sur un seul fil de données avec un protocole propriétaire très sensible au timing ; la bibliothèque désactive les interruptions pendant quelques millisecondes à chaque lecture, et on peut lire le DHT11 une fois par seconde et le DHT22 une fois toutes les deux secondes. L'AHT20 utilise l'I2C standard : tu peux brancher sur les deux mêmes fils un écran OLED, une RTC ou un capteur de pression, et tu n'as pas de lectures ratées à cause d'erreurs de timing. HR signifie humidité relative.

CaractéristiqueAHT10 / AHT20DHT11DHT22 (AM2302)
CommunicationI2C (2 fils)Protocole propriétaire à un filProtocole propriétaire à un fil
Plage de température-40…+85 °C0…50 °C-40…+80 °C
Précision de température±0,3 °C±2 °C±0,5 °C
Plage d'humidité0–100 % HR20–90 % HR0–100 % HR
Précision d'humidité±2 % HR±5 % HR±2–5 % HR
Résolution0,01 °C / 0,024 % HR1 °C / 1 % HR0,1 °C / 0,1 % HR
Intervalle de lectureEnviron 80 ms (2 s conseillées)1 s2 s
Autres composants sur le même busOui (I2C)NonNon
PrixBasLe plus basMoyen

Lequel choisir ? Pour un projet simple qui se demande seulement « chaud ou froid », le DHT11 suffit. Mais mesurer l'humidité d'une pièce avec une marge d'erreur de ±5 % veut dire que tu ne verras pas la différence entre 40 % et 45 % ; pour le suivi de l'humidité d'intérieur, une serre ou une couveuse, cette différence compte. Le DHT22 se rapproche de l'AHT20 en précision, mais il est plus cher et plus lent. Si tu veux aussi mesurer la pression, le BME280 est une bonne alternative ; pour une comparaison détaillée, consulte le comparatif des capteurs de température et BME280 et BMP280.

Branchement de l'AHT10 / AHT20 : Uno, ESP32 et Pico

Broche du module AHTArduino UnoESP32Raspberry Pi Pico
VIN / VCC5V (ou 3.3V)3V33V3(OUT), broche 36
GNDGNDGNDGND (p. ex. broche 38)
SCLA5GPIO 22GP5 (broche 7)
SDAA4GPIO 21GP4 (broche 6)

La plupart des modules AHT10 et AHT20 du commerce embarquent un petit régulateur 3,3 V et des résistances de pull-up pour les lignes I2C ; tu peux donc les brancher directement sur l'Uno en 5 V. Sur l'Uno R3, les broches SDA et SCL existent aussi sur deux broches à côté d'AREF ; elles sont reliées en interne à A4 et A5. Une autre carte très courante combine un AHT20 et un BMP280 : l'AHT20 est à l'adresse 0x38, le BMP280 généralement à 0x77, et avec un seul branchement tu lis température, humidité et pression ensemble. Pour les bases de l'I2C, l'article Qu'est-ce que l'I2C est un bon point de départ.

N'alimente pas en 5 V sans être sûr que le module a un régulateur. Si tu ne vois sur la carte que la puce du capteur et quelques résistances (notamment sur certaines cartes AHT10 nues), tu dois l'alimenter en 3,3 V ; la limite supérieure de la puce AHT10 est de 3,6 V. De plus, comme l'adresse de l'AHT20 ne peut pas être modifiée, tu ne peux pas brancher deux AHT20 sur le même bus I2C ; pour un deuxième capteur, utilise le second bus I2C de l'ESP32 ou du Pico, ou un multiplexeur I2C comme le TCA9548A.

Pas à pas : première mesure avec Arduino

  1. Dans l'IDE Arduino, ouvre le Gestionnaire de bibliothèques, cherche Adafruit AHTX0 et installe-la ; quand il te demande les dépendances, choisis Install all pour installer aussi Adafruit BusIO et Adafruit Unified Sensor.
  2. Branche le capteur selon le tableau ci-dessus : VIN sur 5V, GND sur GND, SCL sur A5, SDA sur A4.
  3. Si tu n'es pas sûr que le capteur apparaisse sur le bus, lance d'abord un scanner I2C ; tu dois voir l'adresse 0x38 dans la liste.
  4. Téléverse le code ci-dessous et ouvre le Moniteur série à 9600 bauds.
  5. Souffle doucement sur le capteur : tu verras la valeur d'humidité monter vite en quelques secondes, puis revenir lentement à sa valeur d'origine.
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}
LigneCe qu'elle fait
aht.begin()Cherche le capteur à l'adresse 0x38, le réinitialise et vérifie l'état de calibration. Renvoie false si le capteur est introuvable.
aht.getEvent(&humidity, &temp)Envoie la commande de mesure (0xAC), attend la fin de la mesure et lit les deux valeurs à la fois.
temp.temperatureTempérature en degrés Celsius (float).
humidity.relative_humidityHumidité relative en pourcentage (float).
delay(2000)Attend 2 secondes entre les mesures ; évite l'auto-échauffement de la puce.

Des données brutes à la température et à l'humidité : les formules

Lire le capteur sans bibliothèque est aussi facile, car le protocole ne comporte que quelques commandes. Pour lancer une mesure, on écrit les octets 0xAC 0x33 0x00 dans le capteur ; environ 80 ms plus tard, le premier des six octets lus est l'octet d'état. Si le bit de poids fort de cet octet (bit 7, 0x80) vaut 1, le capteur est encore en train de mesurer ; si le bit 3 (0x08) vaut 1, le capteur est calibré. Les cinq octets suivants contiennent côte à côte l'humidité sur 20 bits (S_RH) et la température sur 20 bits (S_T). Les formules de conversion sont : RH = S_RH / 2^20 × 100 et T = S_T / 2^20 × 200 − 50. Par exemple, si la valeur brute d'humidité est 471 859, l'humidité vaut 471 859 / 1 048 576 × 100 ≈ 45,0 % ; si la température brute est 372 244, la température vaut 372 244 / 1 048 576 × 200 − 50 ≈ 21,0 °C. Le code MicroPython de la section Pico applique exactement ces étapes.

Lire le capteur plusieurs fois par seconde peut sembler tentant, mais chaque mesure chauffe la puce, même très peu. Le fabricant recommande de limiter les mesures à une toutes les 2 secondes pour que l'auto-échauffement reste négligeable. Pour une grandeur qui varie lentement comme l'humidité d'intérieur, lire toutes les 5 à 10 secondes est largement suffisant.

Suivre l'humidité de la maison en hiver : pourquoi c'est important

En hiver, derrière la gorge sèche, les décharges d'électricité statique ou les lèvres gercées à la maison, il y a souvent une humidité trop basse. La cause est une simple loi physique : la quantité de vapeur d'eau que l'air peut contenir augmente vite avec la température. À 0 °C, un mètre cube d'air peut contenir au plus environ 4,8 grammes de vapeur d'eau ; à 21 °C, cette limite monte à environ 18,3 grammes. L'air extérieur à 0 °C et 80 % d'humidité contient environ 3,9 g/m³ d'eau. Quand cet air entre et est chauffé à 21 °C par le radiateur, la quantité d'eau qu'il contient ne change pas, mais celle qu'il pourrait contenir est environ quatre fois plus grande ; l'humidité relative tombe à 3,9 / 18,3 ≈ 21 %. La précision de ±2 % de l'AHT20 te permet de voir facilement ce genre de variations et de savoir si ton humidificateur sert vraiment à quelque chose.

Humidité relativeSituationQue faire ?
Moins de 30 %Très sec : gorge, yeux et peau secs, électricité statiqueUtilise un humidificateur, baisse un peu le chauffage
30–40 %Un peu sec, fréquent en hiverPoser un récipient d'eau dans la pièce ou faire sécher du linge aide
40–60 %Plage idéaleGarde cet état
60–70 %Humide : la buée apparaît sur les vitresAère brièvement et souvent
Plus de 70 %Risque élevé de moisissures et d'acariensAère, utilise un déshumidificateur si nécessaire

Mesurer l'humidité permet aussi de calculer le point de rosée. Le point de rosée est la température à laquelle la vapeur d'eau de l'air commence à se condenser. Si la vitre ou la face intérieure d'un mur extérieur descend sous cette température, des gouttelettes d'eau s'y forment et, avec le temps, la moisissure apparaît. Il se calcule avec la formule de Magnus : γ = ln(RH/100) + 17,62·T / (243,12 + T) et Td = 243,12·γ / (17,62 − γ). Par exemple, si la pièce est à 21 °C et 60 % d'humidité, le point de rosée est d'environ 12,9 °C ; en hiver, la face intérieure d'une vitre descend facilement sous 10 °C, donc la vitre s'embue. Si l'humidité de la même pièce descend à 45 %, le point de rosée tombe à 8,6 °C et le risque de buée diminue nettement. Dans le code ESP32, nous afficherons ce calcul directement à l'écran.

Afficheur d'humidité sur écran OLED (Arduino Uno)

Rassemblons maintenant ce que tu as appris : avec un Arduino Uno, un AHT20 et un écran OLED SSD1306 de 0,96 pouce, tu vas réaliser un afficheur d'humidité à poser sur ton bureau. Comme les deux modules utilisent l'I2C, ils se branchent en parallèle sur les mêmes broches A4 (SDA) et A5 (SCL) ; l'OLED est à l'adresse 0x3C et l'AHT20 à 0x38, il n'y a donc pas de conflit. Pour l'installation de la bibliothèque de l'écran et les autres détails, jette un œil à l'article Utiliser un écran OLED (SSD1306).

Écran OLED I2C 0,96 pouce SSD1306
L'écran OLED SSD1306 de 0,96 pouce partage le même bus I2C que l'AHT20 : l'écran est à l'adresse 0x3C, le capteur à 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}

Le code fait une mesure toutes les deux secondes ; il affiche la température en petits caractères en haut et l'humidité en caractères trois fois plus grands au milieu. La ligne en dessous indique, selon les plages du tableau ci-dessus, si l'air est sec, idéal ou humide ; la barre tout en bas montre visuellement l'humidité. Comme le tampon d'image de l'OLED utilise environ 1 Ko des 2 Ko de RAM de l'Uno, nous avons écrit les textes fixes avec la macro F(). Si tu places le capteur à quelques centimètres au bout d'un câble, plutôt que collé contre l'écran et l'Arduino, la chaleur dégagée par les cartes ne faussera pas la mesure.

AHT20 avec ESP32 : point de rosée et humidité min/max

Sur l'ESP32, les mêmes bibliothèques Adafruit fonctionnent sans changement ; la seule différence concerne les broches I2C. Sur les cartes ESP32 DevKit, la broche SDA par défaut est GPIO 21 et la broche SCL GPIO 22, et tu peux les indiquer explicitement avec Wire.begin(21, 22). Le code ci-dessous affiche l'humidité et la température sur l'OLED, calcule le point de rosée avec la formule de Magnus et mémorise aussi l'humidité minimale et maximale depuis la mise sous tension. Comme nous utilisons millis() au lieu de delay(), loop() reste libre ; si tu veux plus tard envoyer les données à ton téléphone en Wi-Fi ou les afficher sur une page web, tu n'auras pas à tout réécrire. Pour la partie Wi-Fi, tu peux commencer par l'article Qu'est-ce que l'ESP32.

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 et MicroPython avec l'AHT20

Sur le Raspberry Pi Pico, tu n'as même pas besoin d'une bibliothèque pour MicroPython ; le protocole est si simple que tu peux l'écrire toi-même en quelques lignes. Le code attend d'abord 40 ms pour le démarrage du capteur, regarde le bit de calibration de l'octet d'état et envoie la commande d'initialisation si nécessaire. Ensuite, à chaque mesure, il envoie la commande 0xAC, attend 80 ms, lit jusqu'à ce que le bit occupé retombe à zéro et calcule le résultat avec les formules vues plus haut. Si tu utilises un AHT10, il suffit d'appeler aht_init(True). Le bus I2C0 du Pico est ici sur les broches GP4 (SDA) et GP5 (SCL) ; si tu veux ajouter un OLED, tu peux utiliser le pilote ssd1306.py avec le même objet i2c. Pour l'installation de MicroPython, consulte l'article Qu'est-ce que le 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

Idées de projets avec l'AHT20

  • Afficheur d'humidité de pièce : place un AHT20 et un petit OLED dans chaque pièce pour voir laquelle est la plus sèche en hiver.
  • Humidificateur automatique : quand l'humidité descend sous 40 %, fais démarrer l'humidificateur avec un module relais, et coupe-le à 50 %.
  • Commande du ventilateur de salle de bains : quand l'humidité dépasse 70 % après la douche, fais démarrer l'extracteur ; tu peux utiliser le montage de l'article Commande de ventilateur avec Arduino.
  • Mini-serre et couveuse : contrôle la température et l'humidité en même temps ; le projet de serre intelligente est un bon point de départ.
  • Enregistreur de données sur batterie : mets l'ESP32 en mode deep sleep et mesure toutes les 10 minutes ; l'AHT20 consomme moins d'un microampère en veille.
  • Thermostat intelligent : mesure la température à ±0,3 °C et allume ou coupe la chaudière avec un relais ; les détails sont dans l'article Thermostat Arduino.
  • Alarme d'humidité pour garde-robe et cave : quand l'humidité dépasse 65 %, préviens avec un buzzer et agis avant que la moisissure n'apparaisse.

Erreurs courantes et solutions

SymptômeCause possibleSolution
Message « introuvable », begin() renvoie falseSDA et SCL inversés, fil mal branché ou mauvaise alimentationVérifie les câbles, cherche l'adresse 0x38 avec un scanner I2C
Le scanner ne trouve aucune adresseLe module n'a pas de résistance de pull-up ou la masse n'est pas communeAjoute des pull-up de 4,7 kΩ de SDA et SCL vers 3,3 V, relie les GND
La température est trop haute de 2–3 °CLe capteur subit la chaleur de l'Arduino, du régulateur ou de l'écranÉloigne le capteur des cartes avec un câble, perce des aérations dans le boîtier
L'humidité reste près de 100 % ou ne change jamaisLe capteur a subi de la condensation ou sa surface est encrasséeLaisse-le quelques heures dans un endroit sec et tiède, ne touche pas la surface du capteur
De temps en temps des valeurs absurdes (p. ex. -50 °C)Lecture avant la fin de la mesure, lectures trop fréquentes ou parasites sur le busAttends au moins 2 s entre les lectures, garde des câbles courts, vérifie le CRC sur l'AHT20
L'AHT10 bloque avec l'OLEDProblème de partage du bus I2C de certains modules AHT10Passe à l'AHT20 ou branche l'AHT10 sur un bus I2C séparé
Pour mesurer correctement, le capteur doit être en contact avec l'air. Si tu le mets dans un boîtier fermé, perce impérativement un trou devant le capteur et place-le dans un compartiment séparé du régulateur et du microcontrôleur qui chauffent. La lumière directe du soleil, le dessus d'un radiateur ou un coin de mur extérieur ne reflètent pas la vraie valeur de la pièce ; fais la mesure à hauteur de l'endroit où tu es assis, près du milieu de la pièce.

Malgré son prix bas, l'AHT10, et surtout l'AHT20, offre une précision largement suffisante pour suivre le climat intérieur, et grâce à l'I2C il est très facile à brancher et à associer à d'autres modules. Si tu as commencé avec un DHT11, tu peux porter le même projet sur l'AHT20 en changeant quelques lignes et constater par toi-même à quel point les mesures deviennent plus stables. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas et codes, des projets comme la mesure de température et d'humidité avec un DHT11, l'afficheur de température et d'humidité sur LCD avec ESP32, l'écran météo OLED et l'enregistreur de température sur carte microSD, et tu pourras facilement y adapter l'AHT20 comme capteur.

Questions fréquentes

Quelle est la différence entre l'AHT10 et l'AHT20 ?

Les deux ont la même plage de mesure et une précision d'environ ±0,3 °C et ±2 % HR. L'AHT20 offre une plage d'alimentation plus large (2,0–5,5 V), un contrôle des données par CRC et une meilleure stabilité à long terme ; les commandes d'initialisation sont aussi différentes. Pour un nouveau projet, mieux vaut choisir l'AHT20.

Quelle est l'adresse I2C de l'AHT20 ?

L'adresse de l'AHT20 est fixée à 0x38 et ne peut pas être modifiée. Sur l'AHT10, la broche ADR permet de choisir 0x38 ou 0x39. Pour utiliser deux AHT20 sur le même bus, il faut un second bus I2C ou un multiplexeur I2C comme le TCA9548A.

AHT20 ou DHT22 : lequel est le meilleur ?

Pour la plupart des projets d'intérieur, l'AHT20 est meilleur : précision égale ou supérieure à celle du DHT22, prix plus bas, mesure plus rapide, et grâce à l'I2C il partage les deux mêmes fils avec d'autres modules. L'avantage du DHT22 est qu'il peut fonctionner avec de longs câbles ; l'I2C fonctionne généralement le mieux avec des câbles courts, de moins d'un mètre.

Peut-on brancher l'AHT10 sur Arduino en 5 V ?

Les modules équipés d'un régulateur fonctionnent en toute sécurité en 5 V ; regarde s'il y a sur la carte un petit régulateur à trois pattes et l'inscription VIN. Sur les cartes AHT10 nues sans régulateur, la limite supérieure de la puce étant de 3,6 V, tu dois alimenter le module en 3,3 V.

Pourquoi mon AHT20 affiche-t-il une température trop élevée ?

La cause la plus fréquente est la chaleur dégagée par l'Arduino, le régulateur de tension ou l'écran, qui influence le capteur. Mesurer trop souvent chauffe aussi un peu la puce. Garde le capteur au bout d'un câble, loin des cartes, et fais les mesures au moins toutes les 2 secondes.

Quel taux d'humidité idéal dans une maison ?

Pour l'intérieur, une humidité relative de 40–60 % est généralement considérée comme idéale. En hiver, à cause du chauffage, l'humidité peut descendre sous 30 % ; la sécheresse de la gorge et de la peau augmente alors. Au-delà de 60 %, le risque de buée sur les vitres puis de moisissures apparaît.

Voir tous les projets
Température et humidité avec DHT11
AR-55Intermédiaire

Température et humidité avec DHT11

Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

4.7(47)
83
ESP32 DHT22 Température et humidité (avec écran LCD)
ES-15Intermédiaire

ESP32 DHT22 Température et humidité (avec écran LCD)

Il s'agit d'un projet permettant de mesurer la température ambiante et le taux d'humidité à l'aide d'un capteur DHT22 et d'afficher ces données en temps réel sur un écran LCD I2C 16x2. Les données du capteur sont lues à l'aide du protocole one-wire grâce à la bibliothèque Adafruit DHT. Ce projet constitue la base des stations météo IoT, de la domotique ou des systèmes de surveillance de l'environnement dans les serres.

4.8(38)
57
Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avancé
Premium

Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Construis avec l'ESP32 un enregistreur de température et d'humidité horodaté ! Un capteur DHT22 mesure la température et l'humidité une fois par minute, et chaque mesure est enregistrée sur une carte microSD au format CSV avec l'heure réelle du module RTC DS1307. L'écran OLED affiche en direct, en grands caractères, la dernière température, l'humidité, l'horodatage et le nombre d'enregistrements.

4.7(7)
12
ESP32 HTTPClient + API météo (avec écran OLED SSD1306)
ES-32Avancé
Premium

ESP32 HTTPClient + API météo (avec écran OLED SSD1306)

L'ESP32 appelle par Internet une API météo (wttr.in) en REST avec HTTPClient.h. Contrairement à la version LCD I2C, on utilise ici un écran OLED SSD1306 (128×64), avec un grand texte et des icônes vectorielles pour un affichage plus riche. Sept icônes météo (soleil, pluie, neige et plus) sont dessinées à la volée, sans fichier bitmap.

4.3(10)
22
Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)
ES-33Avancé
Premium

Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)

Le mode Deep Sleep de l'ESP32 coupe le CPU et la plupart des périphériques et réduit la consommation à environ 10µA, un point clé pour les objets IoT sur batterie. Ce projet utilise trois sources de réveil : un minuteur (15 s), une broche externe (EXT0, le bouton sur GPIO 33) et une broche tactile (T0/GPIO 4). Les compteurs marqués RTC_DATA_ATTR sont conservés pendant le deep sleep.

4.3(10)
16
Mesure de la température avec NTC et écran LCD 2x16
AR-44Débutant
Premium

Mesure de la température avec NTC et écran LCD 2x16

Mesure la température ambiante avec un capteur qui ressemble à une petite perle.

4.5(33)
44
Horloge matricielle, calendrier et station météo (MAX7219, DS1307)
AR-85Intermédiaire
Premium

Horloge matricielle, calendrier et station météo (MAX7219, DS1307)

Un panneau à texte défilant pour ton bureau ou ton mur, qui affiche tour à tour l'heure, la date et la météo de la pièce.

5.0(50)
66