¡Descubre cómo controlar múltiples sensores de temperatura con ESP32 DS18B20 y Arduino IDE y crear un servidor web para monitorearlos en tiempo real!

En este artículo, exploraremos cómo utilizar un sensor de temperatura DS18B20 con el módulo ESP32 y programarlo utilizando Arduino IDE. Desde la configuración de un único sensor hasta la implementación de múltiples sensores y la creación de un servidor web para visualizar los datos, descubriremos paso a paso cómo llevar a cabo este proyecto emocionante y práctico. ¡Acompáñanos en esta aventura de innovación tecnológica!

Esta es una guía detallada para el sensor de temperatura DS18B20 con ESP32 usando Arduino IDE. Le mostraremos cómo conectar el sensor, instalar las bibliotecas necesarias y escribir el código para recuperar los valores del sensor de uno o más sensores. Finalmente, creamos un servidor web simple para mostrar los valores del sensor.

Sensor de temperatura ESP32 DS18B20 con Arduino IDE (único, múltiple, servidor web)

Quizás también quieras leer otras guías de DS18B20:

Sensor de temperatura ESP8266 DS18B20 con Arduino IDE
Sensor de temperatura ESP32/ESP8266 DS18B20 con MicroPython
ESP32 con múltiples sensores de temperatura DS18B20
Sensor de temperatura DS18B20 con Arduino

Contenido

Presentamos el sensor de temperatura DS18B20

El Sensor de temperatura DS18B20 Es un sensor de temperatura digital de un solo cable. Esto significa que solo necesita una línea de datos (y GND) para comunicarse con su ESP32.

La energía se puede suministrar a través de una fuente de alimentación externa o a través de la línea de datos (el llamado «modo parásito»), eliminando la necesidad de una fuente de alimentación externa.

Cada sensor de temperatura DS18B20 tiene un código de serie único de 64 bits. Esto le permite conectar varios sensores al mismo cable de datos. Esto le permite obtener la temperatura de múltiples sensores con un solo GPIO.

El sensor de temperatura DS18B20 también está disponible en diseño impermeable.

A continuación se muestra un resumen de las especificaciones clave del sensor de temperatura DS18B20:

Se comunica a través de comunicación de bus de un solo cable
Rango de fuente de alimentación: 3,0 V a 5,5 V
Rango de temperatura de funcionamiento: -55ºC a +125ºC
Precisión +/-0,5ºC (rango -10ºC a 85ºC)

Se puede encontrar más información en el Hoja de datos DS18B20.

Piezas requeridas

Para seguir este tutorial necesitarás los siguientes elementos:

ESP32 (leer Las mejores placas de desarrollo ESP32)
Sensor de temperatura DS18B20 (uno o más sensores) – diseño impermeable
Resistencia de 4,7k ohmios
Cables de puente
tablero de circuitos

Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!

Diagrama de cableado – ESP32

Como se mencionó anteriormente, el sensor de temperatura DS18B20 se puede alimentar a través del pin VDD (modo normal) o puede obtener su energía de la línea de datos (Modo parásito). Puedes elegir entre ambos modos.

Si está utilizando un ESP32, siga uno de estos dos esquemas.

Modo parásito

Modo normal

Preparando tu IDE de Arduino

Programaremos el ESP32 usando Arduino IDE. Por lo tanto, asegúrese de tener instalado el complemento ESP32 antes de continuar:

Instale la placa ESP32 en Arduino IDE (Instrucciones para Windows, Mac OS X y Linux)

Instalación de bibliotecas

Para conectarse al sensor de temperatura DS18B20, debe Biblioteca One Wire de Paul Stoffregen y eso Biblioteca de temperatura de DallasSiga los siguientes pasos para instalar estas bibliotecas.

1. Abra su IDE de Arduino y vaya a Bosquejo > incluir biblioteca > Administrar bibliotecas. El administrador de la biblioteca debería abrirse.

2. Ingrese «un solo cable”en el campo de búsqueda e instale la biblioteca OneWire de Paul Stoffregen.

