Choosing the Right DHT Sensor: Unraveling the Differences Between Types for Optimal Performance

Fawad February 13, 2024

0 10 9 minutes read

Table of Contents

Introduction:

When it comes to measuring humidity and temperature accurately, choosing the right DHT sensor is essential. However, with different types of sensors available in the market, it can be overwhelming to identify the one that best suits your needs. In this article, we unravel the differences between various DHT sensor types to help you achieve optimal performance in your projects.

The DHT sensor family includes popular models like DHT11, DHT22, and DHT21, each with its unique features and capabilities. Understanding these differences will enable you to make an informed decision based on your specific requirements.

We’ll delve into the technical specifications, such as temperature and humidity range, accuracy, power consumption, and communication protocols supported by each sensor type. By exploring these aspects, you can hone in on the sensor that aligns with your project goals and ensures consistent and reliable measurements.

Whether you’re an electronics enthusiast or a professional engineer, this article will provide valuable insights into selecting the right DHT sensor for your temperature and humidity monitoring needs. Let’s dive in and discover the perfect sensor to elevate your projects to new heights.

Understanding the importance of choosing the right DHT sensor

Accurate measurement of temperature and humidity is crucial in various industries, including agriculture, HVAC systems, and indoor environmental monitoring. Whether you’re monitoring the climate in a greenhouse or ensuring optimal conditions in a server room, having a reliable DHT sensor is essential.

Using the wrong sensor can lead to inaccurate readings, which can have severe consequences. For example, in agriculture, improper monitoring of temperature and humidity can result in crop damage or failure. In HVAC systems, inaccurate measurements can lead to inefficient energy usage or even equipment failure.

By selecting the right DHT sensor, you can ensure consistent and reliable measurements, leading to improved decision-making and enhanced overall performance. Now, let’s explore the different types of DHT sensors available in the market.

Amazon links:

*Please Note: These are affiliate links. I may make a commission if you buy the components through these links. I would appreciate your support in this way!

Types of DHT sensors available in the market

DHT11 Sensor

The DHT11 sensor is an entry-level sensor widely used for hobbyist projects and basic temperature and humidity monitoring. It offers a temperature range of 0 to 50 degrees Celsius with an accuracy of +/- 2 degrees Celsius. The humidity range is 20% to 90% with an accuracy of +/- 5%.

With a low-cost design, the DHT11 sensor is suitable for applications where high accuracy is not critical. It operates on a single-wire digital interface, making it easy to integrate into microcontroller-based projects. However, due to its lower accuracy and limited temperature and humidity range, it may not be suitable for more demanding applications.

DHT22 Sensor

The DHT22 sensor, also known as the AM2302, is an advanced version compared to the DHT11. It offers a wider temperature range of -40 to 80 degrees Celsius with an accuracy of +/- 0.5 degrees Celsius. The humidity range is 0% to 100% with an accuracy of +/- 2.5%.

The DHT22 sensor provides higher accuracy and a broader operating range, making it suitable for a wide range of applications. It also features a more robust design, making it more reliable in harsh environments. The DHT22 sensor communicates using a single-wire digital interface, making it compatible with various microcontrollers.

DHT12 Sensor

The DHT12 sensor is a variant of the DHT11 sensor, offering improved accuracy and a wider operating voltage range. It provides a temperature range of -20 to 60 degrees Celsius with an accuracy of +/- 0.5 degrees Celsius. The humidity range is 20% to 95% with an accuracy of +/- 5%.

With its enhanced accuracy and wider voltage range, the DHT12 sensor is suitable for applications where higher precision is required. It also offers a low-power standby mode, making it energy efficient. The DHT12 sensor communicates using a two-wire serial interface, requiring fewer pins on the microcontroller.

DHT21 Sensor

The DHT21 sensor, also known as the AM2301, is similar to the DHT22 sensor in terms of accuracy and operating range. It offers a temperature range of -40 to 80 degrees Celsius with an accuracy of +/- 0.5 degrees Celsius. The humidity range is 0% to 100% with an accuracy of +/- 2.5%.

The DHT21 sensor shares similar specifications with the DHT22, making it suitable for various applications. However, it uses a different communication protocol called the I2C interface, which may require additional hardware support on the microcontroller.

DHT11 sensor: Features and specifications

The DHT11 sensor is an entry-level option that offers basic temperature and humidity sensing capabilities. It operates in a temperature range of 0°C to 50°C with a humidity range of 20% to 80%. The accuracy of the sensor is ±2°C for temperature and ±5% for humidity.

