Componentes · 12 min de leitura

AHT10 com Arduino: guia do sensor de temperatura e umidade AHT20

Ligue o AHT10 e o AHT20 ao Arduino: conexão I2C 0x38, biblioteca AHTX0, comparação com DHT11/DHT22, indicador de umidade em OLED e código para ESP32 e Pico.

O AHT10 virou uma das escolhas mais populares em projetos Arduino que precisam medir temperatura e umidade ao mesmo tempo. Fabricados pela Aosong (ASAIR), o AHT10 e seu sucessor aprimorado, o AHT20, se conectam por I2C com apenas quatro fios, medem a temperatura com precisão de cerca de ±0,3 °C e a umidade relativa com ±2%, e entregam valores digitais calibrados de fábrica. Resumindo: é bem mais preciso que o DHT11, e mais barato e mais rápido que o DHT22.

Neste post você vai ver as diferenças entre o AHT10 e o AHT20, como ligá-los a um Arduino Uno, a um ESP32 e a um Raspberry Pi Pico, sua primeira leitura com a biblioteca Adafruit AHTX0 e como a temperatura e a umidade são calculadas a partir dos dados brutos que o sensor envia. Depois, vai entender por que a umidade dentro de casa cai no inverno com o aquecimento ligado, qual é a faixa de umidade ideal e como calcular o ponto de orvalho para saber se as janelas vão embaçar. Por fim, vai montar um indicador prático de umidade ambiente em um pequeno display OLED.

O que são o AHT10 e o AHT20 e como funcionam?

Dentro dos dois sensores há dois elementos de medição separados. A umidade é medida por um elemento capacitivo: uma fina camada de polímero entre dois eletrodos absorve o vapor de água do ar. Quando a umidade sobe, o polímero retém mais água, sua constante dielétrica muda e a capacitância do elemento aumenta de forma mensurável. A temperatura é medida por um sensor semicondutor no próprio chip. Esses dois sinais analógicos são convertidos em números por um ADC de 20 bits em um processador dedicado (ASIC) no mesmo encapsulamento e corrigidos com coeficientes de calibração definidos na fábrica. O que chega ao seu microcontrolador é um conjunto de números brutos já calibrados; você só precisa convertê-los em graus Celsius e porcentagem com uma fórmula simples.

Por fora, o AHT10 e o AHT20 são quase idênticos, e as faixas de medição e a precisão também são as mesmas. A diferença está nos detalhes: o AHT20 tem uma faixa de alimentação mais ampla (2,0–5,5 V), melhor estabilidade a longo prazo, envia um byte de CRC para você saber se os dados foram corrompidos e usa outro comando de inicialização (0xE1 no AHT10, 0xBE no AHT20). O AHT10 pode usar 0x38 ou 0x39 graças a um pino de seleção de endereço, enquanto o endereço do AHT20 é fixo em 0x38. Também se sabe que alguns módulos AHT10 dão problema ao dividir o barramento I2C com outros dispositivos; para um projeto novo, geralmente vale mais a pena comprar o AHT20.

CaracterísticaAHT10AHT20
FabricanteAosong (ASAIR)Aosong (ASAIR)
Interface e endereçoI2C, 0x38 (0x39 com o pino ADR)I2C, fixo em 0x38
Tensão de alimentação do chip1,8–3,6 V2,0–5,5 V
Faixa / precisão de temperatura-40…+85 °C / ±0,3 °C-40…+85 °C / ±0,3 °C
Faixa / precisão de umidade0–100% UR / ±2% UR0–100% UR / ±2% UR
Resolução0,01 °C / 0,024% UR0,01 °C / 0,024% UR
Tempo de mediçãoCerca de 75 msCerca de 80 ms
Corrente em repousoMenos de 1 µAMenos de 1 µA
Comando de inicialização0xE1 0x08 0x000xBE 0x08 0x00
Verificação CRCNãoSim (7º byte)

AHT20 vs DHT11 vs DHT22

