Componenti · 11 min di lettura

AHT10 e AHT20 con Arduino: sensore di temperatura e umidità

Collega AHT10 e AHT20 ad Arduino: indirizzo I2C 0x38, libreria AHTX0, confronto con DHT11/DHT22, igrometro OLED, codice per Uno, ESP32 e Pico.

L'AHT10 è uno dei sensori più scelti negli ultimi anni da chi vuole misurare temperatura e umidità insieme nei progetti Arduino. Prodotto da Aosong (ASAIR), l'AHT10 e la sua versione migliorata AHT20 si collegano con soli quattro fili tramite I2C, misurano la temperatura con una precisione di circa ±0,3 °C e l'umidità relativa con ±2%, e restituiscono un valore digitale calibrato in fabbrica. In breve: molto più preciso del DHT11, più economico e più veloce del DHT22.

In questo articolo vedrai passo dopo passo le differenze tra AHT10 e AHT20, il collegamento ad Arduino Uno, ESP32 e Raspberry Pi Pico, la prima misura con la libreria Adafruit AHTX0 e come si calcolano temperatura e umidità a partire dai dati grezzi inviati dal sensore. Poi scoprirai perché in inverno, con i termosifoni accesi, l'umidità in casa scende, qual è l'intervallo ideale e come il calcolo del punto di rugiada mostra il rischio di vetri appannati. Infine costruirai un pratico igrometro da casa che mostra tutto su un piccolo display OLED.

Cos'è l'AHT10/AHT20 e come funziona?

All'interno di entrambi i sensori ci sono due elementi di misura distinti. L'umidità si misura con un elemento capacitivo: tra due elettrodi c'è un sottile strato di polimero che assorbe il vapore acqueo dell'aria. Più l'umidità sale, più acqua trattiene il polimero, la costante dielettrica cambia e la capacità dell'elemento aumenta in modo misurabile. La temperatura invece viene misurata da un sensore a semiconduttore sul chip. Questi due segnali analogici vengono convertiti in numeri da un ADC a 20 bit in un processore dedicato (ASIC) nello stesso package e corretti con i coefficienti di calibrazione impostati in fabbrica. Al microcontrollore arrivano così numeri grezzi già calibrati: a te basta convertirli in gradi Celsius e percentuale con una semplice formula.

AHT10 e AHT20 sono praticamente identici dall'esterno e hanno gli stessi intervalli di misura e la stessa precisione. La differenza sta nei dettagli: l'AHT20 ha un intervallo di alimentazione più ampio (2,0–5,5 V), una migliore stabilità a lungo termine, invia un byte di CRC per verificare che i dati letti non siano corrotti e ha un comando di inizializzazione diverso (0xE1 per AHT10, 0xBE per AHT20). Sull'AHT10 il pin di selezione dell'indirizzo permette di usare 0x38 o 0x39, mentre l'indirizzo dell'AHT20 è fisso a 0x38. Inoltre alcuni moduli AHT10 sono noti per dare problemi quando condividono il bus I2C con altri dispositivi: per un nuovo progetto di solito conviene comprare un AHT20.

CaratteristicaAHT10AHT20
ProduttoreAosong (ASAIR)Aosong (ASAIR)
Interfaccia e indirizzoI2C, 0x38 (0x39 con il pin ADR)I2C, 0x38 fisso
Tensione di alimentazione del chip1,8–3,6 V2,0–5,5 V
Intervallo / precisione temperatura-40…+85 °C / ±0,3 °C-40…+85 °C / ±0,3 °C
Intervallo / precisione umidità0–100% RH / ±2% RH0–100% RH / ±2% RH
Risoluzione0,01 °C / 0,024% RH0,01 °C / 0,024% RH
Tempo di misuraCirca 75 msCirca 80 ms
Corrente in standbySotto 1 µASotto 1 µA
Comando di inizializzazione0xE1 0x08 0x000xBE 0x08 0x00
Controllo CRCNoSì (7° byte)

Confronto tra AHT20, DHT11 e DHT22

