ESP32 DS18B20 Dallas Temperature Sensor

Code Examples

Below you can find code examples of DS18B20 Dallas Temperature Sensor with ESP32 in several frameworks:

• Arduino IDE
• ESP-IDF
• ESPHome
• PlatformIO
• MicroPython

If you encounter issues while using the DS18B20 Dallas Temperature Sensor, check the Common Issues Troubleshooting Guide.

ESP32 DS18B20 Arduino IDE Code Example

Example in Arduino IDE

Fill in your main Arduino IDE sketch file with the following code to use the DS18B20 Dallas Temperature Sensor:

#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is connected to GPIO4 (D2 on many boards)
#define ONE_WIRE_BUS 4

// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature sensor library
DallasTemperature sensors(&oneWire);

void setup() {
  Serial.begin(115200);
  Serial.println("DS18B20 Temperature Sensor");

  // Start the DS18B20 sensor
  sensors.begin();
}

void loop() {
  // Request temperature readings from the sensor
  sensors.requestTemperatures();
  
  // Fetch and print the temperature
  float temperatureC = sensors.getTempCByIndex(0);
  Serial.print("Temperature: ");
  Serial.print(temperatureC);
  Serial.println("°C");

  // Delay for 2 seconds before taking the next reading
  delay(2000);
}

#include and #include import the libraries required for 1-Wire communication and temperature sensor handling.

#define ONE_WIRE_BUS 4 specifies the GPIO pin connected to the data line of the DS18B20 sensor.

The setup() function initializes serial communication and the DS18B20 sensor using sensors.begin().

The loop() function requests temperature readings with sensors.requestTemperatures() and retrieves the value in Celsius using sensors.getTempCByIndex(0). The result is then printed to the serial monitor.

Connect your ESP32 to your computer via a USB cable, Ensure the correct Board and Port are selected under Tools, Click the "Upload" button in the Arduino IDE to compile and upload the code to your ESP32.

ESP32 DS18B20 ESP-IDF Code Example

Example in Espressif IoT Framework (ESP-IDF)

If you're using ESP-IDF to work with the DS18B20 Dallas Temperature Sensor, here's how you can set it up and read data from the sensor. Fill in this code in the main ESP-IDF file:

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "onewire.h"
#include "ds18b20.h"

// Define GPIO for the DS18B20 data line
#define DS18B20_GPIO GPIO_NUM_4