3. Luego busque «dallas”e instale la biblioteca DallasTemperature de Miles Burton.

Después de instalar las bibliotecas, reinicie su IDE de Arduino.

Código (Único DS18B20)

Después de instalar las bibliotecas requeridas, puede cargar el código en ESP32. El siguiente código lee la temperatura del sensor de temperatura DS18B20 y muestra las lecturas en el monitor serie del Arduino IDE.

/*********
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com  
*********/

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

// GPIO where the DS18B20 is connected to
const int oneWireBus = 4;     

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

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

void setup() {
  // Start the Serial Monitor
  Serial.begin(115200);
  // Start the DS18B20 sensor
  sensors.begin();
}

void loop() {
  sensors.requestTemperatures(); 
  float temperatureC = sensors.getTempCByIndex(0);
  float temperatureF = sensors.getTempFByIndex(0);
  Serial.print(temperatureC);
  Serial.println("ºC");
  Serial.print(temperatureF);
  Serial.println("ºF");
  delay(5000);
}

Ver código sin formato

Hay muchas formas diferentes de determinar la temperatura a partir de sensores de temperatura DS18B20. Sin embargo, si solo utiliza un sensor, esta es una de las opciones más fáciles y sencillas.

Cómo funciona el código

Comience por incluir el Un cable y eso Dallastemperatura Bibliotecas.

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

Cree las instancias necesarias para el sensor de temperatura. El sensor de temperatura está conectado a GPIO4.

// GPIO where the DS18B20 is connected to
const int oneWireBus = 4;

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

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

En el configuración()Inicialice el monitor serie con una velocidad de baudios de 115200.

Serial.begin(115200);

Inicialice el sensor de temperatura DS18B20:

sensors.begin();

Antes de poder medir la temperatura, debe Solicitar temperaturas() Método.

sensors.requestTemperatures();

Luego obtienes la temperatura en Celsius con eso. obtenerTempCByIndex() Método como se muestra a continuación:

float temperatureC = sensors.getTempCByIndex(0);

O usa eso obtenerTempFByIndex() para obtener la temperatura en Fahrenheit.

float temperatureF = sensors.getTempFByIndex(0);

El obtenerTempCByIndex() y eso obtenerTempFByIndex() Los métodos aceptan el índice del sensor de temperatura. Como solo usamos un sensor, su índice es 0. Si desea leer más de un sensor, use el índice 0 para un sensor, el índice 1 para el otro sensor, y así sucesivamente.

Finalmente, imprima los resultados en el monitor serie.

Serial.print(temperatureC);
Serial.println("ºC");
Serial.print(temperatureF);
Serial.println("ºF");

Se solicitan nuevos valores de temperatura cada 5 segundos.

delay(5000);

demostración

Después de cargar el código, las lecturas de su sensor deberían aparecer en el monitor de serie:

Recuperar temperatura de múltiples sensores de temperatura DS18B20

El sensor de temperatura DS18B20 se comunica a través de un protocolo de un solo cable y cada sensor tiene un código de serie único de 64 bits, lo que le permite leer la temperatura de múltiples sensores con un solo GPIO. Todo lo que necesita hacer es conectar todas las líneas de datos como se muestra en el siguiente diagrama de circuito:

Código (múltiples DS18B20)

Luego cargue el siguiente código. Busca todos los dispositivos. GPIO4 e imprime la temperatura de cada uno. (Este boceto se basa en un ejemplo de la biblioteca DallasTemperature).

/*********
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com  
*********/

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

// Data wire is plugged TO GPIO 4
#define ONE_WIRE_BUS 4

// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);

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

// Number of temperature devices found
int numberOfDevices;

// We'll use this variable to store a found device address
DeviceAddress tempDeviceAddress; 

