SHT30 Temperature and Humidity Sensor

Name: SHT30 Temperature and Humidity Sensor
Brand: ESP32
Price: 5 USD
Availability: InStock

SHT30 Temperature and Humidity Sensor image

View on Amazon

Overview

The SHT30 sensor is a high-precision digital temperature and humidity sensor that utilizes Sensirion's CMOSens® technology. It provides fully calibrated, linearized, and temperature-compensated digital output, making it ideal for applications requiring precise and reliable environmental measurements.

Quick Navigation

📋 Specs 📍 Pinout 🔌 Wiring 🔧 Debug

Code Examples

Arduino

C++ Framework

ESP-IDF

Native Framework

ESPHome

YAML Configuration

PlatformIO

IDE & Toolchain

MicroPython

Python Framework

About SHT30 Temperature and Humidity Sensor

The SHT30, developed by Sensirion, is a high-precision digital sensor designed for temperature and humidity measurement. With excellent long-term stability and reliability, it is ideal for HVAC systems, data loggers, and weather stations.

⚡ Key Features

High Accuracy – ±2% RH (humidity) and ±0.3°C (temperature).
I²C Communication – Easy integration with ESP32, Arduino, and other microcontrollers.
Long-Term Stability – Ensures consistent performance over time.
Versatile Applications – Used in climate control, industrial monitoring, and smart home systems.

With its reliability and precision, the SHT30 is a great choice for environmental sensing applications. 🚀

For enhanced performance and additional features, consider the SHT31 sensor, which offers improved accuracy and response time.

Where to Buy

Get Your SHT30

Starting from

$5 per unit

Amazon.com Ships worldwide

View Price

Amazon.de Ships to EU

View Price

AliExpress Best value option

View Price

💡 Prices are subject to change. We earn from qualifying purchases as an Amazon Associate.

Technical Specs

SHT30 Specifications

Complete technical specification details for SHT30 Temperature and Humidity Sensor

📊 Technical Parameters

Operating Voltage 2.4V to 5.5V

Temperature Range -40°C to 125°C

Humidity Range 0% to 100% RH

Temperature Accuracy ±0.3°C

Humidity Accuracy ±2% RH

Interface I2C

Dimensions 2.5mm x 2.5mm x 0.9mm

Download Full Datasheet

Pin Configuration

SHT30 Pinout

The SHT30 uses standard I²C communication with 4 pins, featuring wider voltage range (2.4V-5.5V).

Visual Pinout Diagram

Pinout Diagram Primary

SHT30 Temperature and Humidity Sensor pinout

Total Pins

Pin Types

Power

Communication

Quick Tips

🔌

Standard I²C interface for easy integration,📡 Default I²C address is 0x44 or 0x45 (configurable)

💡

Excellent accuracy: ±0.2°C temp, ±2% humidity,⚡ Wide voltage range (2.4V-5.5V) works with 3.3V and 5V systems

🏆

Professional-grade sensor with fast measurements

Pin Descriptions

Pin Name	Type	Description	Notes
1 VDD	Power	Power supply input (2.4V to 5.5V)	Wide voltage range for flexible power options
2 GND	Power	Ground connection	Connect to ESP32 ground
3 SDA	Communication	I²C data line	Bidirectional data communication
4 SCL	Communication	I²C clock line	Clock signal from master device

Connection Guide

Wiring SHT30 to ESP32

Connect the SHT30 using standard I²C interface for high-precision measurements.

Pin Connections

SHT30 Pin	ESP32 Pin	Description
1 VDD Required	3.3V	Power supply (2.4V to 5.5V supported)
2 GND Required	GND	Ground connection
3 SDA Required	GPIO21	I²C data line (default SDA)
4 SCL Required	GPIO22	I²C clock line (default SCL)

💡

GPIO21/22 are default I²C pins on ESP32

🔧

I²C address is 0x44 or 0x45 (check your module)

⚡

Add 10kΩ pull-up resistors on SDA/SCL if needed

📡

Can share I²C bus with other devices

Help & Support

SHT30 Troubleshooting

Common issues and solutions to help you get your sensor working

Common Issues

Debugging Tips

Additional Resources

Datasheet

Technical specifications and guidelines

Code Examples

SHT30 Programming Examples

Ready-to-use code examples for different platforms and frameworks

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

Adafruit_SHT31 sht31 = Adafruit_SHT31();

void setup() {
  Serial.begin(115200);
  while (!Serial) delay(10);

  if (!sht31.begin(0x44)) {   // Set to 0x45 for alternate i2c addr
    Serial.println("Couldn't find SHT31");
    while (1) delay(1);
  }
}

void loop() {
  float t = sht31.readTemperature();
  float h = sht31.readHumidity();

  if (!isnan(t) && !isnan(h)) {  // check if 'is not a number'
    Serial.print("Temp *C = "); Serial.print(t); Serial.print("	");
    Serial.print("Hum. % = "); Serial.println(h);
  } else {
    Serial.println("Failed to read from SHT31 sensor");
  }

  delay(1000);
}

This Arduino sketch demonstrates how to interface with the SHT30 sensor using the Adafruit SHT31 library. It initializes the sensor and reads temperature and humidity data every second, printing the results to the Serial Monitor. The sensor's I2C address is set to 0x44 by default; if your sensor uses the alternate address (0x45), adjust the initialization accordingly.

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/i2c.h"

