SHT35 Temperature and Humidity Sensor

Name: SHT35 Temperature and Humidity Sensor
Brand: ESP32
Price: 10 USD
Availability: InStock

SHT35 Temperature and Humidity Sensor image

View on Amazon

Overview

The SHT35 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 SHT35 Temperature and Humidity Sensor

The SHT35, developed by Sensirion, is the premium model in the SHT3x series, offering superior accuracy and reliability. It is designed for demanding applications such as industrial monitoring, HVAC systems, and environmental data logging.

⚡ Key Features

Highest Accuracy in the SHT3x Series – Superior precision for critical applications.
I²C Communication – Easy integration with ESP32, Arduino, and other microcontrollers.
Long-Term Stability – Ensures consistent and reliable environmental measurements.
Ideal for Professional Use – Used in scientific monitoring, industrial automation, and smart HVAC systems.

🔗 Looking for cost-effective alternatives? Consider:

SHT30 – Budget-friendly option with good performance.
SHT31 – Mid-range model balancing accuracy and cost.

Where to Buy

Get Your SHT35

Starting from

$10 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

SHT35 Specifications

Complete technical specification details for SHT35 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.1°C

Humidity Accuracy ±1.5% RH

Interface I2C

Dimensions 2.5mm x 2.5mm x 0.9mm

Download Full Datasheet

Pin Configuration

SHT35 Pinout

The SHT35 uses standard I²C communication with 4 pins, offering top-tier accuracy and durability.

Visual Pinout Diagram

Pinout Diagram Primary

SHT35 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)

💡

Top accuracy: ±0.1°C temp, ±1.5% humidity,⚡ Wide voltage range (2.4V-5.5V) for industrial use

🏆

Premium sensor for demanding professional applications

Pin Descriptions

Pin Name	Type	Description	Notes
1 VDD	Power	Power supply input (2.4V to 5.5V)	Wide voltage range for industrial applications
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 SHT35 to ESP32

Connect the SHT35 using standard I²C interface for maximum precision measurements.

Visual Wiring Diagram

Wiring Diagram Recommended

SHT35 Temperature and Humidity Sensor wiring with ESP32

Connections

Connection Status

Required

Protocol

I2C

Pin Connections

SHT35 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

SHT35 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

SHT35 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 address
    Serial.println("Couldn't find SHT35");
    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 SHT35 sensor");
  }

  delay(1000);
}

This Arduino sketch demonstrates how to interface with the SHT35 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 SHT35_SENSOR_ADDR    0x44       /*!< SHT35 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_sht35_sensor() {
    uint8_t data[6];
    i2c_master_write_read_device(I2C_MASTER_NUM, SHT35_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_sht35_sensor();
        vTaskDelay(pdMS_TO_TICKS(2000));
    }
}

This ESP-IDF code demonstrates how to interface with the SHT35 sensor using the I2C interface. The I2C master is initialized on GPIO21 (SDA) and GPIO22 (SCL). The `read_sht35_sensor()` function reads raw temperature and humidity data from the SHT35 sensor and converts it into human-readable values. These values are printed to the console every 2 seconds.

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

This ESPHome configuration defines the SHT35 sensor using the `sht3x` platform. The I2C address is set to 0x44 (default for the sensor). Two entities are configured: one for temperature and one for humidity, with descriptive names like 'Living Room Temperature' and 'Living Room Humidity.' The `update_interval` is set to 60 seconds, meaning the data will be updated every minute.

platformio.ini

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

main.cpp

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

Adafruit_SHT31 sht35 = Adafruit_SHT31();

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

    if (!sht35.begin(0x44)) {   // Default I2C address for SHT35
        Serial.println("Couldn't find SHT35 sensor!");
        while (1) delay(1);
    }
}

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

    if (!isnan(temperature) && !isnan(humidity)) {  // Check if readings are valid
        Serial.print("Temperature: ");
        Serial.print(temperature);
        Serial.println(" °C");
        Serial.print("Humidity: ");
        Serial.print(humidity);
        Serial.println(" %");
    } else {
        Serial.println("Failed to read from SHT35 sensor!");
    }

    delay(2000);  // Wait 2 seconds between readings
}

This PlatformIO sketch demonstrates how to interface with the SHT35 sensor using the Adafruit SHT31 library. The sensor is initialized on its default I2C address (0x44). Temperature and humidity values are read every 2 seconds and printed to the Serial Monitor. If readings fail, an error message is displayed.

from machine import I2C, Pin
import time

# SHT35 default I2C address
SHT35_I2C_ADDRESS = 0x44

# Initialize I2C communication (SDA=21, SCL=22)
i2c = I2C(0, scl=Pin(22), sda=Pin(21))

def read_sht35():
    # Send measurement command (high repeatability, no clock stretching)
    i2c.writeto(SHT35_I2C_ADDRESS, b'\x24\x00')
    time.sleep(0.015)  # Wait for measurement to complete

    # Read 6 bytes of data
    data = i2c.readfrom(SHT35_I2C_ADDRESS, 6)

    # Convert the data
    temp_raw = (data[0] << 8) | data[1]
    humidity_raw = (data[3] << 8) | data[4]

    # Calculate temperature and humidity
    temperature = -45 + (175 * temp_raw / 65535.0)
    humidity = 100 * humidity_raw / 65535.0

    return temperature, humidity

while True:
    try:
        temperature, humidity = read_sht35()
        print("Temperature: {:.2f} °C".format(temperature))
        print("Humidity: {:.2f} %".format(humidity))
    except Exception as e:
        print("Failed to read from SHT35 sensor:", e)

    time.sleep(2)

This MicroPython script interfaces with the SHT35 sensor using the I2C protocol. The `read_sht35` function sends a command to the sensor to initiate a measurement, waits for the response, and then reads 6 bytes of data. The raw data is processed into human-readable temperature (°C) and humidity (%) values. The script continuously reads and prints these values every 2 seconds. Error handling is included to manage failed readings.

Summary

Wrapping Up SHT35

The ESP32 SHT35 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.