void setup(){
  // start serial port
  Serial.begin(115200);
  
  // Start up the library
  sensors.begin();
  
  // Grab a count of devices on the wire
  numberOfDevices = sensors.getDeviceCount();
  
  // locate devices on the bus
  Serial.print("Locating devices...");
  Serial.print("Found ");
  Serial.print(numberOfDevices, DEC);
  Serial.println(" devices.");

  // Loop through each device, print out address
  for(int i=0;i<numberOfDevices; i++){
    // Search the wire for address
    if(sensors.getAddress(tempDeviceAddress, i)){
      Serial.print("Found device ");
      Serial.print(i, DEC);
      Serial.print(" with address: ");
      printAddress(tempDeviceAddress);
      Serial.println();
    } else {
      Serial.print("Found ghost device at ");
      Serial.print(i, DEC);
      Serial.print(" but could not detect address. Check power and cabling");
    }
  }
}

void loop(){ 
  sensors.requestTemperatures(); // Send the command to get temperatures
  
  // Loop through each device, print out temperature data
  for(int i=0;i<numberOfDevices; i++){
    // Search the wire for address
    if(sensors.getAddress(tempDeviceAddress, i)){
      // Output the device ID
      Serial.print("Temperature for device: ");
      Serial.println(i,DEC);
      // Print the data
      float tempC = sensors.getTempC(tempDeviceAddress);
      Serial.print("Temp C: ");
      Serial.print(tempC);
      Serial.print(" Temp F: ");
      Serial.println(DallasTemperature::toFahrenheit(tempC)); // Converts tempC to Fahrenheit
    }
  }
  delay(5000);
}

// function to print a device address
void printAddress(DeviceAddress deviceAddress) {
  for (uint8_t i = 0; i < 8; i++){
    if (deviceAddress[i] < 16) Serial.print("0");
      Serial.print(deviceAddress[i], HEX);
  }
}

Ver código sin formato

demostración

En este ejemplo utilizamos tres sensores de temperatura DS18B20. Esto es lo que obtenemos en el monitor serie Arduino IDE.

Tenemos un artículo dedicado a cómo conectar múltiples sensores de temperatura DS18B20 al EPS32. Simplemente sigue el siguiente tutorial:

ESP32 con múltiples sensores de temperatura DS18B20

Visualización de valores de temperatura DS18B20 en un servidor web

Usamos para construir el servidor web. Biblioteca ESPAsyncWebServer Esto proporciona una manera sencilla de crear un servidor web asincrónico. Crear un servidor web asíncrono tiene varias ventajas. Recomendamos echar un vistazo rápido a la documentación de la biblioteca. página de GitHub.

Instalación de las bibliotecas ESPAsyncWebServer y AsyncTCP

Debe instalar las siguientes bibliotecas en su IDE de Arduino para crear el servidor web para este proyecto.

ESPAsyncWebServer (.Carpeta zip)
AsíncronoTCP (.Carpeta zip)

Las bibliotecas ESPAsyncWebServer, AsynTCP y ESPAsyncTCP no se pueden instalar a través de Arduino Library Manager. Por lo tanto, debe copiar los archivos de la biblioteca a la carpeta de instalación de Arduino Bibliotecas. Alternativamente, puedes hacerlo en tu IDE de Arduino. Bosquejo > incluir biblioteca > Agregar biblioteca .zip y seleccione las bibliotecas que acaba de descargar.

Código (servidor web asíncrono DS18B20)

Abra su IDE de Arduino y copie el siguiente código.

/*********
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com  
*********/

// Import required libraries
#ifdef ESP32
  #include <WiFi.h>
  #include <ESPAsyncWebServer.h>
#else
  #include <Arduino.h>
  #include <ESP8266WiFi.h>
  #include <Hash.h>
  #include <ESPAsyncTCP.h>
  #include <ESPAsyncWebServer.h>
#endif
#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is connected to GPIO 4
#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 
DallasTemperature sensors(&oneWire);

// Variables to store temperature values
String temperatureF = "";
String temperatureC = "";

// Timer variables
unsigned long lastTime = 0;  
unsigned long timerDelay = 30000;

// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Create AsyncWebServer object on port 80
AsyncWebServer server(80);