Nel mondo Arduino i sensori di temperatura e umidità più conosciuti sono DHT11 e DHT22. Comunicano su un'unica linea dati con un protocollo proprietario molto sensibile alle temporizzazioni; la libreria disattiva gli interrupt per qualche millisecondo a ogni lettura, e il DHT11 si può leggere una volta al secondo, il DHT22 una volta ogni due secondi. L'AHT20 usa I2C standard: sugli stessi due fili puoi collegare anche un display OLED, un RTC o un sensore di pressione, e non hai letture perse per errori di temporizzazione. RH sta per umidità relativa (relative humidity).

CaratteristicaAHT10 / AHT20DHT11DHT22 (AM2302)
ComunicazioneI2C (2 fili)Protocollo proprietario a filo singoloProtocollo proprietario a filo singolo
Intervallo temperatura-40…+85 °C0…50 °C-40…+80 °C
Precisione temperatura±0,3 °C±2 °C±0,5 °C
Intervallo umidità0–100% RH20–90% RH0–100% RH
Precisione umidità±2% RH±5% RH±2–5% RH
Risoluzione0,01 °C / 0,024% RH1 °C / 1% RH0,1 °C / 0,1% RH
Intervallo di letturaCirca 80 ms (consigliato 2 s)1 s2 s
Altri dispositivi sulla stessa lineaSì (I2C)NoNo
PrezzoBassoIl più bassoMedio

Quale scegliere? Per un semplice progetto che vuole solo sapere "fa caldo o freddo" il DHT11 basta. Ma misurare l'umidità della stanza con un errore di ±5% significa non poter distinguere il 40% dal 45%; per il monitoraggio dell'umidità in casa, per una serra o un'incubatrice questa differenza conta. Il DHT22 si avvicina all'AHT20 in precisione ma è più caro e più lento. Se vuoi misurare anche la pressione, il BME280 è una buona alternativa; per un confronto dettagliato guarda il confronto tra sensori di temperatura e BME280 e BMP280.

Collegamento di AHT10 / AHT20: Uno, ESP32 e Pico

Pin del modulo AHTArduino UnoESP32Raspberry Pi Pico
VIN / VCC5V (o 3.3V)3V33V3(OUT), pin 36
GNDGNDGNDGND (es. pin 38)
SCLA5GPIO 22GP5 (pin 7)
SDAA4GPIO 21GP4 (pin 6)

La maggior parte dei moduli AHT10 e AHT20 in commercio ha già un piccolo regolatore a 3,3 V e le resistenze di pull-up per le linee I2C, quindi si possono collegare direttamente ai 5 V dell'Uno. Sull'Uno R3 i pin SDA e SCL si trovano anche sui due pin accanto ad AREF: internamente sono la stessa linea di A4 e A5. Un'altra scheda molto diffusa unisce AHT20 e BMP280: l'AHT20 è a 0x38, il BMP280 di solito a 0x77, e con un solo collegamento leggi temperatura, umidità e pressione. Per le basi dell'I2C, che cos'è l'I2C è un buon punto di partenza.

Non alimentare a 5 V se non sei sicuro che il modulo abbia il regolatore. Se sulla scheda vedi solo il chip del sensore e qualche resistenza (in particolare alcune schede AHT10 "nude"), devi alimentarla a 3,3 V; il limite massimo del chip AHT10 è 3,6 V. Inoltre, poiché l'indirizzo dell'AHT20 non si può cambiare, non puoi collegare due AHT20 sulla stessa linea I2C; per il secondo sensore usa la seconda linea I2C di ESP32 e Pico oppure un multiplexer I2C come il TCA9548A.

