SHT40 ESP32 Wiring Guide: I2C Connection, Arduino Code and Troubleshooting

Quick Setup Summary

The table below gives the practical setup for connecting an SHT40 sensor to ESP32 before moving into code and troubleshooting.

What is the SHT40 Temperature Humidity Sensor?

The SHT40 is a compact digital temperature and relative humidity sensor that communicates through I2C. It is commonly used in IoT environmental monitoring, smart home devices, HVAC monitoring, data loggers and embedded systems that need digital humidity and temperature data.

For engineers selecting a compact temperature and humidity sensor for an ESP32-based design, NYFEA's FHT40 digital temperature and humidity sensor is an SHT40-class option for environmental sensing applications.

SHT40 Key Specifications for ESP32 Projects

These values are typical SHT40 reference specifications. For production design, always verify the exact sensor part number, breakout board and operating conditions.

SHT40 ESP32 Wiring Connection

The SHT40 uses a standard I2C connection. On many classic ESP32 development boards, GPIO21 and GPIO22 are commonly used as SDA and SCL. If your board labels different I2C pins, use those board-specific pins and update the code.

Place the sensor away from the ESP32 module, voltage regulator and other heat sources. Board heat can make the measured temperature higher than the actual ambient temperature.

SHT40 I2C Address

The most common SHT40 I2C address is 0x44. Some SHT40 variants may use other factory-configured I2C addresses such as 0x45 or 0x46, so check the exact part number or module documentation before production use.

If the ESP32 cannot detect the sensor, run an I2C scanner first. A detected address confirms that a device responded on the bus, but it does not prove that temperature and humidity measurements are already valid.

ESP32, ESP32-S3 and ESP32-C3 I2C Pin Notes

ESP32 boards can usually assign I2C to different GPIO pins in software. GPIO21 for SDA and GPIO22 for SCL are common on many classic ESP32 development boards, while ESP32-S3 and ESP32-C3 boards often use board-specific pin assignments.

For ESP32-S3 and ESP32-C3, check the exact development board pinout before wiring the SHT40 sensor. If the board silkscreen labels SDA and SCL, use those pins first.

ESP32 Arduino Code for SHT40

The following Arduino example reads temperature and humidity data from SHT40 through the ESP32 I2C interface. It uses GPIO21 as SDA and GPIO22 as SCL for the classic ESP32 wiring shown above. If you use ESP32-S3 or ESP32-C3, replace these pin numbers with the pins from your board.

#include <Wire.h>
#include "Adafruit_SHT4x.h"

Adafruit_SHT4x sht4 = Adafruit_SHT4x();

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);

  if (!sht4.begin()) {
    Serial.println("SHT40 not found");
    while (1);
  }

  Serial.println("SHT40 sensor detected");
}

void loop() {
  sensors_event_t humidity, temp;
  sht4.getEvent(&humidity, &temp);

  Serial.print("Temperature: ");
  Serial.print(temp.temperature);
  Serial.println(" C");

  Serial.print("Humidity: ");
  Serial.print(humidity.relative_humidity);
  Serial.println(" %RH");

  delay(1000);
}

Advanced: CRC-Checked SHT40 Reading Code

The simple library example above is enough for most projects. For engineering validation, the SHT40 response can also be checked manually. The high precision command 0xFD returns six bytes: two temperature bytes, one temperature CRC byte, two humidity bytes and one humidity CRC byte.

#include <Wire.h>

const uint8_t SHT40_ADDR = 0x44;
const int SDA_PIN = 21;
const int SCL_PIN = 22;

uint8_t sht40Crc8(const uint8_t *data, int len) {
  uint8_t crc = 0xFF;

  for (int i = 0; i < len; i++) {
    crc ^= data[i];

    for (int bit = 0; bit < 8; bit++) {
      if (crc & 0x80) {
        crc = (crc << 1) ^ 0x31;
      } else {
        crc <<= 1;
      }
    }
  }

  return crc;
}

bool readSHT40(float &temperatureC, float &humidityRH) {
  Wire.beginTransmission(SHT40_ADDR);
  Wire.write(0xFD);  // high precision measurement command

  if (Wire.endTransmission() != 0) {
    return false;
  }

  delay(20);

  if (Wire.requestFrom((int)SHT40_ADDR, 6) != 6) {
    return false;
  }

  uint8_t data[6];
  for (int i = 0; i < 6; i++) {
    data[i] = Wire.read();
  }

  if (sht40Crc8(data, 2) != data[2]) {
    Serial.println("Temperature CRC failed");
    return false;
  }

  if (sht40Crc8(&data[3], 2) != data[5]) {
    Serial.println("Humidity CRC failed");
    return false;
  }

  uint16_t rawT = ((uint16_t)data[0] << 8) | data[1];
  uint16_t rawRH = ((uint16_t)data[3] << 8) | data[4];

  temperatureC = -45.0f + 175.0f * (float)rawT / 65535.0f;
  humidityRH = -6.0f + 125.0f * (float)rawRH / 65535.0f;

  if (humidityRH > 100.0f) humidityRH = 100.0f;
  if (humidityRH < 0.0f) humidityRH = 0.0f;

  return true;
}

void setup() {
  Serial.begin(115200);
  Wire.begin(SDA_PIN, SCL_PIN);
}

void loop() {
  float temperatureC;
  float humidityRH;

  if (readSHT40(temperatureC, humidityRH)) {
    Serial.print("Temperature: ");
    Serial.print(temperatureC);
    Serial.println(" C");

    Serial.print("Humidity: ");
    Serial.print(humidityRH);
    Serial.println(" %RH");
  } else {
    Serial.println("SHT40 measurement failed");
  }

  delay(1000);
}

Use this advanced version when a project needs to distinguish a wiring problem from a corrupted measurement frame. If the I2C scanner finds 0x44 but CRC fails, the bus can acknowledge the address but the measurement data should not be trusted.

I2C Scanner Code for SHT40 and ESP32

Before running the measurement sketch, use an I2C scanner to confirm that the ESP32 can detect the SHT40 on the bus. This is especially useful when using ESP32-S3 or ESP32-C3 boards with different I2C pins.

#include <Wire.h>

const int SDA_PIN = 21;
const int SCL_PIN = 22;

void setup() {
  Serial.begin(115200);
  Wire.begin(SDA_PIN, SCL_PIN);
  Serial.println("I2C scanner started");
}

void loop() {
  byte error;
  byte address;
  int devices = 0;

  for (address = 1; address < 127; address++) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();

    if (error == 0) {
      Serial.print("I2C device found at address 0x");
      if (address < 16) {
        Serial.print("0");
      }
      Serial.println(address, HEX);
      devices++;
    }
  }

  if (devices == 0) {
    Serial.println("No I2C devices found");
  }

  delay(3000);
}

If the scanner reports 0x44, the ESP32 has detected a device at the common SHT40 address. If no address appears, check power, ground, SDA, SCL, pull-up resistors and the pin numbers in Wire.begin().

Troubleshooting SHT40 ESP32 Communication Problems

Start with the symptom you see in the serial monitor, then check the wiring, I2C pins and sensor placement before changing the code.

SHT40 ESP32 Applications

SHT40 with ESP32 is suitable for Wi-Fi environmental monitoring, smart thermostats, indoor air quality devices, HVAC monitoring, greenhouse sensing and industrial temperature humidity data logging. In each case, sensor placement and airflow are just as important as the wiring and code.