¡Descubre cómo controlar múltiples sensores de temperatura DS18B20 con ESP8266 y Arduino IDE! Además, aprenderás a crear un servidor web para monitorear los datos en tiempo real. ¡No te lo pierdas!

Los sensores de temperatura son una herramienta fundamental en numerosos proyectos de electrónica y domótica. En este artículo, te mostraremos cómo utilizar el sensor de temperatura DS18B20 junto con el módulo ESP8266 y el Arduino IDE para crear un sistema único, múltiple e incluso un servidor web. ¡Sigue leyendo para descubrir cómo llevar tus proyectos al siguiente nivel con esta poderosa combinación de dispositivos!

Esta es una guía detallada para el sensor de temperatura DS18B20 con ESP8266 usando Arduino IDE. Cubrimos el cableado del sensor, la instalación de las bibliotecas necesarias y la escritura del código para obtener las lecturas del sensor de uno o más sensores. Finalmente, creamos un servidor web simple para mostrar los valores del sensor.

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

En este tutorial cubriremos los siguientes temas:

Lea la temperatura de un sensor de temperatura DS18B20;
Lea la temperatura de múltiples sensores de temperatura DS18B20;
Muestre las lecturas del sensor DS18B20 en un servidor web.

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

Sensor de temperatura ESP32 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

Conoce más sobre el ESP8266 en nuestro curso: Domótica con ESP8266.

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 se requiere una línea de datos (y GND) para comunicarse con su ESP8266.

Puede ser alimentado por una fuente de alimentación externa o puede obtener energía 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 versión impermeable.

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

Se comunica a través de un 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)

Para más información, ver Hoja de datos DS18B20.

Piezas requeridas

Para completar este tutorial necesitará los siguientes componentes:

ESP8266 – leer Las mejores placas de desarrollo Wi-Fi ESP8266
Sensor de temperatura DS18B20 (uno o más sensores) – diseño impermeable
Resistencia de 4,7 kOhmios
tablero de circuitos
Cables de puente

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

ESP8266 con DS18B20 Diagrama esquemático

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.

Modo parásito

Modo normal

Nota: En este tutorial conectaremos la línea de datos DS18B20 a GPIO4Pero también puedes utilizar cualquier otro GPIO adecuado.

Lea nuestra Guía de referencia de ESP8266 GPIO para obtener más información sobre los ESP8266 GPIO.

Nota: si usas uno ESP-01GPIO 2 es el pin más adecuado para conectarse al pin de datos DS18B20.

Preparando tu IDE de Arduino

Programamos el ESP8266 con el IDE de Arduino. Por lo tanto, asegúrese de tener instalado el complemento ESP8266 antes de continuar:

Instale la placa ESP8266 en el IDE de Arduino (Instrucciones para Windows, Mac OS X y Linux).

Instalación de bibliotecas para DS18B20

Para conectarse al sensor de temperatura DS18B20, debe instalarlo Biblioteca One Wire de Paul Stoffregen y eso Biblioteca de temperatura de Dallas. Siga 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 Dallas Temperature 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 siguiente código en ESP8266. El 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 formas más sencillas 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 encuentra la temperatura en grados Celsius usando 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 usamos solo 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 otros sensores, etc.

Finalmente, imprima los resultados en el Serial Monitor.

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, abra el monitor serie Arduino IDE con una velocidad de baudios de 115200. La temperatura debe mostrarse tanto en grados Celsius como en Fahrenheit:

Recuperar temperatura de múltiples sensores de temperatura DS18B20

El sensor de temperatura DS18B20 se comunica mediante 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 pin digital.

Esquemático

Para leer la temperatura de varios sensores, todo lo que necesita hacer es conectar todas las líneas de datos como se muestra en el siguiente diagrama de cableado:

Código (múltiples DS18B20)

Luego cargue el siguiente código. Busca todos los dispositivos que están encendidos. GPIO4 e imprime la temperatura de cada uno. Este boceto se basa en el 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

Así es como funciona el código

El código utiliza varios métodos útiles para manejar múltiples sensores DS18B20.

ellos usan el getDeviceCount() Método para determinar la cantidad de sensores DS18B20 en la línea de datos.

numberOfDevices = sensors.getDeviceCount();

El obtener dirección() El método encuentra las direcciones del sensor:

