SHT85 Temperature and Humidity Sensor

Name: SHT85 Temperature and Humidity Sensor
Brand: ESP32
Price: 34 USD
Availability: InStock

SHT85 Temperature and Humidity Sensor image

View on Amazon

Overview

The SHT85 sensor is a high-accuracy digital temperature and humidity sensor that utilizes Sensirion's CMOSens® technology. It provides calibrated, linearized sensor signals in digital I2C format, 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 SHT85 Temperature and Humidity Sensor

The SHT85, developed by Sensirion, is a high-accuracy digital temperature and humidity sensor designed for demanding measurement and test applications. It features a pin-type connector for easy integration and replacement and a unique package design that enhances thermal coupling while minimizing heat interference from the main board.

⚡ Key Features

Superior Accuracy & Stability – Ensures high-precision temperature and humidity readings.
Pin-Type Connector – Enables easy installation and replacement.
IP67 Protection – A PTFE membrane shields the sensor from liquids and dust, making it ideal for harsh environments.
Optimized for Industrial Use – Designed for climate monitoring, industrial testing, and scientific applications.

🔗 Looking for alternatives? Consider:

SHT21 – A cost-effective option.
SHT30 – Offers a balance of performance and affordability.

With its rugged design and precise measurements, the SHT85 is a top choice for industrial and environmental monitoring. 🚀

Where to Buy

Get Your SHT85

Starting from

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

SHT85 Specifications

Complete technical specification details for SHT85 Temperature and Humidity Sensor

📊 Technical Parameters

Operating Voltage 2.15V to 5.5V

Temperature Range -40°C to 105°C

Humidity Range 0% to 100% RH

Temperature Accuracy ±0.1°C

Humidity Accuracy ±1.5% RH

Interface I2C

Dimensions 19mm x 5.6mm x 3.5mm

Download Full Datasheet

Pin Configuration

SHT85 Pinout

The SHT85 uses standard I²C communication with 4 pins, offering top-tier industrial-grade performance.

Visual Pinout Diagram

Pinout Diagram Primary

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

💡

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

🏆

Premium industrial-grade sensor for demanding applications

Pin Descriptions

Pin Name	Type	Description	Notes
1 SCL	Communication	I²C clock line	Serial Clock Line for I2C communication
2 VDD	Power	Power supply input (2.15V to 5.5V)	Wide voltage range for industrial applications
3 VSS	Power	Ground connection	Connect to ESP32 ground
4 SDA	Communication	I²C data line	Serial Data Line for I2C communication

Connection Guide

Wiring SHT85 to ESP32

Connect the SHT85 using standard I²C interface for industrial-grade environmental monitoring.

Pin Connections

SHT85 Pin	ESP32 Pin	Description
1 VDD Required	3.3V	Power supply (2.15V to 5.5V supported)
2 VSS 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

🏭

Industrial-grade reliability for critical applications

Help & Support

SHT85 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

SHT85 Programming Examples

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

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

SHTSensor sht;

void setup() {
  Wire.begin();
  Serial.begin(9600);
  if (sht.init()) {
    Serial.println("SHT85 sensor initialized successfully.");
  } else {
    Serial.println("Failed to initialize SHT85 sensor.");
  }
}

void loop() {
  if (sht.readSample()) {
    Serial.print("Temperature: ");
    Serial.print(sht.getTemperature(), 2);
    Serial.println(" °C");
    Serial.print("Humidity: ");
    Serial.print(sht.getHumidity(), 2);
    Serial.println(" %");
  } else {
    Serial.println("Failed to read data from SHT85 sensor.");
  }
  delay(2000);
}

This Arduino sketch demonstrates how to interface with the SHT85 sensor using the SHTSensor library. It initializes the sensor and reads temperature and humidity data every 2 seconds, printing the results to the Serial Monitor. Ensure that the SHTSensor library is installed in your Arduino IDE.

#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 SHT85_SENSOR_ADDR    0x44       /*!< SHT85 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_sht85_sensor() {
    uint8_t data[6];
    uint8_t cmd[] = {0x24, 0x00}; // Command to trigger measurement
    i2c_master_write_to_device(I2C_MASTER_NUM, SHT85_SENSOR_ADDR, cmd, 2, pdMS_TO_TICKS(1000));
    vTaskDelay(pdMS_TO_TICKS(15));
    i2c_master_read_from_device(I2C_MASTER_NUM, SHT85_SENSOR_ADDR, data, 6, pdMS_TO_TICKS(1000));

    uint16_t raw_temp = (data[0] << 8) | data[1];
    uint16_t raw_humidity = (data[3] << 8) | data[4];

    float temperature = -45 + 175 * ((float)raw_temp / 65535.0);
    float humidity = 100 * ((float)raw_humidity / 65535.0);

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

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

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

This ESP-IDF code demonstrates how to interface with the SHT85 sensor using the I2C protocol. The function `read_sht85_sensor()` sends a command to the sensor to trigger a measurement, reads the raw temperature and humidity data, and converts it into human-readable values. These values are then 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 SHT85 sensor using the `sht3x` platform. The `address` field specifies the I2C address of the sensor (default: 0x44). Two sensor entities are defined: one for temperature and one for humidity, with user-friendly names like 'Living Room Temperature' and 'Living Room Humidity.' The `update_interval` is set to 60 seconds, ensuring regular updates.

platformio.ini

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
lib_deps = 
    sensirion/SHTSensor @ ^1.0.0
monitor_speed = 115200

main.cpp

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

SHTSensor sht(SHTSensor::SHT3X);

void setup() {
    Serial.begin(115200);
    Wire.begin();

    if (sht.init()) {
        Serial.println("SHT85 initialized successfully.");
    } else {
        Serial.println("SHT85 initialization failed.");
    }
}

void loop() {
    if (sht.readSample()) {
        Serial.print("Temperature: ");
        Serial.print(sht.getTemperature(), 2);
        Serial.println(" °C");
        Serial.print("Humidity: ");
        Serial.print(sht.getHumidity(), 2);
        Serial.println(" %");
    } else {
        Serial.println("Failed to read SHT85 sensor data.");
    }
    delay(2000);
}

This PlatformIO code uses the `SHTSensor` library to interact with the SHT85 sensor. The code initializes the sensor, reads temperature and humidity data every 2 seconds, and outputs the results to the Serial Monitor. The library simplifies the communication process and ensures accurate data handling.

from machine import I2C, Pin
from time import sleep

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

# SHT85 I2C address
SHT85_ADDR = 0x44

# Function to trigger measurement and read data
def read_sht85():
    i2c.writeto(SHT85_ADDR, b'\x24\x00')  # Trigger measurement
    sleep(0.015)  # Wait for measurement
    data = i2c.readfrom(SHT85_ADDR, 6)  # Read 6 bytes of data

    raw_temp = (data[0] << 8) | data[1]
    raw_hum = (data[3] << 8) | data[4]

    temperature = -45 + 175 * (raw_temp / 65535.0)
    humidity = 100 * (raw_hum / 65535.0)

    return temperature, humidity

while True:
    try:
        temp, hum = read_sht85()
        print("Temperature: {:.2f} °C".format(temp))
        print("Humidity: {:.2f} %".format(hum))
    except Exception as e:
        print("Error reading SHT85:", e)

    sleep(2)

This MicroPython script uses the I2C protocol to interface with the SHT85 sensor. It triggers a measurement, reads the raw data, converts it to temperature and humidity, and prints the results to the console every 2 seconds. The `machine.I2C` module is used to handle communication with the sensor.

Summary

Wrapping Up SHT85

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