No mundo Arduino, os sensores de temperatura e umidade mais conhecidos são o DHT11 e o DHT22. Eles se comunicam por uma única linha de dados com um protocolo próprio muito sensível ao tempo; a biblioteca desativa as interrupções por alguns milissegundos a cada leitura, e o DHT11 pode ser lido uma vez por segundo, o DHT22 uma vez a cada dois segundos. O AHT20 usa I2C padrão: um display OLED, um RTC ou um sensor de pressão podem dividir os mesmos dois fios, e você não perde leituras por erro de temporização. UR significa umidade relativa (em inglês, RH: relative humidity).

CaracterísticaAHT10 / AHT20DHT11DHT22 (AM2302)
ComunicaçãoI2C (2 fios)Protocolo próprio de um fioProtocolo próprio de um fio
Faixa de temperatura-40…+85 °C0…50 °C-40…+80 °C
Precisão de temperatura±0,3 °C±2 °C±0,5 °C
Faixa de umidade0–100% UR20–90% UR0–100% UR
Precisão de umidade±2% UR±5% UR±2–5% UR
Resolução0,01 °C / 0,024% UR1 °C / 1% UR0,1 °C / 0,1% UR
Intervalo de leituraCerca de 80 ms (recomendado 2 s)1 s2 s
Outros dispositivos no mesmo barramentoSim (I2C)NãoNão
PreçoBaixoO mais baixoMédio

Qual escolher? Para um projeto simples que só verifica “quente ou frio”, o DHT11 basta. Mas, com erro de ±5%, você não consegue distinguir 40% de 45% de umidade, e essa diferença importa no acompanhamento da umidade em casa, em estufas ou chocadeiras. O DHT22 chega perto do AHT20 em precisão, mas é mais caro e mais lento. Se você também quiser medir pressão, o BME280 é uma boa alternativa; para uma comparação detalhada, veja os posts comparação de sensores de temperatura e BME280 e BMP280.

Ligação do AHT10 / AHT20: Uno, ESP32 e Pico

Pino do módulo AHTArduino UnoESP32Raspberry Pi Pico
VIN / VCC5V (ou 3.3V)3V33V3(OUT), pino 36
GNDGNDGNDGND (ex.: pino 38)
SCLA5GPIO 22GP5 (pino 7)
SDAA4GPIO 21GP4 (pino 6)

A maioria dos módulos AHT10 e AHT20 à venda já vem com um pequeno regulador de 3,3 V e resistores de pull-up para as linhas I2C, então podem ser ligados direto nos 5 V do Uno. No Uno R3, os pinos SDA e SCL também aparecem em dois pinos ao lado do AREF; internamente são as mesmas linhas de A4 e A5. Outra placa muito comum combina o AHT20 com um BMP280: o AHT20 fica em 0x38 e o BMP280 normalmente em 0x77, então com uma só ligação você lê temperatura, umidade e pressão juntas. O post O que é I2C é um bom ponto de partida para o básico.

Não aplique 5 V sem ter certeza de que o módulo tem regulador. Se a placa mostra só o chip do sensor e alguns resistores (principalmente algumas placas AHT10 sem componentes extras), você deve alimentar o módulo com 3,3 V; o limite máximo do chip AHT10 é 3,6 V. Além disso, como o endereço do AHT20 não pode ser alterado, não dá para ligar dois AHT20 no mesmo barramento I2C; para um segundo sensor, use o segundo barramento I2C do ESP32 ou do Pico, ou um multiplexador I2C como o TCA9548A.

Passo a passo: sua primeira leitura com Arduino

  1. Abra o Gerenciador de Bibliotecas no Arduino IDE, busque por Adafruit AHTX0 e instale; quando ele perguntar sobre as dependências, escolha Instalar tudo para que a Adafruit BusIO e a Adafruit Unified Sensor também sejam instaladas.
  2. Ligue o sensor conforme a tabela acima: VIN no 5V, GND no GND, SCL no A5, SDA no A4.
  3. Se não tiver certeza de que o sensor aparece no barramento, rode primeiro um sketch scanner I2C; o endereço 0x38 deve aparecer na lista.
  4. Carregue o código abaixo e abra o Monitor Serial a 9600 baud.
  5. Sopre levemente sobre o sensor: você vai ver a umidade subir rápido em poucos segundos e depois voltar devagar ao valor anterior.
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}
LinhaO que faz
aht.begin() (inicialização)Procura o sensor no endereço 0x38, reinicia o sensor e verifica o estado da calibração. Retorna false se o sensor não for encontrado.
aht.getEvent(&humidity, &temp) (leitura)Envia o comando de medição (0xAC), espera a medição terminar e lê os dois valores de uma vez.
temp.temperature (temperatura)Temperatura em graus Celsius (float).
humidity.relative_humidity (umidade)Umidade relativa em porcentagem (float).
delay(2000) (pausa)Espera 2 segundos entre as medições; evita o autoaquecimento do chip.

