DHT11 with ESP8266 and MicroPython: A Comprehensive Guide

The combination of the DHT11 sensor, ESP8266 microcontroller, and MicroPython programming language offers a powerful and accessible solution for environmental monitoring projects. The DHT11 is a popular low-cost sensor that can measure temperature and humidity, while the ESP8266 is a Wi-Fi enabled microcontroller known for its affordability and ease of use. MicroPython, on the other hand, is a lightweight implementation of the Python programming language designed for microcontrollers, which allows developers to write code quickly and efficiently. In this blog post, we will explore the fundamental concepts of using the DHT11 sensor with the ESP8266 using MicroPython. We will cover the basics of the components, how to set up the hardware and software, common practices for reading sensor data, and best practices for optimizing your projects.

Table of Contents#

  1. Fundamental Concepts
  2. Hardware Setup
  3. Software Setup
  4. Usage Methods
  5. Common Practices
  6. Best Practices
  7. Conclusion
  8. References

Fundamental Concepts#

DHT11 Sensor#

The DHT11 is a digital temperature and humidity sensor that uses a capacitive humidity sensor and a thermistor to measure the surrounding environment. It has a single-wire digital interface, which means it can communicate with a microcontroller using only one data line. The sensor provides relatively low accuracy compared to more expensive sensors, but it is sufficient for many basic applications.

ESP8266 Microcontroller#

The ESP8266 is a low-cost Wi-Fi microcontroller with built-in TCP/IP protocol stack. It can be used as a standalone device or as an add-on to another microcontroller to provide Wi-Fi connectivity. The ESP8266 has a powerful processor and enough memory to run MicroPython, making it a popular choice for Internet of Things (IoT) projects.

MicroPython#

MicroPython is a lean and efficient implementation of the Python 3 programming language that includes a small subset of the Python standard library and is optimized to run on microcontrollers. It allows developers to write code in a high-level language, which is easier to learn and write compared to traditional low-level languages like C or assembly.

Hardware Setup#

To use the DHT11 sensor with the ESP8266, you will need the following components:

  • ESP8266 development board (e.g., NodeMCU)
  • DHT11 sensor
  • Breadboard and jumper wires

The wiring connection is as follows:

  • Connect the VCC pin of the DHT11 to the 3.3V pin on the ESP8266.
  • Connect the GND pin of the DHT11 to the GND pin on the ESP8266.
  • Connect the data pin of the DHT11 to one of the GPIO pins on the ESP8266 (e.g., D2).

Software Setup#

  1. Install MicroPython on the ESP8266: You can use the esptool.py utility to flash the MicroPython firmware onto the ESP8266. Follow the official MicroPython documentation for detailed instructions.
  2. Connect to the ESP8266: You can use a serial terminal program (e.g., PuTTY or screen) to connect to the ESP8266 over USB. Once connected, you should see the MicroPython REPL (Read-Eval-Print Loop).
  3. Upload the DHT11 Library: MicroPython does not have a built-in DHT11 library, but you can use a third-party library. You can copy the DHT11 library code directly to the ESP8266 using a file transfer tool like ampy or rshell.

Here is an example of a simple DHT11 library code:

import machine
import time
 