String readDSTemperatureC() {
  // Call sensors.requestTemperatures() to issue a global temperature and Requests to all devices on the bus
  sensors.requestTemperatures(); 
  float tempC = sensors.getTempCByIndex(0);

  if(tempC == -127.00) {
    Serial.println("Failed to read from DS18B20 sensor");
    return "--";
  } else {
    Serial.print("Temperature Celsius: ");
    Serial.println(tempC); 
  }
  return String(tempC);
}

String readDSTemperatureF() {
  // Call sensors.requestTemperatures() to issue a global temperature and Requests to all devices on the bus
  sensors.requestTemperatures(); 
  float tempF = sensors.getTempFByIndex(0);

  if(int(tempF) == -196){
    Serial.println("Failed to read from DS18B20 sensor");
    return "--";
  } else {
    Serial.print("Temperature Fahrenheit: ");
    Serial.println(tempF);
  }
  return String(tempF);
}

const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE HTML><html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.7.2/css/all.css" integrity="sha384-fnmOCqbTlWIlj8LyTjo7mOUStjsKC4pOpQbqyi7RrhN7udi9RwhKkMHpvLbHG9Sr" crossorigin="anonymous">
  <style>
    html {
     font-family: Arial;
     display: inline-block;
     margin: 0px auto;
     text-align: center;
    }
    h2 { font-size: 3.0rem; }
    p { font-size: 3.0rem; }
    .units { font-size: 1.2rem; }
    .ds-labels{
      font-size: 1.5rem;
      vertical-align:middle;
      padding-bottom: 15px;
    }
  </style>
</head>
<body>
  <h2>ESP DS18B20 Server</h2>
  <p>
    <i class="fas fa-thermometer-half" style="color:#059e8a;"></i> 
    <span class="ds-labels">Temperature Celsius</span> 
    <span id="temperaturec">%TEMPERATUREC%</span>
    <sup class="units">&deg;C</sup>
  </p>
  <p>
    <i class="fas fa-thermometer-half" style="color:#059e8a;"></i> 
    <span class="ds-labels">Temperature Fahrenheit</span>
    <span id="temperaturef">%TEMPERATUREF%</span>
    <sup class="units">&deg;F</sup>
  </p>
</body>
<script>
setInterval(function ( ) {
  var xhttp = new XMLHttpRequest();
  xhttp.onreadystatechange = function() {
    if (this.readyState == 4 && this.status == 200) {
      document.getElementById("temperaturec").innerHTML = this.responseText;
    }
  };
  xhttp.open("GET", "/temperaturec", true);
  xhttp.send();
}, 10000) ;
setInterval(function ( ) {
  var xhttp = new XMLHttpRequest();
  xhttp.onreadystatechange = function() {
    if (this.readyState == 4 && this.status == 200) {
      document.getElementById("temperaturef").innerHTML = this.responseText;
    }
  };
  xhttp.open("GET", "/temperaturef", true);
  xhttp.send();
}, 10000) ;
</script>
</html>)rawliteral";

// Replaces placeholder with DS18B20 values
String processor(const String& var){
  //Serial.println(var);
  if(var == "TEMPERATUREC"){
    return temperatureC;
  }
  else if(var == "TEMPERATUREF"){
    return temperatureF;
  }
  return String();
}

void setup(){
  // Serial port for debugging purposes
  Serial.begin(115200);
  Serial.println();
  
  // Start up the DS18B20 library
  sensors.begin();

  temperatureC = readDSTemperatureC();
  temperatureF = readDSTemperatureF();

  // Connect to Wi-Fi
  WiFi.begin(ssid, password);
  Serial.println("Connecting to WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  
  // Print ESP Local IP Address
  Serial.println(WiFi.localIP());

  // Route for root / web page
  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/html", index_html, processor);
  });
  server.on("/temperaturec", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/plain", temperatureC.c_str());
  });
  server.on("/temperaturef", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/plain", temperatureF.c_str());
  });
  // Start server
  server.begin();
}
 
void loop(){
  if ((millis() - lastTime) > timerDelay) {
    temperatureC = readDSTemperatureC();
    temperatureF = readDSTemperatureF();
    lastTime = millis();
  }  
}

Ver código sin formato