One of the advantages of the DHT11 sensor is its low cost, making it an attractive option for hobbyists and beginners. However, it has a relatively lower accuracy compared to other DHT sensors. Additionally, the DHT11 sensor has a slower response time and limited communication protocols, supporting only the single-wire digital interface.

Despite its limitations, the DHT11 sensor can still be suitable for applications where high accuracy is not critical. It can be used in environmental monitoring, home automation, and simple temperature and humidity measurement projects.

Feature	Specification
Sensor Type	Digital temperature and humidity sensor
Operating Voltage	3 to 5.5 Volts
Measuring Range	Temperature: 0 to 50°C (±2°C) Humidity: 20 to 90% RH (±5% RH)
Response Time	1 second
Data Output Format	Digital signal
Sampling Rate	≤1 Hz (once every second)
Power Consumption	Low, typically 2.5mA
Long-term Stability	±1% RH/year
Interface	Single-wire two-way interface
Dimensions	Small, with a common size of 15.5mm x 12mm x 5.5mm
Operating Conditions	0-50°C, max 95% RH non-condensing
Storage Conditions	-10 to 60°C, < 80% RH
Application Fields	Home appliances, weather stations, consumer goods, etc.

DHT22 sensor: Features and specifications

The DHT22 sensor, also known as the AM2302, is an upgraded version of the DHT11. It offers improved accuracy and a wider temperature and humidity range. The DHT22 operates in a temperature range of -40°C to 80°C with a humidity range of 0% to 100%. The accuracy of the sensor is ±0.5°C for temperature and ±2% for humidity.

Compared to the DHT11, the DHT22 sensor provides more reliable and precise measurements, making it suitable for applications where higher accuracy is required. It has a faster response time and supports both single-wire digital interface and two-wire I2C communication protocols.

The DHT22 sensor is commonly used in weather stations, HVAC systems, agriculture, and industrial applications. Its wider temperature range and improved accuracy make it a versatile choice for various projects.

Feature	Specification
Sensor Type	Digital temperature and humidity sensor
Operating Voltage	3.3 to 6 Volts
Measuring Range	Temperature: -40 to 80°C (±0.5°C) Humidity: 0 to 100% RH (±2-5% RH)
Response Time	2 seconds
Data Output Format	Digital signal
Sampling Rate	≤0.5 Hz (once every 2 seconds)
Power Consumption	Low, typically 2.5mA during measurement
Long-term Stability	< ±0.5% RH/year
Interface	Single-wire two-way interface
Dimensions	Generally small, around 28.2mm x 13.1mm x 10mm
Operating Conditions	-40 to 80°C, 0-100% RH non-condensing
Storage Conditions	-40 to 80°C, < 90% RH
Application Fields	More precise home and industrial applications, HVAC, data loggers, weather stations, etc.

DHT12 sensor: Features and specifications

The DHT12 sensor is another member of the DHT sensor family, offering similar features to the DHT11. It operates in a temperature range of -20°C to 60°C with a humidity range of 20% to 95%. The accuracy of the sensor is ±0.5°C for temperature and ±2% for humidity.

Although the DHT12 sensor has comparable specifications to the DHT11, it has a smaller form factor, making it suitable for space-constrained projects. It also supports the single-wire digital interface for communication.

The DHT12 sensor can be used in applications such as indoor climate control, greenhouse monitoring, and personal weather stations. Its compact size and decent accuracy make it a convenient choice for projects where space is limited.

Feature	Specification
Sensor Type	Digital temperature and humidity sensor
Operating Voltage	2.7 to 5.5 Volts
Measuring Range	Temperature: -20 to 60°C (±0.5°C) Humidity: 20 to 95% RH (±5% RH)
Resolution	Temperature: 0.1°C
	Humidity: 1% RH
Output	Digital (I2C) and single-bus modes
Power Consumption	Ultra-low power, typically around 2.5mA
Sampling Rate	Not specified; typically low
Interface	I2C and single-wire (similar to DHT11)
Accuracy	Higher than DHT11, lower than DHT22
Operating Conditions	-20 to 60°C, 20-95% RH non-condensing
Storage Conditions	-40 to 80°C, < 80% RH
Dimensions	Similar to DHT11 and DHT22
Application Fields	Home appliances, weather stations, consumer goods, DIY projects with microcontrollers like Arduino

DHT21 sensor: Features and specifications

