DS18B20 Dallas Temperature Sensor

// Requires the official Espressif 1-Wire and DS18B20 drivers from the ESP Component Registry:
//   idf.py add-dependency "espressif/ds18b20^0.4.0"
//   idf.py add-dependency "espressif/onewire_bus^1.1.1"

#include <stdio.h>
#include <string.h>
#include "esp_log.h"
#include "esp_err.h"
#include "ds18b20.h"
#include "onewire_bus.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#define ONE_WIRE_GPIO    4   // Change this to your preferred GPIO pin
#define MAX_DS18B20      2   // Maximum number of DS18B20 sensors
#define DS18B20_CONVERSION_DELAY_MS 750  // Default conversion delay for 12-bit resolution

static const char *TAG = "DS18B20";

void app_main(void) {
    // Install the 1-Wire bus
    onewire_bus_handle_t bus = NULL;
    onewire_bus_config_t bus_config = {
        .bus_gpio_num = ONE_WIRE_GPIO,
    };

    onewire_bus_rmt_config_t rmt_config = {
        .max_rx_bytes = 10, // 1-byte ROM command + 8 bytes ROM number + 1 byte device command
    };

    ESP_ERROR_CHECK(onewire_new_bus_rmt(&bus_config, &rmt_config, &bus));

    int ds18b20_device_num = 0;
    ds18b20_device_handle_t ds18b20s[MAX_DS18B20];
    onewire_device_iter_handle_t iter = NULL;
    onewire_device_t next_onewire_device;
    esp_err_t search_result = ESP_OK;

    // Create 1-Wire device iterator to search for sensors
    ESP_ERROR_CHECK(onewire_new_device_iter(bus, &iter));
    ESP_LOGI(TAG, "Device iterator created, start searching...");

    do {
        search_result = onewire_device_iter_get_next(iter, &next_onewire_device);
        if (search_result == ESP_OK) {
            ds18b20_config_t ds_cfg = {};  // Initialize DS18B20 config

            // Check if the device is a DS18B20 sensor
            if (ds18b20_new_device_from_enumeration(&next_onewire_device, &ds_cfg, &ds18b20s[ds18b20_device_num]) == ESP_OK) {
                ESP_LOGI(TAG, "Found DS18B20[%d], address: %016llX", ds18b20_device_num, next_onewire_device.address);
                ds18b20_device_num++;
            } else {
                ESP_LOGW(TAG, "Found unknown device, address: %016llX", next_onewire_device.address);
            }
        }
    } while (search_result != ESP_ERR_NOT_FOUND);

    ESP_ERROR_CHECK(onewire_del_device_iter(iter));
    ESP_LOGI(TAG, "Searching done, %d DS18B20 device(s) found", ds18b20_device_num);

    // Read and print temperature from each detected DS18B20 sensor
    while (1) {
        for (int i = 0; i < ds18b20_device_num; i++) {
            float temperature = 0.0;
            if (ds18b20_trigger_temperature_conversion(ds18b20s[i]) == ESP_OK) {
                vTaskDelay(pdMS_TO_TICKS(DS18B20_CONVERSION_DELAY_MS));  // Wait for conversion
                if (ds18b20_get_temperature(ds18b20s[i], &temperature) == ESP_OK) {
                    ESP_LOGI(TAG, "DS18B20[%d] Temperature: %.2f°C", i, temperature);
                } else {
                    ESP_LOGE(TAG, "Failed to get temperature from DS18B20[%d]", i);
                }
            } else {
                ESP_LOGE(TAG, "Failed to trigger temperature conversion for DS18B20[%d]", i);
            }
        }
        vTaskDelay(pdMS_TO_TICKS(2000));  // Wait 2 seconds before the next reading
    }
}

one_wire:
  - platform: gpio
    pin: GPIO4

sensor:
  - platform: dallas_temp
    # With multiple sensors on the bus, add their address (logged at boot)
    name: "DS18B20 Temperature"
    update_interval: 60s

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

#include <Arduino.h>
#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);
}

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