Ingrese sus credenciales de red en las siguientes variables y el código funcionará inmediatamente.

const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

Cómo funciona el código

En las siguientes secciones explicamos cómo funciona el código. Continúe leyendo si desea obtener más información o pase a la sección de demostración para ver el resultado final.

Importando bibliotecas

Primero importe las bibliotecas necesarias para la placa ESP32:

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

Crear una instancia del sensor DS18B20

Defina el GPIO al que está conectado el pin de datos DS18B20. En este caso está conectado a GPIO4.

#define ONE_WIRE_BUS 4

Cree una instancia de las instancias necesarias para inicializar el sensor:

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

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

Configuración de sus credenciales de red

Ingrese sus credenciales de red en las siguientes variables para que el ESP8266 pueda conectarse a su red local.

const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

Crea uno Servidor web asíncrono Objeto en el puerto 80.

AsyncWebServer server(80);

Leer funciones de temperatura

Luego creamos dos funciones para leer la temperatura.

El leerDSTemperaturaC() La función devuelve las medidas en grados Celsius.

String readDSTemperatureC() {
  // Call sensors.requestTemperatures() to issue a global temperature and Requests to all devices on the bus
  sensors.requestTemperatures(); 
  float tempC = sensors.getTempCByIndex(0);

  if(tempC == -127.00){
    Serial.println("Failed to read from DS18B20 sensor");
    return "--";
  } else {
    Serial.print("Temperature Celsius: ");
    Serial.println(tempC); 
  }
  return String(tempC);
}

Si el sensor no recibe una lectura válida, devuelve -127. Entonces tenemos una declaración if que devuelve dos guiones (–) si el sensor no obtiene ninguna lectura.

if(tempC == -127.00){
  Serial.println("Failed to read from DS18B20 sensor");
  return "--";

El leerTemperaturaF() La función funciona de manera similar, pero devuelve las lecturas en grados Fahrenheit.

Las medidas se devuelven como una cadena. Para convertir un flotante en una cadena, use el cadena() Función.

return String(tempC);

Creando el sitio web

El siguiente paso es crear el sitio web. Los archivos HTML y CSS necesarios para crear el sitio web se encuentran en el índice_html Variable.

En el texto HTML tenemos TEMPERATURAC Y TEMPERATURA F entre % Firmar. Este es un marcador de posición para los valores de temperatura.

Eso significa que estos %TEMPERATURAC% El texto es como una variable que se reemplaza con el valor de temperatura real del sensor. Los marcadores de posición en el texto HTML deben estar entre % Firmar.

Explicamos en detalle cómo funciona el HTML y CSS utilizados en este servidor web en un tutorial anterior. Entonces, si quieres aprender más, lee el siguiente proyecto:

Servidor web de temperatura y humedad DHT11/DHT22 con Arduino IDE

procesador

Ahora tenemos que Procesador() Función que reemplaza los marcadores de posición de nuestro texto HTML por los valores de temperatura reales.

String processor(const String& var){
  //Serial.println(var);
  if(var == "TEMPERATUREC"){
    return readDSTemperatureC();
  }
  else if(var == "TEMPERATUREF"){
    return readDSTemperatureF();
  }
  return String();
}

Al acceder al sitio web, comprobamos si el HTML contiene marcadores de posición. Si es el %TEMPERATURAC% Comodín, devolvemos la temperatura en Celsius usando el leerDSTemperaturaC() función creada previamente.

if(var == "TEMPERATUREC"){
  return readDSTemperatureC();
}

Si el marcador de posición %TEMPERATURAF%volvamos la temperatura en Fahrenheit.

else if(var == "TEMPERATUREF"){
  return readDSTemperatureF();
}

configuración()

En el configuración()inicialice el monitor serie para fines de depuración.

Serial.begin(115200);

Inicialice el sensor de temperatura DS18B20.

sensors.begin();

Conéctese a su red local e imprima la dirección IP de ESP32.

WiFi.begin(ssid, password);
Serial.println("Connecting to WiFi");
while (WiFi.status() != WL_CONNECTED) {
  delay(500);
  Serial.print(".");
}
Serial.println();

// Print ESP8266 Local IP Address
Serial.println(WiFi.localIP());

Finalmente, agregue las siguientes líneas de código para administrar el servidor web.

server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
  request->send_P(200, "text/html", index_html, processor);
});
server.on("/temperaturec", HTTP_GET, [](AsyncWebServerRequest *request){
  request->send_P(200, "text/plain", readDSTemperatureC().c_str());
});
server.on("/temperaturef", HTTP_GET, [](AsyncWebServerRequest *request){
  request->send_P(200, "text/plain", readDSTemperatureF().c_str());
});

