ESP8266 DS18B20 Sensor Web Server Arduino IDE (Simple, Multiple)

ESP8266 DS18B20 Sensor Web Server Arduino IDE (Simple, Multiple)

Ceci est un guide détaillé pour le capteur de température DS18B20 avec ESP8266 utilisant Arduino IDE. Nous verrons comment câbler le capteur, installer les bibliothèques requises et écrire le code pour obtenir les lectures du capteur à partir d’un et de plusieurs capteurs. Enfin, nous allons créer un serveur Web simple pour afficher les lectures des capteurs.

ESP8266 avec capteur de température DS18B20 utilisant Arduino IDE

Tout au long de ce didacticiel, nous aborderons les sujets suivants :

  1. Lire la température d’un capteur de température DS18B20 ;
  2. Lire la température à partir de plusieurs capteurs de température DS18B20 ;
  3. Affichez les lectures du capteur DS18B20 sur un serveur Web.

Vous pourriez également aimer lire d’autres guides DS18B20 :

Apprenez-en plus sur l’ESP8266 avec notre cours : Domotique à l’aide de l’ESP8266.

Présentation du capteur de température DS18B20

Le Capteur de température DS18B20 est un capteur de température numérique à un fil. Cela signifie qu’il ne nécessite qu’une seule ligne de données (et GND) pour communiquer avec votre ESP8266.

Il peut être alimenté par une alimentation externe ou être alimenté par la ligne de données (appelé « mode parasite »), ce qui élimine le besoin d’une alimentation externe.

Broches de brochage du capteur de température DS18B20

Chaque capteur de température DS18B20 possède un code série unique de 64 bits. Cela vous permet de câbler plusieurs capteurs au même fil de données. Ainsi, vous pouvez obtenir la température de plusieurs capteurs en utilisant un seul GPIO.

Le capteur de température DS18B20 est également disponible en version étanche.

Capteur de température DS18B20 Version étanche

Voici un résumé des spécifications les plus pertinentes du capteur de température DS18B20 :

  • Communique sur un bus à un fil
  • Plage d’alimentation : 3,0 V à 5,5 V
  • Plage de température de fonctionnement : -55 ºC à +125 ºC
  • Précision +/-0,5 ºC (entre -10 ºC et 85 ºC)

Pour plus d’informations consultez le Fiche technique DS18B20.

Pièces requises

Pour terminer ce didacticiel, vous avez besoin des composants suivants :

Vous pouvez utiliser les liens précédents ou accéder directement à MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

ESP8266 DS18B20 Sensor Web Server Arduino IDE Simple Multiple

ESP8266 avec schéma de principe DS18B20

Comme mentionné précédemment, le capteur de température DS18B20 peut être alimenté via la broche VDD (mode normal), ou il peut tirer son alimentation de la ligne de données (mode parasite). Vous pouvez choisir l’un ou l’autre des modes.

Mode Parasite

Capteur de température DS18B20 avec schéma de câblage en mode parasite ESP8266

Mode normal

Capteur de température DS18B20 avec schéma de câblage en mode normal ESP8266

Remarque : dans ce didacticiel, nous connectons la ligne de données DS18B20 au GPIO 4, mais vous pouvez utiliser n’importe quel autre GPIO approprié.

Lisez notre guide de référence ESP8266 GPIO pour en savoir plus sur les GPIO ESP8266.

Remarque : si vous utilisez un ESP-01GPIO 2 est la broche la plus appropriée pour se connecter à la broche de données DS18B20.

Préparation de votre IDE Arduino

Nous allons programmer l’ESP8266 à l’aide de l’IDE Arduino, alors assurez-vous que le module complémentaire ESP8266 est installé avant de continuer :

Installation des bibliothèques pour DS18B20

Pour interfacer avec le capteur de température DS18B20, vous devez installer le Bibliothèque One Wire de Paul Stoffregen et le Bibliothèque de température de Dallas. Suivez les étapes suivantes pour installer ces bibliothèques.

1. Ouvrez votre IDE Arduino et accédez à Sketch > Inclure la bibliothèque > Gérer les bibliothèques. Le gestionnaire de bibliothèque devrait s’ouvrir.

2. Tapez « onewire » dans la zone de recherche et installez la bibliothèque OneWire de Paul Stoffregen.