The DHT21 sensor, also known as the AM2301, is a digital temperature and humidity sensor. It is similar to the DHT22 sensor but comes with a slightly different packaging and may have some variations in performance. Here are its features and specifications laid out in a table:

Feature	Specification
Sensor Type	Digital temperature and humidity sensor
Operating Voltage	3.3 to 5 Volts
Measuring Range	Temperature: -40 to 80°C (±0.5°C) Humidity: 0 to 99.9% RH (±2-5% RH)
Response Time	2 seconds
Data Output Format	Digital signal (1-Wire communication protocol)
Accuracy	Temperature: ±0.5°C
	Humidity: ±2-5% RH
Resolution	Temperature: 0.1°C
	Humidity: 0.1% RH
Power Consumption	Low, typically around 2.5mA during operation
Long-term Stability	< ±0.5% RH/year
Interface	Single-wire (similar to DHT22)
Operating Conditions	-40 to 80°C, 0-99.9% RH non-condensing
Storage Conditions	-40 to 80°C, < 80% RH
Application Fields	Home and industrial applications, HVAC, data loggers, weather stations, etc.

The DHT21 is suitable for applications where accurate and reliable temperature and humidity readings are needed. It is widely used in various systems such as HVAC, dehumidifiers, testing and inspection equipment, consumer goods, and weather stations.

Factors to consider when choosing a DHT sensor

When selecting a DHT sensor, there are several factors to consider to ensure it meets your project requirements. These factors include:

Accuracy: The accuracy of the sensor determines how closely it can measure temperature and humidity. Choose a sensor with the required level of accuracy for your specific application.
Temperature and Humidity Range: Consider the temperature and humidity range in which your project operates. Select a sensor that can withstand and accurately measure within the desired range.
Power Consumption: Different sensors have varying power consumption levels. If your project is battery-powered or requires low power consumption, choose a sensor that aligns with your power requirements.
Communication Protocols: Depending on your project’s needs, consider the communication protocols supported by the sensor. Single-wire digital interfaces and I2C are common options.
Form Factor: The physical size of the sensor may be important if you have space limitations. Choose a sensor that fits within your project’s constraints.

By considering these factors, you can make an informed decision and select the DHT sensor that best suits your project’s needs.

Examples of applications for different DHT sensors

Each DHT sensor has its own strengths and weaknesses, making them suitable for different applications. Here are some examples of projects where specific DHT sensors excel:

DHT11: The DHT11 sensor is ideal for simple temperature and humidity monitoring projects where high accuracy is not critical. It can be used in home automation, environmental monitoring, and basic IoT applications.
DHT22: The DHT22 sensor is well-suited for weather stations, HVAC systems, and industrial applications that require accurate temperature and humidity measurements. Its wider temperature range and improved accuracy make it a reliable choice for these projects.
DHT12: The DHT12 sensor’s compact size makes it suitable for projects with limited space. It can be used in indoor climate control, greenhouse monitoring, and personal weather stations.
DHT21: The DHT21 sensor, like the DHT22, is suitable for weather monitoring, hydroponics, and indoor climate control projects. Its accuracy and reliability make it a preferred choice for applications that require precise temperature and humidity measurements.

Consider the specific requirements of your project and match them with the capabilities of the various DHT sensors to make the right choice.

Practical Example 1: interfacing DHT11 with Arduino:

Circuit diagram:

Program:

#include "DHT.h"

DHT dht;

void setup()
{
  Serial.begin(9600);
  Serial.println();
  Serial.println("Status\tHumidity (%)\tTemperature (C)\t(F)");

  dht.setup(2); // data pin 2
}

void loop()
{
  delay(dht.getMinimumSamplingPeriod());

  float humidity = dht.getHumidity();
  float temperature = dht.getTemperature();

  Serial.print(dht.getStatusString());
  Serial.print("\t");
  Serial.print(humidity, 1);
  Serial.print("\t\t");
  Serial.print(temperature, 1);
  Serial.print("\t\t");
  Serial.println(dht.toFahrenheit(temperature), 1);
}

#include "DHT.h"

DHT dht;

void setup()

{

Serial.begin(9600);

Serial.println();

Serial.println("Status\tHumidity (%)\tTemperature (C)\t(F)");

dht.setup(2); // data pin 2

}

void loop()

{

delay(dht.getMinimumSamplingPeriod());

float humidity = dht.getHumidity();

float temperature = dht.getTemperature();

Serial.print(dht.getStatusString());

Serial.print("\t");

Serial.print(humidity, 1);

Serial.print("\t\t");

Serial.print(temperature, 1);

Serial.print("\t\t");

Serial.println(dht.toFahrenheit(temperature), 1);

}