Cuando hacemos una solicitud a la URL raíz, enviamos el texto HTML que está en el índice_html Variable. Tenemos que hacer eso también procesador Función que reemplaza todos los marcadores de posición con los valores correctos.

server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
  request->send_P(200, "text/html", index_html, processor);
});

Necesitamos agregar dos controladores adicionales para actualizar los valores de temperatura. Cuando recibimos una solicitud en el /Temperaturac URL simplemente necesitamos enviar el valor de temperatura actualizado. Es texto sin formato y debe enviarse como un carácter, así que lo usaremos cadena_c() Método.

server.on("/temperaturec", HTTP_GET, [](AsyncWebServerRequest *request){
  request->send_P(200, "text/plain", readDSTemperatureC().c_str());
});

Se repite el mismo proceso para la temperatura en Fahrenheit.

server.on("/temperaturef", HTTP_GET, [](AsyncWebServerRequest *request){
  request->send_P(200, "text/plain", readDSTemperatureF().c_str());
});

Finalmente podemos iniciar el servidor.

server.begin();

Dado que es un servidor web asíncrono, no tenemos que ponerle nada. Cinta().

void loop(){

}

En términos generales, así es como funciona el código.

demostración

Después de cargar el código, abra el monitor serie Arduino IDE con una velocidad de baudios de 115200. Presione el botón RST incorporado del ESP32 y después de unos segundos debería aparecer su dirección IP.

Abra un navegador en su red local e ingrese la dirección IP ESP32.

Ahora puedes ver la temperatura en grados Celsius y Fahrenheit en tu servidor web. Los valores de los sensores se actualizan automáticamente sin que tengas que actualizar el sitio web.

Envolver

Esperamos que este tutorial te haya resultado útil. Tenemos guías para otros sensores y módulos que utilizan el ESP32 que podrían interesarle:

ESP32 con BME280 (presión, temperatura y humedad)
Sensor de efecto Hall incorporado en ESP32
Pantalla OLED ESP32 con Arduino IDE
Sensor de temperatura y humedad ESP32 DHT con Arduino IDE

Si desea obtener más información sobre ESP32, consulte nuestro curso o consulte nuestros recursos gratuitos de ESP32:

Aprenda ESP32 con Arduino IDE
Más proyectos y tutoriales de ESP32

Gracias por leer.

Error 403 The request cannot be completed because you have exceeded your quota. : quotaExceeded

Sensor de temperatura ESP32 DS18B20 con Arduino IDE (único, múltiple, servidor web)

Este es una guía detallada para el sensor de temperatura DS18B20 con ESP32 utilizando Arduino IDE. Te mostraremos cómo cablear el sensor, instalar las bibliotecas necesarias y escribir el código para obtener las lecturas del sensor desde uno y múltiples sensores. Finalmente, construiremos un servidor web sencillo para mostrar las lecturas del sensor.

Introducción al sensor de temperatura DS18B20

El sensor de temperatura DS18B20 es un sensor digital de temperatura de un solo cable. Esto significa que solo requiere una línea de datos (y GND) para comunicarse con tu ESP32.

Puede ser alimentado por una fuente de alimentación externa o puede derivar energía de la línea de datos (llamado «modo parásito»), lo que elimina la necesidad de una fuente de alimentación externa.

Cada sensor de temperatura DS18B20 tiene un código de serie único de 64 bits. Esto te permite cablear múltiples sensores a la misma línea de datos. Así que, puedes obtener la temperatura de múltiples sensores utilizando solo un GPIO.

