Temp and Humidity Sensor Arduino: AHT20 vs DHT22 Wiring and Code

If you are building a temp and humidity sensor Arduino project in 2026, the best default sensor to buy is the AHT20 (or the premium SHT31 for lab-grade accuracy). Stop using DHT11 and DHT22 sensors. Their legacy 1-Wire-style protocol relies on strict microsecond timing that blocks your main loop and crashes the moment an interrupt fires. The AHT20 uses the hardware I2C bus, freeing your microcontroller to handle WiFi, displays, and motor control without dropping sensor readings.

This guide provides a concrete decision framework to pick your sensor, a complete wiring and code implementation targeting the Arduino Uno R3 and R4 Minima, and a deep-dive debugging section for the most common I2C failure modes.

The Decision Tree: Which Sensor Should You Actually Buy?

Walk through this decision matrix to select the right module for your specific environment and budget. Do not default to the DHT11 just because it is cheap; the data quality is unusable for anything beyond basic classroom demos.

Hardware Spec Sheet and Pin Mapping

For this build, we are using the Arduino Uno R4 Minima (or the classic Uno R3) paired with an Adafruit AHT20 Breakout Board (Product ID: 4566). We specify the Adafruit breakout because it includes the necessary 3.3V voltage regulator and I2C level-shifting circuitry, allowing safe connection to 5V Arduino boards. Generic green AHT20 modules lack these components and will fry if connected directly to 5V logic.

Pin Mapping Table

The AHT20 uses a fixed I2C address of 0x38. It does not support address selection jumpers, meaning you can only put one AHT20 on a single I2C bus.

Wiring Steps and Compilable I2C Code

Follow these physical wiring steps before uploading the code. Ensure your workbench is grounded to prevent electrostatic discharge (ESD) from damaging the sensor’s sensitive capacitive humidity element.

1. Power Rails: Connect the Arduino 5V pin to the red breadboard rail, and GND to the blue breadboard rail.
2. Sensor Power: Route red from the rail to the AHT20 VIN pin. Route black from the rail to the AHT20 GND pin.
3. I2C Data Lines: Connect Arduino A4 (or dedicated SDA) to the sensor SDA. Connect Arduino A5 (or dedicated SCL) to the sensor SCL.
4. Verification: Use a multimeter in continuity mode to verify there are no shorts between VCC and GND before plugging in the USB cable.

Complete Arduino Code

This code targets the Arduino Uno R3/R4. It requires the Adafruit AHTX0 and Adafruit Unified Sensor libraries, which you can install via the Arduino Library Manager. The code includes explicit pin definitions, hardware I2C initialization, and fatal error handling.

#include <Wire.h>
#include <Adafruit_AHTX0.h>

// Pin definitions for Hardware I2C
// On Uno R3, SDA is A4 and SCL is A5.
// On Uno R4, these map to the dedicated SDA/SCL header pins.
#define I2C_SDA_PIN A4
#define I2C_SCL_PIN A5
#define SENSOR_I2C_ADDR 0x38

// Instantiate the sensor object
Adafruit_AHTX0 aht;

void setup() {
  Serial.begin(115200);
  
  // Wait for serial monitor to open (useful for debugging)
  while (!Serial) {
    delay(10);
  }
  
  Serial.println("Initializing AHT20 Temp & Humidity Sensor...");

  // Initialize the I2C bus with explicit pins
  Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);

  // Begin sensor communication with explicit address
  if (!aht.begin(&Wire, 0, SENSOR_I2C_ADDR)) {
    Serial.println("ERROR: Failed to find AHT chip");
    Serial.println("Action: Check SDA/SCL wiring, I2C pull-ups, and logic levels.");
    
    // Halt execution on fatal hardware error
    // Blink onboard LED to indicate fault state without serial monitor
    pinMode(LED_BUILTIN, OUTPUT);
    while (1) {
      digitalWrite(LED_BUILTIN, HIGH);
      delay(250);
      digitalWrite(LED_BUILTIN, LOW);
      delay(250);
    }
  }
  
  Serial.println("AHT20 initialized successfully.");
}