for complete tutorial read this article.

Practical Example 2: interfacing DHT21 and ssd1306 oled with Arduino

Circuit diagram:

DHT21 and ssd1306 oled with Arduino Program:

#include <DHT.h>;
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
//Constants
#define DHTPIN 2            //what pin we're connected to
#define DHTTYPE DHT21       //DHT 21  (AM2301)
DHT dht(DHTPIN, DHTTYPE);   //Initialize DHT sensor for normal 16mhz Arduino

int buzzer=4;
//Variables
float hum;  //Stores humidity value
float temp; //Stores temperature value

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void setup()
{
  Serial.begin(9600);
  pinMode(buzzer,OUTPUT);
  dht.begin();
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  delay(2000);
  display.clearDisplay();
  display.setTextColor(WHITE);
  delay(10);
}

void loop()
{
  //Read data and store it to variables hum and temp
  hum = dht.readHumidity();
  temp= dht.readTemperature();
  
  //Print temp and humidity values to serial monitor
  Serial.print("Humidity: ");
  Serial.print(hum);
  Serial.print("%,  Temperature: ");
  Serial.print(temp);
  Serial.println(" Celsius");
   display.clearDisplay();
     display.setTextSize(2);
  display.setCursor(0, 10);
  display.print(temp);
   display.print((char)247);
  display.print("C");
    display.setTextSize(2);
  display.setCursor(0, 30);
 display.print("H:"+String(hum)+"%"); 

    display.display();
    
  if(temp>40)
{
  digitalWrite(buzzer,HIGH);
  }
  else
  {
      digitalWrite(buzzer,LOW);

    }
  delay(1000); //Delay 2 sec.
}

#include <DHT.h>;

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

//Constants

#define DHTPIN 2 //what pin we're connected to

#define DHTTYPE DHT21 //DHT 21 (AM2301)

DHT dht(DHTPIN, DHTTYPE); //Initialize DHT sensor for normal 16mhz Arduino

int buzzer=4;

//Variables

float hum; //Stores humidity value

float temp; //Stores temperature value

#define SCREEN_WIDTH 128 // OLED display width, in pixels

#define SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)

#define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin)

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void setup()

{

Serial.begin(9600);

pinMode(buzzer,OUTPUT);

dht.begin();

display.begin(SSD1306_SWITCHCAPVCC, 0x3C);

delay(2000);

display.clearDisplay();

display.setTextColor(WHITE);

delay(10);

}

void loop()

{

//Read data and store it to variables hum and temp

hum = dht.readHumidity();

temp= dht.readTemperature();

//Print temp and humidity values to serial monitor

Serial.print("Humidity: ");

Serial.print(hum);

Serial.print("%, Temperature: ");

Serial.print(temp);

Serial.println(" Celsius");

display.clearDisplay();

display.setTextSize(2);

display.setCursor(0, 10);

display.print(temp);

display.print((char)247);

display.print("C");

display.setTextSize(2);

display.setCursor(0, 30);

display.print("H:"+String(hum)+"%");

display.display();

if(temp>40)

{

digitalWrite(buzzer,HIGH);

}

else

{

digitalWrite(buzzer,LOW);

}

delay(1000); //Delay 2 sec.

}

for complete tutorial read this article.

Practical Example 3: interfacing DHT21 and ssd1306 oled with attiny85

Circuit diagram:

DHT21 and ssd1306 oled with attiny85 Program:

#include <dht.h>
#include <TinyWireM.h>
#include <Tiny4kOLED.h>
#define DHT21_PIN PB1
const unsigned char  img_thermometer[] PROGMEM = {
  0x00, 0xfe, 0x03, 0xfe, 0x50,
  0x00, 0xff, 0x00, 0xff, 0x55,
  0x60, 0x9f, 0x80, 0x9f, 0x65,
};
dht DHT;
float getTemperature() {
  return DHT.temperature;
}
float getHumidity() {
  return DHT.humidity;
}
void setup() {
  pinMode(DHT21_PIN, INPUT);
  oled.begin(128, 64, sizeof(tiny4koled_init_128x64br), tiny4koled_init_128x64br);

  // Two fonts are supplied with this library, FONT8X16 and FONT6X8
  oled.setFont(FONT8X16);
  // To clear all the memory
  oled.clear();
  oled.on();
  delay(3000);
  
}