Passo dopo passo: la prima misura con Arduino

  1. Apri il Gestore Librerie nell'IDE di Arduino, cerca Adafruit AHTX0 e installala; quando chiede le dipendenze scegli Install all in modo da installare anche Adafruit BusIO e Adafruit Unified Sensor.
  2. Collega il sensore secondo la tabella qui sopra: VIN a 5V, GND a GND, SCL ad A5, SDA ad A4.
  3. Se non sei sicuro che il sensore compaia sul bus, esegui prima uno scanner I2C: nell'elenco devi vedere l'indirizzo 0x38.
  4. Carica il codice qui sotto e apri il Monitor Seriale a 9600 baud.
  5. Soffia leggermente sul sensore: vedrai il valore dell'umidità salire rapidamente in pochi secondi e poi tornare lentamente al valore precedente.
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}
RigaCosa fa
aht.begin()Cerca il sensore all'indirizzo 0x38, lo resetta e controlla lo stato di calibrazione. Se il sensore non viene trovato restituisce false.
aht.getEvent(&humidity, &temp)Invia il comando di misura (0xAC), attende la fine della misura e legge entrambi i valori.
temp.temperatureTemperatura in gradi Celsius (float).
humidity.relative_humidityUmidità relativa in percentuale (float).
delay(2000)Attende 2 secondi tra le misure; evita l'autoriscaldamento del chip.

Dai dati grezzi a temperatura e umidità: le formule

Si può leggere il sensore anche senza libreria, perché il protocollo è composto da pochi comandi. Per avviare una misura si scrivono al sensore i byte 0xAC 0x33 0x00; dopo circa 80 ms, dei sei byte letti il primo è il byte di stato. Se il suo bit più significativo (bit 7, 0x80) è 1, il sensore sta ancora misurando; se il bit 3 (0x08) è 1, il sensore è calibrato. Nei cinque byte successivi si trovano affiancati l'umidità a 20 bit (S_RH) e la temperatura a 20 bit (S_T). Le formule di conversione sono: RH = S_RH / 2^20 × 100 e T = S_T / 2^20 × 200 − 50. Per esempio, se il valore grezzo dell'umidità è 471.859, l'umidità è 471.859 / 1.048.576 × 100 ≈ 45,0%; se la temperatura grezza è 372.244, la temperatura è 372.244 / 1.048.576 × 200 − 50 ≈ 21,0 °C. Il codice MicroPython nella sezione Pico esegue esattamente questi passaggi.

Può venire la tentazione di leggere il sensore più volte al secondo, ma ogni misura scalda il chip, anche se pochissimo. Il produttore consiglia di limitare le misure a una ogni 2 secondi perché l'autoriscaldamento resti trascurabile. Per grandezze che cambiano lentamente, come l'umidità di casa, una lettura ogni 5–10 secondi è più che sufficiente.

Monitorare l'umidità in casa d'inverno: perché è importante?

Dietro a gola secca, scosse di elettricità statica o labbra screpolate in inverno spesso c'è l'aria troppo secca. La causa è una semplice legge fisica: la quantità di vapore acqueo che l'aria può contenere aumenta rapidamente con la temperatura. A 0 °C un metro cubo d'aria può contenere al massimo circa 4,8 grammi di vapore, a 21 °C questo limite sale a circa 18,3 grammi. L'aria esterna a 0 °C e all'80% di umidità contiene circa 3,9 g/m³ di acqua. Quando entra in casa e viene scaldata a 21 °C dal termosifone, la quantità d'acqua non cambia ma quella che può contenere sale di circa quattro volte; l'umidità relativa scende a 3,9 / 18,3 ≈ 21%. La precisione di ±2% dell'AHT20 ti permette di vedere bene queste variazioni e se l'umidificatore funziona davvero.

Umidità relativaSituazioneCosa fare
Sotto il 30%Troppo secco: secchezza di gola, occhi e pelle, elettricità staticaUsa un umidificatore, riduci un po' il riscaldamento
30–40%Un po' secco, frequente in invernoMettere una bacinella d'acqua nella stanza o stendere il bucato aiuta
40–60%Intervallo idealeMantieni la situazione
60–70%Umido: inizia ad appannarsi il vetroArieggia spesso e per poco tempo
Sopra il 70%Alto rischio di muffa e acariArieggia, se serve usa un deumidificatore