if(sensors.getAddress(tempDeviceAddress, i)){

La dirección es única para cada sensor. Esto significa que cada sensor puede identificarse por su dirección.

Entonces usa eso obtenerTempC() Método que acepta la dirección del dispositivo como argumento. Puede utilizar este método para encontrar la temperatura de un sensor específico:

float tempC = sensors.getTempC(tempDeviceAddress);

Para obtener la temperatura en grados Fahrenheit puedes usar el obtenerTemF(). Alternativamente, puedes convertir la temperatura en Celsius a Fahrenheit de la siguiente manera:

DallasTemperature::toFahrenheit(tempC)

demostración

Después de cargar el código, abra su monitor serial con una velocidad de baudios de 115200. Todos los valores del sensor deberían aparecer como se muestra a continuación:

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 la biblioteca ESPAsyncWebServer

La biblioteca ESPAsyncWebServer no se puede instalar en el administrador de bibliotecas Arduino IDE. Por lo tanto, debes instalarlos manualmente.

Siga los siguientes pasos para instalar la biblioteca ESPAsyncWebServer:

Haga clic aquí para descargar la biblioteca ESPAsyncWebServer. Deberías tener una carpeta .zip en tu carpeta de Descargas.
Descomprima la carpeta ZIP y debería obtener lo siguiente Maestro ESPAsyncWebServer Carpeta
Cambie el nombre de su carpeta de ~~Maestro ESPAsyncWebServer~~ A ESPAsyncWebServer
mueve eso ESPAsyncWebServer Carpeta a la carpeta de bibliotecas de instalación de Arduino IDE

Instalación de la biblioteca ESPAsync TCP

La biblioteca ESPAsyncWebServer requiere la ESPAsyncTCP Biblioteca para trabajar. Siga los siguientes pasos para instalar esta biblioteca:

Haga clic aquí para descargar la biblioteca ESPAsyncTCP. Deberías tener una carpeta .zip en tu carpeta de Descargas.
Descomprima la carpeta ZIP y debería obtener lo siguiente Maestro ESPAsyncTCP Carpeta
Cambia el nombre de tu carpeta ~~Maestro ESPAsyncTCP~~ A ESPAsyncTCP
mueve eso ESPAsyncTCP Carpeta a la carpeta de bibliotecas de instalación de Arduino IDE
Finalmente, vuelva a abrir su IDE de Arduino

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.

Importar bibliotecas

Primero importe las bibliotecas necesarias.

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <Hash.h>
#include <ESPAsyncTCP.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(D1).

#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);

Cree variables que almacenen la temperatura y la humedad como valores de cadena:

String temperatureF = "";
String temperatureC = "";

Recibimos nuevos valores de sensores cada 30 segundos. Puedes cambiar eso en el Retraso del temporizador Variable.

unsigned long lastTime = 0;  
unsigned long timerDelay = 30000;

Configuración de sus credenciales de red

Ingrese sus credenciales de red en las siguientes variables para permitir que el ESP8266 se conecte a su red local.

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

Cree un objeto AsyncWebServer 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 los valores medidos 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 un tipo de cadena. Para convertir un flotante en una cadena, use el cadena() Función.

return String(tempC);

Creando el sitio web

El siguiente paso es construir el sitio web. El código HTML y CSS necesario para crear la página web se almacena 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 esto %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 desea obtener más información, consulte el siguiente proyecto:

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

procesador

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

// 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();
}

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 temperatureC;
}

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

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

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();

Obtenga los valores de temperatura actuales:

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

Conéctese a su red local e imprima la dirección IP del ESP8266.

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", temperatureC.c_str());
});
server.on("/temperaturef", HTTP_GET, [](AsyncWebServerRequest *request){
  request->send_P(200, "text/plain", temperatureF.c_str());
});

Cuando realizamos una solicitud a la URL raíz, enviamos el texto HTML almacenado en ella. índice_html Variable. Tenemos que pasar esto 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 las lecturas de temperatura. Cuando recibimos una solicitud en /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", temperatureC.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", temperatureF.c_str());
});

Finalmente podemos iniciar el servidor.

server.begin();

En el Cinta()actualizar los valores de temperatura cada 30 segundos (Retraso del temporizador Variable).

void loop(){
  if ((millis() - lastTime) > timerDelay) {
    temperatureC = readDSTemperatureC();
    temperatureF = readDSTemperatureF();
    lastTime = millis();
  }  
}

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

demostración

Después de cargar el código, abra el Arduino IDE Serial Monitor con una velocidad de baudios de 115200. 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 del ESP8266.

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

Resumen

Esta fue una guía detallada sobre cómo usar el sensor de temperatura DS18B20 con el ESP8266 y mostrar las lecturas en un servidor web.

El DS18B20 se comunica mediante un protocolo de un solo cable y cada sensor tiene un código de serie único de 64 bits, lo que significa que puede leer muchos sensores a través del mismo pin de datos.

Esperamos que este tutorial te haya resultado útil. Tenemos más tutoriales usando el ESP8266 que te pueden gustar:

ESP8266 con BME280 usando Arduino IDE (Presión, Temperatura, Humedad)
ESP8266: Valores de temperatura y humedad DHT en la pantalla OLED
Pantalla OLED ESP8266 de 0,96 pulgadas con Arduino IDE
ESP8266 DHT11/DHT22 Servidor Web de Temperatura y Humedad con Arduino IDE

Obtenga más información sobre el ESP8266 con Domótica con ESP8266 (eBook + vídeo curso).

Gracias por leer.

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

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

Esta es una guía detallada para el sensor de temperatura DS18B20 con ESP8266 utilizando Arduino IDE. Cubriremos cómo cablear el sensor, instalar las bibliotecas necesarias y escribir el código para obtener las lecturas del sensor de uno y varios sensores. Finalmente, construiremos un servidor web simple para mostrar las lecturas del sensor.

Índice:

Leer la temperatura de un sensor de temperatura DS18B20
Leer la temperatura de varios sensores de temperatura DS18B20
Mostrar las lecturas del sensor DS18B20 en un servidor web

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 su ESP8266. 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 le permite cablear varios sensores en la misma línea de datos. Entonces, puede obtener la temperatura de varios sensores utilizando solo un GPIO. El sensor de temperatura DS18B20 también está disponible en versión impermeable.

La biblioteca ESPAsyncWebServer no está disponible para instalar en el Administrador de bibliotecas de Arduino IDE. Por lo tanto, debe instalarla manualmente. Siga los siguientes pasos para instalar la biblioteca ESPAsyncWebServer:

Descargue la biblioteca ESPAsyncWebServer
Descomprima la carpeta descargada y renómbrala a ESPAsyncWebServer
Mueva la carpeta ESPAsyncWebServer a la carpeta de bibliotecas de su instalación de Arduino IDE

El código para leer la temperatura de un solo DS18B20 es el siguiente:

Inserte aquí el código para leer la temperatura de un solo DS18B20 con ESP8266 y Arduino IDE

Preguntas frecuentes

¿Cómo se obtiene la temperatura de varios sensores en un solo pin digital?
¿Es posible alimentar el sensor DS18B20 en modo parásito?
¿Qué bibliotecas son necesarias para trabajar con el sensor DS18B20 en ESP8266?
¿Cómo se puede mostrar la temperatura de los sensores en un servidor web?

Siga explorando otros tutoriales relacionados con el DS18B20:

ul>

ESP32 Sensor de Temperatura DS18B20 con Arduino IDE

ESP32/ESP8266 Sensor de Temperatura DS18B20 con MicroPython

ESP32 con Múltiples Sensores de Temperatura DS18B20

Sensor de Temperatura DS18B20 con Arduino

Para obtener más información, consulte la hoja de datos de DS18B20.

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

vestaffibiapa

24 de agosto de 2022 a las 18:37

¡Muy buena guía! Me parece súper útil la información sobre cómo utilizar el sensor de temperatura ESP8266 DS18B20 con Arduino IDE. ¡Gracias por compartir!
Accede para responder
plazabolivarsv

30 de enero de 2023 a las 05:58

¡Buena explicación! Me resultó fácil de seguir y entender. ¡Gracias por compartir!
Accede para responder
dreesvh

27 de septiembre de 2023 a las 13:19

¡Qué completo y detallado! Me parece genial la manera en que explican el uso y funcionamiento del sensor de temperatura ESP8266 DS18B20 con Arduino IDE. ¡Muy informativo! ¡Gracias por compartir!
Accede para responder
rodolfovarelawl

1 de enero de 2024 a las 01:46

¡Excelente tutorial! Me encantó la forma en que explicaron paso a paso cómo utilizar el sensor de temperatura ESP8266 DS18B20 con Arduino IDE. ¡Gracias por compartir este proyecto tan útil!
Accede para responder
zwakheidwq

30 de enero de 2024 a las 17:10

¡Interesante proyecto! Me encantaría probarlo en casa.
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

ESP8266 con DS18B20 Diagrama esquemático

Modo parásito

Modo normal

Preparando tu IDE de Arduino

Instalación de bibliotecas para DS18B20

Código (Único DS18B20)

Cómo funciona el código

demostración

Recuperar temperatura de múltiples sensores de temperatura DS18B20

Esquemático

Código (múltiples DS18B20)

Así es como funciona el código

demostración

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

Instalación de la biblioteca ESPAsyncWebServer

Instalación de la biblioteca ESPAsync TCP

Código (servidor web asíncrono DS18B20)

Cómo funciona el código

Importar 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

Resumen

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

Índice:

Preguntas frecuentes

Related Posts:

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

Deja un comentario Cancelar la respuesta