void app_main(void) {
    printf("DS18B20 Temperature Sensor with ESP-IDF
");

    // Initialize 1-Wire protocol
    onewire_bus_handle_t bus = onewire_bus_init(DS18B20_GPIO);

    if (bus == NULL) {
        printf("Failed to initialize 1-Wire bus
");
        return;
    }

    // Search for devices on the bus
    uint8_t rom_code[8];
    if (!onewire_search_first(bus, rom_code, false)) {
        printf("No DS18B20 sensors found on the bus
");
        onewire_bus_deinit(bus);
        return;
    }

    // Display the ROM code of the detected sensor
    printf("Found device with ROM: ");
    for (int i = 0; i < 8; i++) {
        printf("%02X ", rom_code[i]);
    }
    printf("
");

    // Initialize the DS18B20 sensor
    if (!ds18b20_init(bus, rom_code)) {
        printf("Failed to initialize DS18B20 sensor
");
        onewire_bus_deinit(bus);
        return;
    }

    while (1) {
        // Request temperature measurement
        if (ds18b20_start_conversion(bus, rom_code)) {
            // Wait for the conversion to complete
            vTaskDelay(pdMS_TO_TICKS(750));

            // Read the temperature
            float temperature;
            if (ds18b20_get_temperature(bus, rom_code, &temperature)) {
                printf("Temperature: %.2f°C
", temperature);
            } else {
                printf("Failed to read temperature
");
            }
        } else {
            printf("Failed to start temperature conversion
");
        }

        vTaskDelay(pdMS_TO_TICKS(2000)); // Delay 2 seconds
    }

    // Deinitialize the 1-Wire bus
    onewire_bus_deinit(bus);
}

• #include "onewire.h" and #include "ds18b20.h" import libraries for 1-Wire communication and sensor handling.
• #define DS18B20_GPIO GPIO_NUM_4 specifies the GPIO pin connected to the sensor's data line.
• In the app_main() function, the 1-Wire bus is initialized with onewire_bus_init().
• The code searches for a DS18B20 device, initializes it, and continuously reads temperature values using ds18b20_get_temperature().
• The temperature is printed to the serial monitor using printf().

Update the I2C pins (I2C_MASTER_SDA_IO and I2C_MASTER_SCL_IO) to match your ESP32 hardware setup, Use idf.py build to compile the project, Use idf.py flash to upload the code to your ESP32.

ESP32 DS18B20 ESPHome Code Example

Example in ESPHome (Home Assistant)

Fill in this configuration in your ESPHome YAML configuration file (example.yml) to integrate the DS18B20 Dallas Temperature Sensor

sensor: 
  - platform: dallas_temp
    address: 0x1234567812345628
    name: temperature
    update_interval: 120s

The code defines a JSON property sensor_config containing a stringified object. It includes a sensor array with attributes like platform (sensor type), address (hardware ID), name (sensor label), and update_interval (update frequency).

Upload this code to your ESP32 using the ESPHome dashboard or the esphome run command.

ESP32 DS18B20 PlatformIO Code Example

Example in PlatformIO Framework

For PlatformIO, make sure to configure the platformio.ini file with the appropriate environment and libraries, and then proceed with the code.

Configure platformio.ini

First, your platformio.ini should look like below. You might need to include some libraries as shown. Make sure to change the board to your ESP32:

[env:esp32]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps =
    paulstoffregen/OneWire @ ^2.3.7
    milesburton/DallasTemperature @ ^3.11.0

ESP32 DS18B20 PlatformIO Example Code

Write this code in your PlatformIO project under the src/main.cpp file to use the DS18B20 Dallas Temperature Sensor:

#include <Arduino.h>
#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is connected to GPIO4
#define ONE_WIRE_BUS 4

// Create a oneWire instance to communicate with any OneWire devices
OneWire oneWire(ONE_WIRE_BUS);

// Pass the oneWire reference to Dallas Temperature
DallasTemperature sensors(&oneWire);

void setup() {
    Serial.begin(115200);
    Serial.println("DS18B20 Temperature Sensor with PlatformIO");

    // Start the DS18B20 sensor
    sensors.begin();
}

void loop() {
    // Request temperature measurement
    sensors.requestTemperatures();

    // Get temperature in Celsius
    float temperatureC = sensors.getTempCByIndex(0);

    // Print the temperature to the serial monitor
    Serial.print("Temperature: ");
    Serial.print(temperatureC);
    Serial.println("°C");

    // Delay for 2 seconds before the next reading
    delay(2000);
}

• #include and #include import the required libraries for 1-Wire communication and DS18B20 sensor handling.
• #define ONE_WIRE_BUS 4 sets the GPIO pin connected to the DS18B20 data pin.
• The setup() function initializes serial communication and the DS18B20 sensor with sensors.begin().
• In the loop() function, sensors.requestTemperatures() requests a temperature measurement.
• sensors.getTempCByIndex(0) retrieves the temperature in Celsius, which is printed to the serial monitor using Serial.print().

Upload the code to your ESP32 using the PlatformIO "Upload" button in your IDE or the pio run --target upload command.

ESP32 DS18B20 MicroPython Code Example

Example in Micro Python Framework

Fill in this script in your MicroPython main.py file (main.py) to integrate the DS18B20 Dallas Temperature Sensor with your ESP32.

import machine
import onewire
import ds18x20
import time

# Define the GPIO pin where the DS18B20 data line is connected
ds_pin = machine.Pin(4)

# Create a OneWire object
ow = onewire.OneWire(ds_pin)

# Create a DS18X20 object
ds = ds18x20.DS18X20(ow)

# Scan for DS18B20 devices on the bus
roms = ds.scan()
print("Found DS18B20 devices:", roms)

while True:
    # Request temperature conversion
    ds.convert_temp()
    time.sleep(1)  # Wait for the conversion to complete

    # Read temperature from each device
    for rom in roms:
        temp = ds.read_temp(rom)
        print("Temperature:", temp, "°C")

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

• import machine, import onewire, and import ds18x20 are used to handle GPIO pins, 1-Wire protocol, and DS18B20 sensor operations respectively.
• ds_pin = machine.Pin(4) sets GPIO4 as the pin connected to the DS18B20 data line.
• The OneWire and DS18X20 objects are initialized to communicate with the sensor.
• ds.scan() searches for DS18B20 sensors connected to the bus and returns their ROM addresses.
• Inside a loop, ds.convert_temp() starts a temperature measurement, and ds.read_temp(rom) reads the temperature from each sensor.
• The temperature readings are printed to the console with print().

Upload this code to your ESP32 using a MicroPython-compatible IDE, such as Thonny, uPyCraft, or tools like ampy.