El sensor de temperatura DS18B20 también está disponible en una versión impermeable.

Partes Requeridas

Para seguir este tutorial necesitarás las siguientes partes:

ESP32
Sensor de temperatura DS18B20 (uno o varios sensores) – versión impermeable
Resistor de 4.7k Ohm
Cables jumper
Protoboard

Puedes encontrar todas las partes para tus proyectos al mejor precio en MakerAdvisor.com/tools.

Esquemático – ESP32

Como se mencionó anteriormente, el sensor de temperatura DS18B20 puede ser alimentado a través del pin VDD (modo normal) o puede derivar su energía de la línea de datos (modo parásito). Puedes elegir entre estos dos diagramas esquemáticos.

Preparación de tu Arduino IDE

Programaremos el ESP32 utilizando Arduino IDE, así que asegúrate de tener el complemento ESP32 instalado antes de continuar.

Instalación de Bibliotecas

Para interactuar con el sensor de temperatura DS18B20, necesitas instalar la biblioteca OneWire de Paul Stoffregen y la biblioteca Dallas Temperature. Sigue los siguientes pasos para instalar esas bibliotecas.

Abre tu Arduino IDE y ve a Sketch > Include Library > Manage Libraries. El Administrador de Bibliotecas debería abrirse.
Escribe «onewire» en el cuadro de búsqueda e instala la biblioteca OneWire de Paul Stoffregen.
Luego, busca «Dallas» e instala la biblioteca DallasTemperature de Miles Burton.

Después de instalar las bibliotecas, reinicia tu Arduino IDE.

…

Este es solo una parte del contenido inspirador que puedes complementar y expandir en tu artículo. Asegúrate de cubrir todos los detalles importantes y proporcionar información valiosa a tus lectores. ¡Buena suerte!

3 comentarios en «Sensor de temperatura ESP32 DS18B20 con Arduino IDE (único, múltiple, servidor web)»

krojilkip

17 de octubre de 2022 a las 19:37

Interesante artículo, me encantaría probar a hacer mi propio sensor de temperatura con el ESP32 DS18B20. ¡Gracias por compartir!
Accede para responder
Capacciniag

7 de enero de 2023 a las 01:57

Me gustó mucho el tutorial, está súper claro y fácil de seguir. Definitivamente lo intentaré en casa. ¡Gracias por la info!
Accede para responder
patronalpu

15 de marzo de 2024 a las 13:53

Genial, justo lo que estaba buscando para empezar a jugar con mi ESP32! Gracias por el tutorial, se entiende muy bien. ¡A probar se ha dicho! 🤓
Accede para responder

Deja un comentario Cancelar la respuesta

Lo siento, debes estar conectado para publicar un comentario.

Presentamos el sensor de temperatura DS18B20

Piezas requeridas

Diagrama de cableado – ESP32

Modo parásito

Modo normal

Preparando tu IDE de Arduino

Instalación de bibliotecas

Código (Único DS18B20)

Cómo funciona el código

demostración

Recuperar temperatura de múltiples sensores de temperatura DS18B20

Código (múltiples DS18B20)

demostración

Visualización de valores de temperatura DS18B20 en un servidor web

Instalación de las bibliotecas ESPAsyncWebServer y AsyncTCP

Código (servidor web asíncrono DS18B20)

Cómo funciona el código

Importando bibliotecas

Crear una instancia del sensor DS18B20

Configuración de sus credenciales de red

Leer funciones de temperatura

Creando el sitio web

procesador

configuración()

demostración

Envolver

Sensor de temperatura ESP32 DS18B20 con Arduino IDE (único, múltiple, servidor web)

Introducción al sensor de temperatura DS18B20

Partes Requeridas

Esquemático – ESP32

Preparación de tu Arduino IDE

Instalación de Bibliotecas

Related Posts:

3 comentarios en «Sensor de temperatura ESP32 DS18B20 con Arduino IDE (único, múltiple, servidor web)»

Deja un comentario Cancelar la respuesta