void loop() {
  // Create event objects to hold the sensor data
  sensors_event_t humidity, temp;
  
  // Trigger a reading and populate the event objects
  aht.getEvent(&humidity, &temp);

  // Print Temperature in Celsius
  Serial.print("Temperature: ");
  Serial.print(temp.temperature, 2);
  Serial.print(" C | ");

  // Print Relative Humidity
  Serial.print("Humidity: ");
  Serial.print(humidity.relative_humidity, 2);
  Serial.println(" %");

  // The AHT20 requires ~2 seconds between reads for thermal stability
  // and to prevent self-heating of the silicon die.
  delay(2000); 
}

Debugging: "Failed to find AHT chip" and I2C Bus Failures

If your serial monitor outputs ERROR: Failed to find AHT chip and the onboard LED starts blinking rapidly, the microcontroller cannot communicate with the sensor at address 0x38. Do not immediately assume the sensor is dead. Follow this ranked troubleshooting path.

The First Three Things to Check

1. SDA and SCL Swapped: This accounts for 70% of I2C failures. Unlike power pins, swapping SDA and SCL will not fry the board, but it will silently kill communication. Verify against the pin mapping table above.
2. Missing I2C Pull-Up Resistors: The I2C protocol uses open-drain outputs. It requires pull-up resistors (typically 4.7kΩ) on both SDA and SCL lines to pull the voltage high. The Adafruit breakout includes these. If you are using a bare, cheap green AHT20 module, it likely lacks pull-ups. Fix: Solder two 4.7kΩ resistors between the SDA/SCL lines and the 3.3V VCC line.
3. Logic Level Mismatch (The Silent Killer): The AHT20 silicon operates natively at 3.3V. If you wire a bare 3.3V sensor directly to a 5V Arduino Uno without a logic level shifter (like the BSS138 MOSFET circuit found on the Adafruit board), you are back-feeding 5V into a 3.3V I2C pin. This can permanently degrade the sensor. Fix: Use a dedicated I2C level shifter module or switch to a 3.3V microcontroller like the Arduino Nano 33 IoT.

Using an I2C Scanner to Isolate the Fault

If the physical checks pass, upload the standard Arduino I2C Scanner sketch (found in File > Examples > Wire > I2CScanner). Open the serial monitor at 9600 baud. If the scanner returns I2C device found at address 0x38, your wiring is perfect, and the issue is a corrupted library installation. Reinstall the Adafruit AHTX0 library. If the scanner returns No I2C devices found, you have a physical layer fault (broken wire, missing pull-up, or dead sensor).

Extending the Build: Adding an OLED and Deep Sleep

Once you have a stable baseline reading, you can extend this temp and humidity sensor Arduino project without changing your core sensor code.

Adding an SSD1306 OLED Display

Because the AHT20 uses I2C, you can share the exact same SDA and SCL bus with an SSD1306 128x64 OLED display. The display typically uses I2C address 0x3C, which does not conflict with the AHT20’s 0x38. Simply wire the OLED VCC, GND, SDA, and SCL in parallel with the sensor. Use the Adafruit_SSD1306 and Adafruit_GFX libraries to render the temp.temperature and humidity.relative_humidity floats directly to the screen inside your loop().

Simplifying for Battery Power (Deep Sleep)

If you are deploying this node in a remote location on a 18650 lithium cell, you must minimize power draw. The AHT20 draws roughly 1.3mA during a measurement and 0.25µA in sleep mode. However, the Arduino Uno’s voltage regulator and USB-to-serial chip draw a constant 20mA+.

Concrete Recommendation: To build a low-power node, abandon the Uno. Port this exact code to an ESP32-C3 SuperMini or an Adafruit QT Py. You can use the ESP32’s esp_deep_sleep_start() function to wake the board every 15 minutes, take a 2-second reading, transmit via MQTT, and return to sleep, reducing average current draw to under 15µA and allowing a single 18650 cell to run the sensor for over a year.

For 95% of hobbyist and home-automation projects, the AHT20 paired with an I2C-compatible microcontroller is the definitive choice. It eliminates the timing fragility of legacy sensors, provides excellent out-of-the-box accuracy, and scales cleanly when you add displays or wireless telemetry to your bus.