Installer la bibliothèque OneWire de Paul Stoffregen dans l'IDE Arduino

3. Ensuite, recherchez « Dallas » et installez la bibliothèque Dallas Temperature de Miles Burton.

Installer la bibliothèque DallasTemperature de Miles Burton dans Arduino IDE

Après avoir installé les bibliothèques, redémarrez votre IDE Arduino.

Code (DS18B20 simple)

Après avoir installé les bibliothèques requises, vous pouvez télécharger le code suivant sur l’ESP8266. Le code lit la température du capteur de température DS18B20 et affiche les lectures sur le moniteur série Arduino IDE. 

/*********
  Rui Santos
  Complete project details at https://Raspberryme.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);
}

Afficher le code brut

Il existe de nombreuses façons d’obtenir la température des capteurs de température DS18B20. Cependant, si vous n’utilisez qu’un seul capteur, c’est l’un des moyens les plus faciles et les plus simples.

Capteur de température DS18B20 Single OneWire avec ESP32 et Arduino IDE sur Breadboard

Comment fonctionne le code

Commencez par inclure les bibliothèques OneWire et DallasTemperature.

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

Créez les instances nécessaires pour le capteur de température. Le capteur de température est connecté au GPIO 4. 

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

Dans setup(), initialisez le Serial Monitor à un débit en bauds de 115200.

Serial.begin(115200);

Initialisez le capteur de température DS18B20 :

sensors.begin();

Avant d’obtenir réellement la température, vous devez appeler la méthode requestTemperatures().

sensors.requestTemperatures();

Ensuite, obtenez la température en Celsius en utilisant la méthode getTempCByIndex() comme indiqué ci-dessous :

float temperatureC = sensors.getTempCByIndex(0);

Ou utilisez getTempFByIndex() pour obtenir la température en Fahrenheit.

float temperatureF = sensors.getTempFByIndex(0);

Les méthodes getTempCByIndex() et getTempFByIndex() acceptent l’index du capteur de température. Parce que nous n’utilisons qu’un seul capteur, son index est 0. Si vous voulez lire plus d’un capteur, vous utilisez l’index 0 pour un capteur, l’index 1 pour l’autre capteur et ainsi de suite.

Enfin, imprimez les résultats dans le moniteur série.

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

De nouvelles lectures de température sont demandées toutes les 5 secondes.

delay(5000);

Manifestation

Après avoir téléchargé le code, ouvrez le moniteur série Arduino IDE à un débit de 9600 bauds. Vous devriez obtenir la température affichée en degrés Celsius et Fahrenheit :

1680616334 9 ESP8266 DS18B20 Sensor Web Server Arduino IDE Simple Multiple

Obtention de la température à partir de plusieurs capteurs de température DS18B20

Capteurs de température multiples DS18B20 OneWire avec ESP32 et Arduino IDE

Le capteur de température DS18B20 communique à l’aide d’un protocole à un fil et chaque capteur possède un code série 64 bits unique, de sorte que vous pouvez lire la température de plusieurs capteurs à l’aide d’une seule broche numérique.

Schématique

Pour lire la température de plusieurs capteurs, il vous suffit de câbler toutes les lignes de données ensemble, comme indiqué dans le schéma suivant :

Capteurs de température multiples DS18B20 avec schéma de câblage ESP32

Code (plusieurs DS18B20)

Ensuite, téléchargez le code suivant. Il recherche tous les appareils sur GPIO 4 et imprime la température pour chacun. Cette esquisse est basée sur l’exemple fourni par la bibliothèque DallasTemperature.

/*********
  Rui Santos
  Complete project details at https://Raspberryme.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);
  }
}

Afficher le code brut

Comment fonctionne le code

Le code utilise plusieurs méthodes utiles pour gérer plusieurs capteurs DS18B20.

Vous utilisez la méthode getDeviceCount() pour obtenir le nombre de capteurs DS18B20 sur la ligne de données.

numberOfDevices = sensors.getDeviceCount();

La méthode getAddress() trouve les adresses des capteurs :

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

L’adresse est unique pour chaque capteur. Ainsi chaque capteur peut être identifié par son adresse.

Ensuite, vous utilisez la méthode getTempC() qui accepte en argument l’adresse du périphérique. Avec cette méthode, vous pouvez obtenir la température d’un capteur spécifique :

float tempC = sensors.getTempC(tempDeviceAddress);

Pour obtenir la température en degrés Fahrenheit, vous pouvez utiliser getTemF(). Alternativement, vous pouvez convertir la température en Celsius en Fahrenheit comme suit :

DallasTemperature::toFahrenheit(tempC)

Manifestation

Après avoir téléchargé le code, ouvrez votre moniteur série à un débit en bauds de 115200. Vous devriez obtenir toutes les lectures de vos capteurs affichées comme indiqué ci-dessous :

ESP8266 Plusieurs capteurs de température DS18B20 Moniteur série Lectures d'impression

Afficher les relevés de température DS18B20 sur un serveur Web

Pour construire le serveur Web, nous utiliserons le Bibliothèque ESPAsyncWebServer qui fournit un moyen simple de créer un serveur Web asynchrone. Construire un serveur Web asynchrone présente plusieurs avantages. Nous vous recommandons de jeter un coup d’œil rapide à la documentation de la bibliothèque sur son Page GitHub.

Installation de la librairie ESPAsyncWebServer

La bibliothèque ESPAsyncWebServer n’est pas disponible pour être installée dans le gestionnaire de bibliothèque IDE Arduino. Vous devez donc l’installer manuellement.

Suivez les étapes suivantes pour installer la bibliothèque ESPAsyncWebServer :

  1. Cliquez ici pour télécharger la librairie ESPAsyncWebServer. Vous devriez avoir un dossier .zip dans votre dossier Téléchargements
  2. Décompressez le dossier .zip et vous devriez obtenir le dossier ESPAsyncWebServer-master
  3. Renommez votre dossier de ESPAsyncWebServer-maître vers ESPAsyncWebServer
  4. Déplacez le dossier ESPAsyncWebServer vers le dossier des bibliothèques d’installation de votre IDE Arduino

Installation de la bibliothèque ESPAsync TCP

La librairie ESPAsyncWebServer nécessite le ESPAsyncTCP bibliothèque pour travailler. Suivez les étapes suivantes pour installer cette bibliothèque :

  1. Cliquez ici pour télécharger la librairie ESPAsyncTCP. Vous devriez avoir un dossier .zip dans votre dossier Téléchargements
  2. Décompressez le dossier .zip et vous devriez obtenir le dossier ESPAsyncTCP-master
  3. Renommez votre dossier de ESPAsyncTCP-maître vers ESPAsyncTCP
  4. Déplacez le dossier ESPAsyncTCP vers le dossier des bibliothèques d’installation de votre IDE Arduino
  5. Enfin, rouvrez votre IDE Arduino

Code (serveur Web asynchrone DS18B20)

Ouvrez votre IDE Arduino et copiez le code suivant.

/*********
  Rui Santos
  Complete project details at https://Raspberryme.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();
  }  
}

Afficher le code brut

Insérez vos informations d’identification réseau dans les variables suivantes et le code fonctionnera immédiatement.

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

Comment fonctionne le code

Dans les paragraphes suivants, nous expliquerons le fonctionnement du code. Continuez à lire si vous voulez en savoir plus ou passez à la section « Démonstration » pour voir le résultat final.

Importation de bibliothèques

Tout d’abord, importez les bibliothèques requises.

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <Hash.h>
#include <ESPAsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include <OneWire.h>
#include <DallasTemperature.h>

Instancier le capteur DS18B20

Définissez le GPIO auquel la broche de données DS18B20 est connectée. Dans ce cas, il est connecté au GPIO 4(D1).

#define ONE_WIRE_BUS 4

Instanciez les instances nécessaires pour initialiser le capteur :

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

Créez des variables qui contiendront la température et l’humidité sous forme de valeurs de chaîne :

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

Nous aurons de nouvelles lectures de capteur toutes les 30 secondes. Vous pouvez modifier cela dans la variable timerDelay.

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

Définition de vos identifiants réseau

Insérez vos informations d’identification réseau dans les variables suivantes, afin que l’ESP8266 puisse se connecter à votre réseau local.

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

Créez un objet AsyncWebServer sur le port 80.

AsyncWebServer server(80);

Lire les fonctions de température

Ensuite, nous créons deux fonctions pour lire la température.

La fonction readDSTemperatureC() renvoie les lectures en degrés 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 le capteur ne parvient pas à obtenir une lecture valide, il renvoie -127. Nous avons donc une instruction if qui renvoie deux tirets (–-) au cas où le capteur ne parviendrait pas à obtenir les lectures. 

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

La fonction readSTemperatureF() fonctionne de manière similaire mais renvoie les lectures en degrés Fahrenheit.

Les lectures sont renvoyées sous forme de chaîne. Pour convertir un flottant en chaîne, utilisez la fonction String().

return String(tempC);

Construire la page Web

L’étape suivante consiste à créer la page Web. Le HTML et le CSS nécessaires à la construction de la page Web sont enregistrés dans la variable index_html.

Dans le texte HTML, nous avons TEMPERATUREC et TEMPERATUREF entre les signes %. Il s’agit d’un espace réservé pour les valeurs de température.

Cela signifie que ce texte %TEMPERATUREC% est comme une variable qui sera remplacée par la valeur de température réelle du capteur. Les espaces réservés sur le texte HTML doivent être entre les signes %.

Nous avons expliqué en détail le fonctionnement du HTML et du CSS utilisés dans ce serveur Web dans un didacticiel précédent. Donc, si vous voulez en savoir plus, référez-vous au prochain projet :

Processeur

Maintenant, nous devons créer la fonction processor(), qui remplacera les espaces réservés dans notre texte HTML par les valeurs de température réelles.

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

Lorsque la page Web est demandée, nous vérifions si le code HTML contient des espaces réservés. S’il trouve l’espace réservé %TEMPERATUREC%, nous renvoyons la température en degrés Celsius en appelant la fonction readDSTemperatureC() créée précédemment.

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

Si l’espace réservé est %TEMPERATUREF%, nous renvoyons la température en Fahrenheit.

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

installation()

Dans setup(), initialisez le moniteur série à des fins de débogage.

Serial.begin(115200);

Initialiser le capteur de température DS18B20.

sensors.begin();

Obtenez les valeurs de température actuelles :

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

Connectez-vous à votre réseau local et imprimez l’adresse IP 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());

Enfin, ajoutez les lignes de code suivantes pour gérer le serveur 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());
});

Lorsque nous faisons une requête sur l’URL root, nous envoyons le texte HTML qui est stocké dans la variable index_html. Nous devons également passer la fonction de processeur, qui remplacera tous les espaces réservés par les bonnes valeurs.

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

Nous devons ajouter deux gestionnaires supplémentaires pour mettre à jour les relevés de température. Lorsque nous recevons une requête sur l’URL /temperaturec, nous devons simplement envoyer la valeur de température mise à jour. C’est du texte brut, et il doit être envoyé sous forme de caractère, nous utilisons donc la méthode c_str().

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

Le même processus est répété pour la température en Fahrenheit.

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

Enfin, nous pouvons démarrer le serveur.

server.begin();

Dans la boucle(), mettre à jour les valeurs de température toutes les 30 secondes (variable timerDelay).

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

C’est à peu près comme ça que le code fonctionne.

Manifestation

Après avoir téléchargé le code, ouvrez le moniteur série Arduino IDE à un débit en bauds de 115200. Après quelques secondes, votre adresse IP devrait apparaître.

Dans votre réseau local, ouvrez un navigateur et saisissez l’adresse IP ESP8266.

Vous pouvez maintenant voir la température en degrés Celsius et Fahrenheit sur votre serveur Web. Les lectures du capteur sont mises à jour automatiquement sans qu’il soit nécessaire d’actualiser la page Web.

Serveur Web ESP8266 avec capteur de température DS18B20 OneWire Arduino IDE

Conclusion

Il s’agissait d’un guide détaillé sur la façon d’utiliser le capteur de température DS18B20 avec l’ESP8266 et d’afficher les lectures sur un serveur Web.

Le DS18B20 communique via un protocole à un fil et chaque capteur possède un code série 64 bits unique, ce qui signifie que vous pouvez lire de nombreux capteurs sur la même broche de données.

Nous espérons que vous avez trouvé ce tutoriel utile. Nous avons d’autres tutoriels avec l’ESP8266 qui pourraient également vous plaire :

En savoir plus sur l’ESP8266 avec domotique à l’aide de l’ESP8266 (eBook + cours vidéo).

Merci d’avoir lu.

Apprenez l’histoire de Raspberry Pi à travers cette vidéo :

YouTube video