Dos dados brutos à temperatura e umidade: as fórmulas

Ler o sensor sem biblioteca também é fácil, porque o protocolo tem só alguns comandos. Para iniciar uma medição, você escreve os bytes 0xAC 0x33 0x00 no sensor; após cerca de 80 ms, lê seis bytes, e o primeiro é o byte de status. Se o bit mais significativo dele (bit 7, 0x80) for 1, o sensor ainda está medindo; se o bit 3 (0x08) for 1, o sensor está calibrado. Os cinco bytes seguintes trazem lado a lado o valor de umidade de 20 bits (S_RH) e o de temperatura de 20 bits (S_T). As fórmulas de conversão são: RH = S_RH / 2^20 × 100 e T = S_T / 2^20 × 200 − 50. Por exemplo, se o valor bruto de umidade for 471.859, a umidade é 471.859 / 1.048.576 × 100 ≈ 45,0%; se a temperatura bruta for 372.244, a temperatura é 372.244 / 1.048.576 × 200 − 50 ≈ 21,0 °C. O código MicroPython da seção do Pico segue exatamente esses passos.

Dá vontade de ler o sensor várias vezes por segundo, mas cada medição aquece o chip, mesmo que só um pouco. O fabricante recomenda limitar as medições a uma a cada 2 segundos para que o autoaquecimento fique desprezível. Para grandezas que mudam devagar, como a umidade dentro de casa, ler a cada 5–10 segundos já é mais que suficiente.

Acompanhando a umidade em casa no inverno: por que importa

Por trás de queixas de inverno como garganta seca, choques de eletricidade estática ou lábios rachados, muitas vezes está a umidade baixa. O motivo é uma lei física simples: a quantidade de vapor de água que o ar consegue reter aumenta rápido com a temperatura. A 0 °C, um metro cúbico de ar retém no máximo cerca de 4,8 gramas de vapor de água, enquanto a 21 °C esse limite sobe para cerca de 18,3 gramas. O ar externo a 0 °C e 80% de umidade contém cerca de 3,9 g/m³ de água. Quando esse ar entra e é aquecido a 21 °C pelo aquecedor, a quantidade de água nele não muda, mas a quantidade que ele poderia reter fica cerca de quatro vezes maior; a umidade relativa cai para 3,9 / 18,3 ≈ 21%. A precisão de ±2% do AHT20 permite ver com facilidade mudanças como essa e se o seu umidificador está realmente funcionando.

Umidade relativaSituaçãoO que fazer
Abaixo de 30%Muito seco: garganta, olhos e pele secos, eletricidade estáticaUse um umidificador, diminua um pouco o aquecimento
30–40%Um pouco seco, comum no invernoColocar uma vasilha com água no cômodo ou secar roupa dentro de casa ajuda
40–60%Faixa idealMantenha assim
60–70%Úmido: as janelas começam a embaçarVentile por pouco tempo e com frequência
Acima de 70%Alto risco de mofo e ácarosVentile e, se necessário, use um desumidificador

Outra vantagem de medir a umidade é poder calcular o ponto de orvalho. O ponto de orvalho é a temperatura em que o vapor de água do ar começa a condensar. Se o vidro da janela ou a face interna de uma parede externa ficar abaixo dessa temperatura, formam-se gotas de água ali e, com o tempo, surge mofo. Ele é calculado com a fórmula de Magnus: γ = ln(RH/100) + 17,62·T / (243,12 + T) e Td = 243,12·γ / (17,62 − γ). Por exemplo, se o cômodo está a 21 °C e 60% de umidade, o ponto de orvalho é cerca de 12,9 °C; no inverno a face interna do vidro pode facilmente ficar abaixo de 10 °C, e a janela embaça. Se a umidade do mesmo cômodo cair para 45%, o ponto de orvalho cai para 8,6 °C e o risco de embaçamento diminui bastante. No código do ESP32, vamos mostrar esse cálculo direto no display.