Misurare l'umidità permette anche di calcolare il punto di rugiada: la temperatura alla quale il vapore acqueo nell'aria inizia a condensare. Se il vetro di una finestra o la superficie interna di una parete esterna scende sotto questa temperatura, si formano goccioline d'acqua e col tempo compare la muffa. Si calcola con la formula di Magnus: γ = ln(RH/100) + 17,62·T / (243,12 + T) e Td = 243,12·γ / (17,62 − γ). Ad esempio, se la stanza è a 21 °C e 60% di umidità, il punto di rugiada è circa 12,9 °C; d'inverno la superficie interna del vetro scende facilmente sotto i 10 °C, quindi il vetro si appanna. Nella stessa stanza, se l'umidità scende al 45%, il punto di rugiada scende a 8,6 °C e il rischio di condensa diminuisce nettamente. Nel codice per ESP32 mostreremo questo calcolo direttamente sul display.

Igrometro OLED (Arduino Uno)

Mettiamo insieme quello che hai imparato: con un Arduino Uno, un AHT20 e un display OLED SSD1306 da 0,96 pollici costruirai un igrometro da tenere sulla scrivania. Poiché entrambi i moduli usano I2C, si collegano in parallelo agli stessi pin A4 (SDA) e A5 (SCL); l'OLED è a 0x3C e l'AHT20 a 0x38, quindi non ci sono conflitti. Per l'installazione della libreria del display e gli altri dettagli puoi dare un'occhiata a come usare un display OLED (SSD1306).

Display OLED I2C da 0,96 pollici SSD1306
Il display OLED SSD1306 da 0,96 pollici condivide la stessa linea I2C dell'AHT20: il display è a 0x3C, il sensore a 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}

Il codice effettua una misura ogni due secondi: in alto scrive la temperatura con un carattere piccolo, al centro l'umidità con un carattere tre volte più grande. La riga sotto dice se l'aria è secca, ideale o umida in base agli intervalli della tabella precedente, e la barra in basso mostra l'umidità in modo visivo. Poiché il buffer dell'OLED occupa circa 1 KB dei 2 KB di RAM dell'Uno, abbiamo scritto i testi fissi con la macro F(). Se invece di fissare il sensore sopra al display e ad Arduino lo metti a qualche centimetro di distanza, all'estremità di un cavo, il calore emesso dalle schede non influenza la misura.

AHT20 con ESP32: punto di rugiada e umidità minima/massima

Sull'ESP32 le stesse librerie Adafruit funzionano senza modifiche; cambiano solo i pin I2C. Sulle schede ESP32 DevKit il pin SDA predefinito è il GPIO 21 e il pin SCL il GPIO 22, e puoi indicarli esplicitamente con Wire.begin(21, 22). Il codice qui sotto mostra umidità e temperatura sull'OLED, calcola il punto di rugiada con la formula di Magnus e memorizza anche l'umidità minima e massima registrata dall'accensione. Poiché usiamo millis() al posto di delay(), il loop() resta libero; in futuro, se vorrai inviare i dati al telefono via Wi-Fi o mostrarli in una pagina web, non dovrai riscrivere il codice da zero. Per la parte Wi-Fi puoi partire da che cos'è 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}

AHT20 con Raspberry Pi Pico e MicroPython

Sul Raspberry Pi Pico con MicroPython non ti serve nemmeno una libreria a parte: il protocollo è così semplice che puoi scriverlo da solo in poche righe. Il codice aspetta prima 40 ms per l'avvio del sensore, controlla il bit di calibrazione nel byte di stato e, se necessario, invia il comando di inizializzazione. Poi a ogni misura invia il comando 0xAC, attende 80 ms, legge finché il bit di occupato non si azzera e calcola il risultato con le formule spiegate sopra. Se usi un AHT10 ti basta chiamare aht_init(True). La linea I2C0 del Pico qui usa i pin GP4 (SDA) e GP5 (SCL); se vuoi aggiungere un OLED, puoi usare il driver ssd1306.py con lo stesso oggetto i2c. Per l'installazione di MicroPython puoi leggere che cos'è il 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