#define I2C_MASTER_SCL_IO    22    /*!< GPIO number used for I2C master clock */
#define I2C_MASTER_SDA_IO    21    /*!< GPIO number used for I2C master data */
#define I2C_MASTER_NUM       I2C_NUM_0 /*!< I2C master I2C port number */
#define I2C_MASTER_FREQ_HZ   100000     /*!< I2C master clock frequency */
#define SHT30_SENSOR_ADDR    0x44       /*!< SHT30 I2C address */

static esp_err_t i2c_master_init(void) {
    i2c_config_t conf = {
        .mode = I2C_MODE_MASTER,
        .sda_io_num = I2C_MASTER_SDA_IO,
        .scl_io_num = I2C_MASTER_SCL_IO,
        .sda_pullup_en = GPIO_PULLUP_ENABLE,
        .scl_pullup_en = GPIO_PULLUP_ENABLE,
        .master.clk_speed = I2C_MASTER_FREQ_HZ,
    };
    esp_err_t err = i2c_param_config(I2C_MASTER_NUM, &conf);
    if (err != ESP_OK) {
        return err;
    }
    return i2c_driver_install(I2C_MASTER_NUM, conf.mode, 0, 0, 0);
}

void read_sht30_sensor() {
    uint8_t data[6];
    i2c_master_write_read_device(I2C_MASTER_NUM, SHT30_SENSOR_ADDR, NULL, 0, data, sizeof(data), pdMS_TO_TICKS(1000));

    uint16_t temp_raw = (data[0] << 8) | data[1];
    uint16_t hum_raw = (data[3] << 8) | data[4];

    float temperature = -45 + 175 * ((float)temp_raw / 65535.0);
    float humidity = 100 * ((float)hum_raw / 65535.0);

    printf("Temperature: %.2f °C, Humidity: %.2f %%\n", temperature, humidity);
}

void app_main() {
    ESP_ERROR_CHECK(i2c_master_init());

    while (1) {
        read_sht30_sensor();
        vTaskDelay(pdMS_TO_TICKS(2000));
    }
}

This ESP-IDF code demonstrates how to interface with the SHT30 sensor using the I2C interface. It initializes the I2C master on GPIO21 (SDA) and GPIO22 (SCL) and reads temperature and humidity data from the SHT30. The sensor's raw data is processed and converted into human-readable temperature and humidity values. The readings are printed to the console every 2 seconds.

i2c:
  sda: GPIO21
  scl: GPIO22
  scan: true

sensor:
  - platform: sht3x
    address: 0x44
    temperature:
      name: "Room Temperature"
    humidity:
      name: "Room Humidity"
    update_interval: 60s

The ESPHome configuration uses the `sht3x` platform for interfacing with the SHT30 sensor. The `i2c` section specifies the SDA (GPIO21) and SCL (GPIO22) pins, enabling communication with the sensor. The `address` key indicates the I2C address of the SHT30 sensor (default `0x44`). Two sensor entities are defined: one for temperature and one for humidity, with user-friendly names such as 'Room Temperature' and 'Room Humidity.' The readings are updated every 60 seconds.

platformio.ini

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
lib_deps =
    adafruit/Adafruit SHT31 Library @ ^1.1.0
monitor_speed = 115200

main.cpp

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

Adafruit_SHT31 sht31 = Adafruit_SHT31();

void setup() {
    Serial.begin(115200);
    if (!sht31.begin(0x44)) {
        Serial.println("Couldn't find SHT30 sensor. Check wiring!");
        while (1);
    }
    Serial.println("SHT30 initialized.");
}

void loop() {
    float temperature = sht31.readTemperature();
    float humidity = sht31.readHumidity();

    if (!isnan(temperature) && !isnan(humidity)) {
        Serial.print("Temperature: ");
        Serial.print(temperature);
        Serial.println(" °C");

        Serial.print("Humidity: ");
        Serial.print(humidity);
        Serial.println(" %");
    } else {
        Serial.println("Failed to read from SHT30 sensor!");
    }
    delay(2000);
}

This PlatformIO code initializes the SHT30 sensor using the Adafruit library. The setup checks for the sensor's presence at the default I2C address `0x44`. If successful, the loop continuously reads temperature and humidity values, printing them to the Serial Monitor every 2 seconds. Any errors in reading are reported in the console.

from machine import Pin, I2C
from time import sleep
import sht31

# Initialize I2C (SDA=21, SCL=22)
i2c = I2C(0, scl=Pin(22), sda=Pin(21))
sensor = sht31.SHT31(i2c)

print("SHT30 Sensor Example")

while True:
    temperature, humidity = sensor.measure()
    print("Temperature: {:.2f} °C".format(temperature))
    print("Humidity: {:.2f} %".format(humidity))
    sleep(2)

This MicroPython code uses the `sht31` library to interface with the SHT30 sensor. The I2C bus is initialized on GPIO21 (SDA) and GPIO22 (SCL). The `sensor.measure()` function retrieves temperature and humidity readings, which are formatted and printed to the console every 2 seconds. The code is lightweight and ideal for microcontroller projects.

Summary

Wrapping Up SHT30

The ESP32 SHT30 Temperature and Humidity Sensor is a powerful environment sensor that offers excellent performance and reliability. With support for multiple development platforms including Arduino, ESP-IDF, ESPHome, PlatformIO, and MicroPython, it's a versatile choice for your IoT projects.