void loop() {
  static long startTime = 0;
  long currentTime;

  DHT.read22(DHT21_PIN);

  // Get current time
  currentTime = millis();

  // Checks 1 second passed
  if ((currentTime - startTime) > 1000) {
    startTime = currentTime;
    // Update temperature
    float temperature = getTemperature();
    // Set cursor
    oled.setCursor(15, 4);
    oled.print("Temp: ");
    // Print to display
    oled.print(temperature, 1);
    oled.print(" °C  ");
    // Update humidity
    float humidity = getHumidity();
    // Set cursor
    oled.setCursor(15, 6);
    oled.print("Humi: ");
    // Print to display
    oled.print(humidity, 1);
    oled.print(" %  ");

    oled.bitmap(2, 5, 7, 8, img_thermometer);
  }
}

#include <dht.h>

#include <TinyWireM.h>

#include <Tiny4kOLED.h>

#define DHT21_PIN PB1

const unsigned char img_thermometer[] PROGMEM = {

0x00, 0xfe, 0x03, 0xfe, 0x50,

0x00, 0xff, 0x00, 0xff, 0x55,

0x60, 0x9f, 0x80, 0x9f, 0x65,

};

dht DHT;

float getTemperature() {

return DHT.temperature;

}

float getHumidity() {

return DHT.humidity;

}

void setup() {

pinMode(DHT21_PIN, INPUT);

oled.begin(128, 64, sizeof(tiny4koled_init_128x64br), tiny4koled_init_128x64br);

// Two fonts are supplied with this library, FONT8X16 and FONT6X8

oled.setFont(FONT8X16);

// To clear all the memory

oled.clear();

oled.on();

delay(3000);

}

void loop() {

static long startTime = 0;

long currentTime;

DHT.read22(DHT21_PIN);

// Get current time

currentTime = millis();

// Checks 1 second passed

if ((currentTime - startTime) > 1000) {

startTime = currentTime;

// Update temperature

float temperature = getTemperature();

// Set cursor

oled.setCursor(15, 4);

oled.print("Temp: ");

// Print to display

oled.print(temperature, 1);

oled.print(" °C ");

// Update humidity

float humidity = getHumidity();

// Set cursor

oled.setCursor(15, 6);

oled.print("Humi: ");

// Print to display

oled.print(humidity, 1);

oled.print(" % ");

oled.bitmap(2, 5, 7, 8, img_thermometer);

}

for complete tutorial read this article.

Practical Example 4: ESP8266 with Telegram Messenger for Monitoring Temperature and Humidity using DHT11

Circuit diagram:

ESP8266 and DHT111 with Telegram Messenger Program:

#include <ESP8266WiFi.h>

#include <WiFiClientSecure.h>

#include <UniversalTelegramBot.h>

#include "DHT.h"

#define DHTPIN D1

#define DHTTYPE DHT11   // DHT 11

DHT dht(DHTPIN, DHTTYPE);

// Initialize Wifi connection to the router

char ssid[] = "AndroidAP3DEC";     // Wifi Name

char password[] = "123456"; // Wifi Password

// Initialize Telegram BOT

#define BOTtoken "5046061617:AAGM5mOCbPLZ4j92BwCSexfyzQIgyvAWmL8" // Bot token from telegram app

WiFiClientSecure client;

UniversalTelegramBot bot(BOTtoken, client);

//Checks for new messages every 1 second.

int botRequestDelay = 1000;

unsigned long lastTimeBotRan;

void handleNewMessages(int numNewMessages) {

Serial.println("handleNewMessages");

Serial.println(String(numNewMessages));

for (int i=0; i<numNewMessages; i++) {

String chat_id = String(bot.messages[i].chat_id);

String text = bot.messages[i].text;

String from_name = bot.messages[i].from_name;

if (from_name == "") from_name = "Guest";

if (text == "/temperature") {

int t = dht.readTemperature();

String temp = "Temperature : ";

temp += int(t);

temp +=" *C\n";

bot.sendMessage(chat_id,temp, "");

}

if (text == "/humidity") {

int h = dht.readHumidity();

String temp = "Humidity: ";

temp += int(h);

temp += " %";

bot.sendMessage(chat_id,temp, "");

}

if (text == "/start") {

String welcome = "Welcome  " + from_name + ".\n";

welcome += "/temperature : Temperature reading\n";

welcome += "/humidity : Humiditiy reading\n";

bot.sendMessage(chat_id, welcome, "Markdown");

}

}

}

void setup() {

Serial.begin(115200);

dht.begin();

// This is the simplest way of getting this working

// if you are passing sensitive information, or controlling

// something important, please either use certStore or at

// least client.setFingerPrint

client.setInsecure();

// Set WiFi to station mode and disconnect from an AP if it was Previously

// connected

WiFi.mode(WIFI_STA);

WiFi.disconnect();

delay(100);

// attempt to connect to Wifi network:

Serial.print("Connecting Wifi: ");

Serial.println(ssid);

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

Serial.print(".");

delay(500);

}

Serial.println("");

Serial.println("WiFi connected");

Serial.print("IP address: ");

Serial.println(WiFi.localIP());

}