Idee di progetto con l'AHT20

  • Igrometro per ogni stanza: metti un AHT20 e un piccolo OLED in ogni stanza e scopri quale è la più secca in inverno.
  • Umidificatore automatico: quando l'umidità scende sotto il 40% accendi l'umidificatore con un modulo relè e spegnilo al 50%.
  • Controllo della ventola del bagno: dopo la doccia, quando l'umidità supera il 70%, accendi l'aspiratore; puoi usare il circuito dell'articolo controllo ventola con Arduino.
  • Mini serra e incubatrice: controlla temperatura e umidità contemporaneamente; il progetto di serra intelligente è un buon punto di partenza.
  • Data logger a batteria: metti l'ESP32 in deep sleep e misura ogni 10 minuti; in sleep l'AHT20 assorbe meno di un microampere.
  • Termostato intelligente: misura la temperatura con precisione di ±0,3 °C e accendi e spegni la caldaia con un relè; i dettagli sono nell'articolo termostato con Arduino.
  • Allarme umidità per armadi e magazzini: avvisa con un buzzer quando l'umidità supera il 65% e intervieni prima che si formi la muffa.

Errori comuni e come risolverli

SintomoCausa probabileSoluzione
Messaggio "non trovato", begin() restituisce falseSDA e SCL invertiti, cavo allentato o alimentazione sbagliataControlla i cavi, cerca l'indirizzo 0x38 con lo scanner I2C
Lo scanner non trova nessun indirizzoIl modulo non ha resistenze di pull-up o la massa non è in comuneAggiungi pull-up da 4,7 kΩ da SDA e SCL a 3,3 V, unisci le masse
La temperatura risulta 2–3 °C troppo altaIl sensore risente del calore di Arduino, del regolatore o del displayAllontana il sensore dalle schede con un cavo, fai un foro d'aria nella scatola
L'umidità è sempre vicina al 100% o non cambia maiIl sensore è stato esposto a condensa o la superficie è sporcaLascialo qualche ora in un ambiente asciutto e tiepido, non toccare la superficie del sensore
Ogni tanto valori assurdi (es. -50 °C)Lettura prima della fine della misura, letture troppo frequenti o disturbi sulla lineaAspetta almeno 2 s tra le letture, tieni i cavi corti, controlla il CRC sull'AHT20
Con l'OLED l'AHT10 si bloccaProblema di alcuni moduli AHT10 nel condividere la linea I2CPassa all'AHT20 o collega l'AHT10 a una linea I2C separata
Perché il sensore misuri correttamente deve essere a contatto con l'aria. Se lo metti in una scatola chiusa, fai assolutamente un foro davanti al sensore e mettilo in uno scomparto separato dal regolatore e dal microcontrollore che si scaldano. Luce solare diretta, sopra il termosifone e l'angolo di una parete esterna non rappresentano il valore reale della stanza; misura all'altezza a cui stai seduto, vicino al centro della stanza.

Nonostante il prezzo basso, l'AHT10 e soprattutto l'AHT20 offrono una precisione più che sufficiente per il monitoraggio del clima domestico e, grazie all'I2C, sono molto facili da collegare e da combinare con altri moduli. Se hai iniziato con il DHT11, puoi portare lo stesso progetto sull'AHT20 cambiando poche righe e vedere da solo quanto diventano più stabili le misure. Nell'app BlueGrays trovi, passo dopo passo con schemi e codice, i progetti di misura di temperatura e umidità con DHT11, indicatore con LCD su ESP32, stazione meteo con OLED e logger di temperatura su scheda microSD, e puoi adattarli facilmente all'AHT20.

Domande frequenti

Che differenza c'è tra AHT10 e AHT20?

Entrambi hanno lo stesso intervallo di misura e una precisione di circa ±0,3 °C e ±2% RH. L'AHT20 offre un intervallo di alimentazione più ampio (2,0–5,5 V), il controllo dei dati con CRC e una migliore stabilità a lungo termine; anche i comandi di inizializzazione sono diversi. Per i nuovi progetti è meglio scegliere l'AHT20.

Qual è l'indirizzo I2C dell'AHT20?

L'indirizzo dell'AHT20 è fisso a 0x38 e non si può cambiare. Sull'AHT10 il pin ADR permette di scegliere 0x38 o 0x39. Per usare due AHT20 sulla stessa linea serve una seconda linea I2C oppure un multiplexer I2C come il TCA9548A.