class DHT11:
    def __init__(self, pin):
        self.pin = machine.Pin(pin, machine.Pin.IN, machine.Pin.PULL_UP)
 
    def read(self):
        # Send start signal
        self.pin.init(machine.Pin.OUT)
        self.pin.value(0)
        time.sleep_ms(18)
        self.pin.value(1)
        time.sleep_us(40)
        self.pin.init(machine.Pin.IN, machine.Pin.PULL_UP)
 
        # Wait for response
        while self.pin.value() == 1:
            pass
        while self.pin.value() == 0:
            pass
        while self.pin.value() == 1:
            pass
 
        # Read data
        data = []
        for i in range(40):
            while self.pin.value() == 0:
                pass
            pulse_start = time.ticks_us()
            while self.pin.value() == 1:
                pass
            pulse_end = time.ticks_us()
            pulse_duration = pulse_end - pulse_start
            if pulse_duration > 50:
                data.append(1)
            else:
                data.append(0)
 
        # Convert data to bytes
        humidity_integer = int(''.join(map(str, data[0:8])), 2)
        humidity_decimal = int(''.join(map(str, data[8:16])), 2)
        temperature_integer = int(''.join(map(str, data[16:24])), 2)
        temperature_decimal = int(''.join(map(str, data[24:32])), 2)
        checksum = int(''.join(map(str, data[32:40])), 2)
 
        # Calculate checksum
        calculated_checksum = (humidity_integer + humidity_decimal + temperature_integer + temperature_decimal) & 0xFF
 
        if checksum == calculated_checksum:
            return (humidity_integer, temperature_integer)
        else:
            return None

Usage Methods#

Reading Temperature and Humidity Data#

Here is an example code to read temperature and humidity data from the DHT11 sensor using the above library:

from machine import Pin
import time
from dht11 import DHT11
 
# Initialize the DHT11 sensor
dht = DHT11(Pin(4))  # Assuming the DHT11 data pin is connected to GPIO4
 
while True:
    result = dht.read()
    if result:
        humidity, temperature = result
        print(f"Temperature: {temperature}°C, Humidity: {humidity}%")
    else:
        print("Error reading data from DHT11")
    time.sleep(2)

Common Practices#

Error Handling#

The DHT11 sensor can sometimes return invalid data due to electrical interference or other issues. It is important to implement error handling in your code to ensure that your program does not crash when invalid data is received. In the above example, we check if the checksum is valid before printing the temperature and humidity data.

Periodic Data Reading#

In many applications, you may want to read the temperature and humidity data at regular intervals. You can use the time.sleep() function to control the interval between readings. In the example code, we read the data every 2 seconds.

Best Practices#

Power Management#

The ESP8266 and DHT11 sensor consume power, and in battery-powered applications, it is important to optimize power consumption. You can put the ESP8266 into deep sleep mode between readings to reduce power consumption. Here is an example code to put the ESP8266 into deep sleep mode:

import machine
import time
from dht11 import DHT11
 
# Initialize the DHT11 sensor
dht = DHT11(machine.Pin(4))
 
result = dht.read()
if result:
    humidity, temperature = result
    print(f"Temperature: {temperature}°C, Humidity: {humidity}%")
else:
    print("Error reading data from DHT11")
 
# Put the ESP8266 into deep sleep mode for 60 seconds
machine.deepsleep(60000)

Data Logging and Transmission#

If you want to store the sensor data or send it to a remote server, you can use a cloud service like ThingSpeak or Adafruit IO. These services provide APIs that allow you to send data over the Internet. Here is an example code to send data to ThingSpeak:

import machine
import time
import urequests
from dht11 import DHT11
 
# Initialize the DHT11 sensor
dht = DHT11(machine.Pin(4))
 
# ThingSpeak API key
api_key = "YOUR_API_KEY"
 
while True:
    result = dht.read()
    if result:
        humidity, temperature = result
        url = f"https://api.thingspeak.com/update?api_key={api_key}&field1={temperature}&field2={humidity}"
        try:
            response = urequests.get(url)
            response.close()
            print("Data sent to ThingSpeak")
        except Exception as e:
            print(f"Error sending data to ThingSpeak: {e}")
    else:
        print("Error reading data from DHT11")
    time.sleep(60)

Conclusion#

In this blog post, we have explored how to use the DHT11 sensor with the ESP8266 using MicroPython. We have covered the fundamental concepts of the components, the hardware and software setup, common practices for reading sensor data, and best practices for optimizing your projects. By following these guidelines, you can build your own environmental monitoring projects quickly and easily.

References#

2025-10