Indicador de umidade em display OLED (Arduino Uno)

Agora vamos juntar o que você aprendeu: com um Arduino Uno, um AHT20 e um display OLED SSD1306 de 0,96 polegada, você vai montar um indicador de umidade para deixar na mesa. Como os dois módulos usam I2C, eles são ligados em paralelo nos mesmos pinos A4 (SDA) e A5 (SCL); o OLED fica em 0x3C e o AHT20 em 0x38, então não há conflito. Para a instalação da biblioteca do display e outros detalhes, veja o post display OLED de 0,96 polegada (SSD1306).

Display OLED I2C de 0,96 polegada SSD1306
O display OLED SSD1306 de 0,96 polegada divide o mesmo barramento I2C com o AHT20: o display fica em 0x3C, o sensor em 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}

O código faz uma medição a cada dois segundos; escreve a temperatura em cima, em letra pequena, e a umidade no meio, com letra três vezes maior. A linha de baixo diz se o ar está seco, ideal ou úmido, de acordo com as faixas da tabela acima, e a barra no rodapé mostra a umidade de forma visual. Como o buffer de quadro do OLED usa cerca de 1 KB dos 2 KB de RAM do Uno, escrevemos os textos fixos com a macro F(). Se você colocar o sensor a alguns centímetros, na ponta de um fio, em vez de grudá-lo em cima do display e do Arduino, o calor das placas não afeta a leitura.

AHT20 com ESP32: ponto de orvalho e umidade mínima/máxima

As mesmas bibliotecas da Adafruit funcionam sem mudanças no ESP32; a única diferença são os pinos I2C. Nas placas ESP32 DevKit, o pino SDA padrão é o GPIO 21 e o SCL é o GPIO 22, e você pode indicar os pinos explicitamente com Wire.begin(21, 22). O código abaixo mostra umidade e temperatura no OLED, calcula o ponto de orvalho com a fórmula de Magnus e ainda guarda a menor e a maior umidade registradas desde que o dispositivo foi ligado. Como usamos millis() em vez de delay(), o loop() fica livre; quando mais tarde você quiser enviar os dados para o celular por Wi-Fi ou mostrá-los em uma página web, não vai precisar reescrever o código do zero. Para a parte de Wi-Fi, você pode começar por O que é o 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 e MicroPython com o AHT20

No Raspberry Pi Pico você nem precisa de uma biblioteca MicroPython separada; o protocolo é tão simples que dá para escrevê-lo você mesmo em poucas linhas. O código primeiro espera 40 ms pelo tempo de inicialização do sensor, confere o bit de calibração no byte de status e, se necessário, envia o comando de inicialização. Depois, a cada medição, envia o comando 0xAC, espera 80 ms, lê até o bit de ocupado zerar e calcula o resultado com as fórmulas descritas acima. Se você usa um AHT10, basta chamar aht_init(True). O barramento I2C0 do Pico aqui fica nos pinos GP4 (SDA) e GP5 (SCL); se quiser adicionar um OLED, pode usar o driver ssd1306.py com o mesmo objeto i2c. Para instalar o MicroPython, veja O que é o 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

Ideias de projetos com o AHT20

  • Indicador de umidade por cômodo: coloque um AHT20 e um pequeno OLED em cada cômodo para ver qual fica mais seco no inverno.
  • Umidificador automático: quando a umidade cair abaixo de 40%, ligue o umidificador com um módulo relé e desligue em 50%.
  • Controle do exaustor do banheiro: acione o exaustor quando a umidade passar de 70% depois do banho; você pode usar o circuito do post controle de ventoinha com Arduino.
  • Miniestufa e chocadeira: controle temperatura e umidade ao mesmo tempo; o projeto de estufa inteligente é um bom ponto de partida.
  • Datalogger a bateria: coloque o ESP32 em deep sleep e meça a cada 10 minutos; o AHT20 consome menos de um microampère em repouso.
  • Termostato inteligente: meça a temperatura com precisão de ±0,3 °C e ligue e desligue o aquecedor com um relé; os detalhes estão no post termostato com Arduino.
  • Alarme de umidade para guarda-roupa e depósito: toque um buzzer quando a umidade passar de 65% e aja antes que o mofo apareça.