È meglio l'AHT20 o il DHT22?

Per la maggior parte dei progetti domestici l'AHT20 è migliore: precisione pari o superiore al DHT22, prezzo più basso, misura più veloce e, grazie all'I2C, condivide gli stessi due fili con altri moduli. Il vantaggio del DHT22 è che funziona anche con cavi lunghi; l'I2C funziona meglio con cavi corti, di solito sotto il metro.

L'AHT10 si può collegare ad Arduino a 5 V?

I moduli con regolatore a bordo funzionano in sicurezza a 5 V; controlla se sulla scheda c'è un piccolo regolatore a tre piedini e la scritta VIN. Sulle schede AHT10 senza regolatore il limite massimo del chip è 3,6 V, quindi devi alimentare il modulo a 3,3 V.

Perché l'AHT20 segna una temperatura troppo alta?

La causa più frequente è che il sensore risente del calore emesso da Arduino, dal regolatore di tensione o dal display. Anche misurare troppo spesso scalda un po' il chip. Tieni il sensore lontano dalle schede, all'estremità di un cavo, ed esegui le misure al massimo ogni 2 secondi.

Qual è l'umidità ideale in casa?

In casa si considera ideale un'umidità relativa del 40–60%. D'inverno, a causa del riscaldamento, l'umidità può scendere sotto il 30% e aumentano la secchezza di gola e pelle. Sopra il 60% iniziano a comparire vetri appannati e, col tempo, il rischio di muffa.

Vedi tutti i progetti
Temperatura e umidità con DHT11
AR-55Intermedio

Temperatura e umidità con DHT11

Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

4.7(47)
83
ESP32 DHT22 Temperatura e umidità (con display LCD)
ES-15Intermedio

ESP32 DHT22 Temperatura e umidità (con display LCD)

Si tratta di un progetto che misura la temperatura e l'umidità dell'ambiente tramite il sensore DHT22 e le visualizza in tempo reale su un display LCD I2C 16x2. I dati vengono letti dal sensore utilizzando il protocollo one-wire tramite la libreria Adafruit DHT. Questo progetto costituisce la base per stazioni meteorologiche IoT, sistemi di automazione domestica intelligente o sistemi di monitoraggio ambientale nelle serre. La comunicazione con il DHT22 avviene tramite il pin GPIO 4 dell'ESP32.

4.8(38)
57
Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzato
Premium

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.

4.7(7)
12
ESP32 HTTPClient + API meteo (con display OLED SSD1306)
ES-32Avanzato
Premium

ESP32 HTTPClient + API meteo (con display OLED SSD1306)

L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. A differenza della versione con LCD I2C, qui usiamo un display OLED SSD1306 (128×64), con testo grande e icone vettoriali per una resa più ricca. Sette icone meteo (sole, pioggia, neve e altre) vengono disegnate al volo, senza file bitmap.

4.3(10)
22
ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
ES-33Avanzato
Premium

ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)

La modalità Deep Sleep dell'ESP32 spegne la CPU e quasi tutte le periferiche e riduce il consumo a circa 10µA, un aspetto cruciale per i dispositivi IoT a batteria. Il progetto usa tre sorgenti di risveglio: un timer (15 s), un pin esterno (EXT0, il pulsante su GPIO 33) e un pin touch (T0/GPIO 4). I contatori marcati con RTC_DATA_ATTR restano salvati durante il deep sleep.

4.3(10)
16
Misura di temperatura con NTC e display Lcd 2x16
AR-44Principiante
Premium

Misura di temperatura con NTC e display Lcd 2x16

Misura la temperatura dell'ambiente con un sensore che sembra una piccola perlina.

4.5(33)
44
Orologio a matrice di punti, calendario e stazione meteo (MAX7219, DS1307)
AR-85Intermedio
Premium

Orologio a matrice di punti, calendario e stazione meteo (MAX7219, DS1307)

Un pannello a scritte scorrevoli per la scrivania o la parete che mostra a turno l'ora, la data e il clima della stanza.

5.0(50)
66