void loop() {

int t = dht.readTemperature();

int h = dht.readHumidity();

if (millis() > lastTimeBotRan + botRequestDelay)  {

int numNewMessages = bot.getUpdates(bot.last_message_received + 1);

while(numNewMessages) {

Serial.println("got response");

handleNewMessages(numNewMessages);

numNewMessages = bot.getUpdates(bot.last_message_received + 1);

}

lastTimeBotRan = millis();

}

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

#include <ESP8266WiFi.h>

#include <WiFiClientSecure.h>

#include <UniversalTelegramBot.h>

#include "DHT.h"

#define DHTPIN D1

#define DHTTYPE DHT11 // DHT 11

DHT dht(DHTPIN, DHTTYPE);

// Initialize Wifi connection to the router

char ssid[] = "AndroidAP3DEC"; // Wifi Name

char password[] = "123456"; // Wifi Password

// Initialize Telegram BOT

#define BOTtoken "5046061617:AAGM5mOCbPLZ4j92BwCSexfyzQIgyvAWmL8" // Bot token from telegram app

WiFiClientSecure client;

UniversalTelegramBot bot(BOTtoken, client);

//Checks for new messages every 1 second.

int botRequestDelay = 1000;

unsigned long lastTimeBotRan;

void handleNewMessages(int numNewMessages) {

Serial.println("handleNewMessages");

Serial.println(String(numNewMessages));

for (int i=0; i<numNewMessages; i++) {

String chat_id = String(bot.messages[i].chat_id);

String text = bot.messages[i].text;

String from_name = bot.messages[i].from_name;

if (from_name == "") from_name = "Guest";

if (text == "/temperature") {

int t = dht.readTemperature();

String temp = "Temperature : ";

temp += int(t);

temp +=" *C\n";

bot.sendMessage(chat_id,temp, "");

}

if (text == "/humidity") {

int h = dht.readHumidity();

String temp = "Humidity: ";

temp += int(h);

temp += " %";

bot.sendMessage(chat_id,temp, "");

}

if (text == "/start") {

String welcome = "Welcome " + from_name + ".\n";

welcome += "/temperature : Temperature reading\n";

welcome += "/humidity : Humiditiy reading\n";

bot.sendMessage(chat_id, welcome, "Markdown");

}

void setup() {

Serial.begin(115200);

dht.begin();

// This is the simplest way of getting this working

// if you are passing sensitive information, or controlling

// something important, please either use certStore or at

// least client.setFingerPrint

client.setInsecure();

// Set WiFi to station mode and disconnect from an AP if it was Previously

// connected

WiFi.mode(WIFI_STA);

WiFi.disconnect();

delay(100);

// attempt to connect to Wifi network:

Serial.print("Connecting Wifi: ");

Serial.println(ssid);

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

Serial.print(".");

delay(500);

}

Serial.println("");

Serial.println("WiFi connected");

Serial.print("IP address: ");

Serial.println(WiFi.localIP());

}

void loop() {

int t = dht.readTemperature();

int h = dht.readHumidity();

if (millis() > lastTimeBotRan + botRequestDelay) {

int numNewMessages = bot.getUpdates(bot.last_message_received + 1);

while(numNewMessages) {

Serial.println("got response");

handleNewMessages(numNewMessages);

numNewMessages = bot.getUpdates(bot.last_message_received + 1);

}

lastTimeBotRan = millis();

}

for complete tutorial read this article.

Practical Example 4: interfacing DHT11 with Raspberry Pi Pico W

Circuit diagram:

DHT11 with Raspberry Pi Pico W Program:

dht library

Ensure that the dht library is installed on your Raspberry Pi Pico W. To do this, simply create a new file in your IDE, paste the following dht library code into it, and save the file with the name ‘dht.py’.

import array
import micropython
import utime
from machine import Pin
from micropython import const
 
class InvalidChecksum(Exception):
    pass
 
class InvalidPulseCount(Exception):
    pass
 
MAX_UNCHANGED = const(100)
MIN_INTERVAL_US = const(200000)
HIGH_LEVEL = const(50)
EXPECTED_PULSES = const(84)
 
class DHT11:
    _temperature: float
    _humidity: float
 
    def __init__(self, pin):
        self._pin = pin
        self._last_measure = utime.ticks_us()
        self._temperature = -1
        self._humidity = -1
 
    def measure(self):
        current_ticks = utime.ticks_us()
        if utime.ticks_diff(current_ticks, self._last_measure) < MIN_INTERVAL_US and (
            self._temperature > -1 or self._humidity > -1
        ):
            # Less than a second since last read, which is too soon according
            # to the datasheet
            return
 
        self._send_init_signal()
        pulses = self._capture_pulses()
        buffer = self._convert_pulses_to_buffer(pulses)
        self._verify_checksum(buffer)
 
        self._humidity = buffer[0] + buffer[1] / 10
        self._temperature = buffer[2] + buffer[3] / 10
        self._last_measure = utime.ticks_us()
 
    @property
    def humidity(self):
        self.measure()
        return self._humidity
 
    @property
    def temperature(self):
        self.measure()
        return self._temperature
 
    def _send_init_signal(self):
        self._pin.init(Pin.OUT, Pin.PULL_DOWN)
        self._pin.value(1)
        utime.sleep_ms(50)
        self._pin.value(0)
        utime.sleep_ms(18)
 
    @micropython.native
    def _capture_pulses(self):
        pin = self._pin
        pin.init(Pin.IN, Pin.PULL_UP)
 
        val = 1
        idx = 0
        transitions = bytearray(EXPECTED_PULSES)
        unchanged = 0
        timestamp = utime.ticks_us()
 
        while unchanged < MAX_UNCHANGED:
            if val != pin.value():
                if idx >= EXPECTED_PULSES:
                    raise InvalidPulseCount(
                        "Got more than {} pulses".format(EXPECTED_PULSES)
                    )
                now = utime.ticks_us()
                transitions[idx] = now - timestamp
                timestamp = now
                idx += 1
 
                val = 1 - val
                unchanged = 0
            else:
                unchanged += 1
        pin.init(Pin.OUT, Pin.PULL_DOWN)
        if idx != EXPECTED_PULSES:
            raise InvalidPulseCount(
                "Expected {} but got {} pulses".format(EXPECTED_PULSES, idx)
            )
        return transitions[4:]
 
    def _convert_pulses_to_buffer(self, pulses):
        """Convert a list of 80 pulses into a 5 byte buffer
        The resulting 5 bytes in the buffer will be:
            0: Integral relative humidity data
            1: Decimal relative humidity data
            2: Integral temperature data
            3: Decimal temperature data
            4: Checksum
        """
        # Convert the pulses to 40 bits
        binary = 0
        for idx in range(0, len(pulses), 2):
            binary = binary << 1 | int(pulses[idx] > HIGH_LEVEL)
 
        # Split into 5 bytes
        buffer = array.array("B")
        for shift in range(4, -1, -1):
            buffer.append(binary >> shift * 8 & 0xFF)
        return buffer
 
    def _verify_checksum(self, buffer):
        # Calculate checksum
        checksum = 0
        for buf in buffer[0:4]:
            checksum += buf
        if checksum & 0xFF != buffer[4]:
            raise InvalidChecksum()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

import array

import micropython

import utime

from machine import Pin

from micropython import const

class InvalidChecksum(Exception):

pass

class InvalidPulseCount(Exception):

pass

MAX_UNCHANGED = const(100)

MIN_INTERVAL_US = const(200000)

HIGH_LEVEL = const(50)

EXPECTED_PULSES = const(84)

class DHT11:

_temperature: float

_humidity: float

def __init__(self, pin):

self._pin = pin

self._last_measure = utime.ticks_us()

self._temperature = -1

self._humidity = -1

def measure(self):

current_ticks = utime.ticks_us()

if utime.ticks_diff(current_ticks, self._last_measure) < MIN_INTERVAL_US and (

self._temperature > -1 or self._humidity > -1

# Less than a second since last read, which is too soon according

# to the datasheet

return

self._send_init_signal()

pulses = self._capture_pulses()

buffer = self._convert_pulses_to_buffer(pulses)

self._verify_checksum(buffer)

self._humidity = buffer[0] + buffer[1] / 10

self._temperature = buffer[2] + buffer[3] / 10

self._last_measure = utime.ticks_us()

@property

def humidity(self):

self.measure()

return self._humidity

@property

def temperature(self):

self.measure()

return self._temperature

def _send_init_signal(self):

self._pin.init(Pin.OUT, Pin.PULL_DOWN)

self._pin.value(1)

utime.sleep_ms(50)

self._pin.value(0)

utime.sleep_ms(18)

@micropython.native

def _capture_pulses(self):

pin = self._pin

pin.init(Pin.IN, Pin.PULL_UP)

val = 1

idx = 0

transitions = bytearray(EXPECTED_PULSES)

unchanged = 0

timestamp = utime.ticks_us()

while unchanged < MAX_UNCHANGED:

if val != pin.value():

if idx >= EXPECTED_PULSES:

raise InvalidPulseCount(

"Got more than {} pulses".format(EXPECTED_PULSES)

)

now = utime.ticks_us()

transitions[idx] = now - timestamp

timestamp = now

idx += 1

val = 1 - val

unchanged = 0

else:

unchanged += 1

pin.init(Pin.OUT, Pin.PULL_DOWN)

if idx != EXPECTED_PULSES:

raise InvalidPulseCount(

"Expected {} but got {} pulses".format(EXPECTED_PULSES, idx)

)

return transitions[4:]

def _convert_pulses_to_buffer(self, pulses):

"""Convert a list of 80 pulses into a 5 byte buffer

The resulting 5 bytes in the buffer will be:

0: Integral relative humidity data

1: Decimal relative humidity data

2: Integral temperature data

3: Decimal temperature data

4: Checksum

"""

# Convert the pulses to 40 bits

binary = 0

for idx in range(0, len(pulses), 2):

binary = binary << 1 | int(pulses[idx] > HIGH_LEVEL)

# Split into 5 bytes

buffer = array.array("B")

for shift in range(4, -1, -1):

buffer.append(binary >> shift * 8 & 0xFF)

return buffer

def _verify_checksum(self, buffer):

# Calculate checksum

checksum = 0

for buf in buffer[0:4]:

checksum += buf

if checksum & 0xFF != buffer[4]:

raise InvalidChecksum()

Main DHT11 Sensor Program:

from machine import Pin
import dht
import time

# DHT11 sensor setup
sensor_pin = Pin(16, Pin.IN, Pin.PULL_UP)
dht_sensor = dht.DHT11(sensor_pin)

# Web server loop
while True:
    try:
        # Read sensor
        dht_sensor.measure()
        temp = dht_sensor.temperature  # Access as property, not method
        hum = dht_sensor.humidity      # Access as property, not method
        
        # Print the values if the sensor is working
        print("Temperature:", temp, "°C")
        print("Humidity:", hum, "%")

    except Exception as e:
        # Print an error message if there's an issue with the sensor
        print("Failed to read from the sensor:", str(e))

    # Delay before the next read
    time.sleep(2)

from machine import Pin

import dht

import time

# DHT11 sensor setup

sensor_pin = Pin(16, Pin.IN, Pin.PULL_UP)

dht_sensor = dht.DHT11(sensor_pin)

# Web server loop

while True:

try:

# Read sensor

dht_sensor.measure()

temp = dht_sensor.temperature # Access as property, not method

hum = dht_sensor.humidity # Access as property, not method

# Print the values if the sensor is working

print("Temperature:", temp, "°C")

print("Humidity:", hum, "%")

except Exception as e:

# Print an error message if there's an issue with the sensor

print("Failed to read from the sensor:", str(e))

# Delay before the next read

time.sleep(2)

for complete tutorial read this article.

Conclusion: Making an informed decision for optimal performance

Choosing the right DHT sensor is crucial for accurate temperature and humidity measurements in your projects. By understanding the differences between the various DHT sensor types, you can make an informed decision that aligns with your specific requirements.

The DHT11, DHT22, DHT12, and DHT21 sensors each offer unique features and specifications that cater to different project needs. Consider factors such as accuracy, temperature and humidity range, power consumption, communication protocols, and form factor when selecting a DHT sensor.

Whether you’re a hobbyist or a professional engineer, the right DHT sensor can elevate your projects to new heights. With the knowledge gained from this article, you can confidently choose the perfect sensor for your temperature and humidity monitoring needs. So go ahead, make the right choice, and achieve optimal performance in your projects.

Fawad February 13, 2024

0 10 9 minutes read