Erros comuns e como resolver

SintomaCausa provávelSolução
Mensagem “not found”, begin() retorna falseSDA e SCL invertidos, fio solto ou alimentação erradaConfira os fios e procure o endereço 0x38 com um scanner I2C
O scanner não encontra nenhum endereçoO módulo não tem resistores de pull-up ou o GND não é comumAdicione pull-ups de 4,7 kΩ de SDA e SCL para 3,3 V e una os GNDs
Temperatura 2–3 °C acima do realO sensor sofre com o calor do Arduino, do regulador ou do displayAfaste o sensor das placas na ponta de um fio e faça furos de ventilação na caixa
Umidade sempre perto de 100% ou nunca mudaO sensor foi exposto à condensação ou a superfície está contaminadaDeixe-o algumas horas em local seco e morno e não toque na superfície do sensor
Valores absurdos de vez em quando (ex.: -50 °C)Leitura antes do fim da medição, leituras frequentes demais ou ruído no barramentoEspere pelo menos 2 s entre leituras, use fios curtos e verifique o CRC no AHT20
O AHT10 trava quando usado com o OLEDAlguns módulos AHT10 têm problemas ao dividir o barramento I2CTroque pelo AHT20 ou ligue o AHT10 em um barramento I2C separado
Para medir corretamente, o sensor precisa estar em contato com o ar. Se for colocá-lo em uma caixa fechada, faça sem falta um furo na frente dele e posicione-o em um compartimento separado do regulador e do microcontrolador, que esquentam. Lugares como sol direto, em cima do aquecedor ou no canto de uma parede externa não refletem o valor real do cômodo; meça na altura em que você fica sentado, perto do meio do cômodo.

Apesar do preço baixo, o AHT10, e principalmente o AHT20, oferece precisão mais que suficiente para acompanhar o clima dentro de casa e, graças ao I2C, é muito fácil de ligar e combinar com outros módulos. Se você começou antes com o DHT11, pode passar o mesmo projeto para o AHT20 mudando poucas linhas e ver com seus próprios olhos como as leituras ficam mais estáveis. No app BlueGrays você encontra, com esquemas do circuito e código passo a passo, projetos como medição de temperatura e umidade com DHT11, indicador de temperatura e umidade com ESP32 e LCD, tela de previsão do tempo com OLED e registrador de temperatura que grava em cartão microSD, e pode adaptá-los facilmente para usar o AHT20.

Perguntas frequentes

Qual é a diferença entre o AHT10 e o AHT20?

Os dois têm a mesma faixa de medição e precisão de cerca de ±0,3 °C e ±2% UR. O AHT20 oferece faixa de alimentação mais ampla (2,0–5,5 V), verificação de dados por CRC e melhor estabilidade a longo prazo, e os comandos de inicialização também são diferentes. Para projetos novos, o AHT20 é a melhor escolha.

Qual é o endereço I2C do AHT20?

O endereço do AHT20 é fixo em 0x38 e não pode ser alterado. No AHT10, o pino ADR permite escolher 0x38 ou 0x39. Para usar dois AHT20, você precisa de um segundo barramento I2C ou de um multiplexador I2C como o TCA9548A.

O AHT20 é melhor que o DHT22?

Para a maioria dos projetos internos, o AHT20 é melhor: a precisão é igual ou superior à do DHT22, é mais barato, mede mais rápido e, graças ao I2C, divide os mesmos dois fios com outros módulos. A vantagem do DHT22 é funcionar com cabos longos; o I2C geralmente funciona melhor com cabos curtos, de menos de 1 metro.

Posso ligar o AHT10 a um Arduino em 5 V?

Módulos com regulador na placa funcionam com segurança em 5 V; confira se a placa tem um pequeno regulador de três terminais e a marcação VIN. Em placas AHT10 sem regulador, o limite máximo do chip é 3,6 V, então você deve alimentar o módulo com 3,3 V.

Por que meu AHT20 mostra temperatura alta?

O motivo mais comum é o sensor sofrer com o calor do Arduino, do regulador de tensão ou do display. Medir com frequência demais também aquece um pouco o chip. Mantenha o sensor longe das placas, na ponta de um fio, e meça no máximo uma vez a cada 2 segundos.

Qual deve ser a umidade ideal em casa?

Em ambientes internos, 40–60% de umidade relativa costuma ser considerado ideal. No inverno, o aquecimento pode levar a umidade abaixo de 30%, o que aumenta a secura da garganta e da pele. Acima de 60%, as janelas começam a embaçar e, com o tempo, surge risco de mofo.

Ver todos os projetos
Temperatura e umidade com DHT11
AR-55Intermediário

Temperatura e umidade com DHT11

Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

4.7(47)
83
Temperatura e umidade com ESP32 e DHT22 (com display LCD)
ES-15Intermediário

Temperatura e umidade com ESP32 e DHT22 (com display LCD)

Este projeto mede a temperatura e a umidade do ambiente com um sensor DHT22 e exibe os dados em tempo real em um LCD I2C 16x2. Os dados são lidos do sensor pelo protocolo de um fio (one-wire) com a biblioteca Adafruit DHT. Este projeto serve de base para estações meteorológicas IoT, automação residencial ou sistemas de monitoramento ambiental em estufas. A comunicação com o DHT22 é feita pelo pino GPIO 4 do ESP32.

4.8(38)
57
Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avançado
Premium

Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Monte um registrador de temperatura com data e hora usando ESP32. O DHT22 mede a temperatura e a umidade a cada minuto, o DS1307 RTC fornece a hora real e cada leitura é gravada em CSV no cartão microSD. O OLED mostra em letras grandes a temperatura atual, além da umidade, da data e hora e do total de registros. Abra o arquivo /temp_log.csv no Excel, no Google Sheets ou com pandas para acompanhar uma estufa ou a temperatura de casa.

4.7(7)
12
ESP32 HTTPClient + API de clima (com display OLED SSD1306)
ES-32Avançado
Premium

ESP32 HTTPClient + API de clima (com display OLED SSD1306)

Neste projeto, usamos o ESP32 para fazer uma chamada REST à API de clima wttr.in pela internet com HTTPClient.h. Diferentemente da versão anterior com LCD I2C, aqui usamos um display OLED SSD1306 (128×64), que permite usar fontes grandes, ícones vetoriais e uma apresentação visual rica em uma única tela. Sete ícones vetoriais de condições do tempo (ensolarado, parcialmente nublado, nublado, chuvoso, com neve, com tempestade e com neblina) são desenhados durante a execução, sem arquivos bitmap.

4.3(10)
22
ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)
ES-33Avançado
Premium

ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)

O modo de sono profundo do ESP32 reduz o consumo de corrente para ~10 µA ao desligar a CPU e a maioria dos periféricos, sendo essencial para dispositivos IoT alimentados por bateria. Neste projeto, usamos três fontes de despertar: um temporizador (15 segundos), um pino externo (EXT0 — botão no GPIO 33) e toque (T0/GPIO 4). As variáveis marcadas com RTC_DATA_ATTR são preservadas durante o sono profundo, mantendo os contadores de inicializações e de despertares por temporizador e botão.

4.3(10)
16
Medição de temperatura com NTC e display LCD 2x16
AR-44Iniciante
Premium

Medição de temperatura com NTC e display LCD 2x16

Meça a temperatura ao seu redor com um sensor que parece uma pequena conta. Esse componente, chamado NTC, deixa a eletricidade passar com mais facilidade à medida que aquece; o Arduino lê essa…

4.5(33)
44
Relógio, calendário e estação meteorológica de matriz de pontos (MAX7219, DS1307)
AR-85Intermediário
Premium

Relógio, calendário e estação meteorológica de matriz de pontos (MAX7219, DS1307)

Um painel com texto em rolagem para sua mesa ou parede que mostra, em sequência, a hora, a data e as condições do ambiente.

5.0(50)
66