Le guide complet des capteurs de température numériques DS18B20 avec Arduino

Ce tutoriel comprend tout ce que vous devez savoir sur l’utilisation  des capteurs de température numériques DS18B20 1-Wire  avec Arduino. J’ai inclus des schémas de câblage et plusieurs exemples de codes pour vous aider à démarrer.

Pour ce didacticiel, nous utiliserons  DallasTemperature  en combinaison avec la  bibliothèque OneWire  Arduino. Ces bibliothèques facilitent la communication avec un ou plusieurs capteurs. Dans la première partie de cet article, vous trouverez les spécifications et informations sur les différents types de capteurs DS18B20. Ensuite, nous verrons comment connecter le capteur à l’Arduino.

Dans le premier exemple de code, je vais vous montrer comment prendre des mesures de température à partir d’un seul capteur et afficher le résultat dans le moniteur série. Les exemples suivants expliquent comment lire plusieurs capteurs avec une seule broche Arduino. Enfin, je vais vous montrer comment afficher la température sur un  LCD I2C .

Si vous souhaitez en savoir plus sur les autres capteurs de température, consultez les articles ci-dessous.

Composants matériels

Logiciel

EDIArduino

À propos du capteur de température DS18B20 1-Wire

Le DS18B20 est un capteur de température numérique fabriqué par  Maxim Integrated  (anciennement Dallas Semiconductor). C’est l’un des capteurs de température les plus populaires du marché et il offre une précision assez élevée (±0,5 °C) sur une large plage de température (-55 °C à + 125 °C). Étant donné que la tension de fonctionnement du capteur est de 3,0 à 5,5 V, vous pouvez l’utiliser à la fois avec l’Arduino (qui fonctionne à 5 V), ainsi qu’avec des appareils comme l’ESP32 et le Raspberry Pi qui ont des broches GPIO de 3,3 V.

L’un des principaux avantages de ce capteur est qu’il ne nécessite qu’une seule broche numérique de l’Arduino pour la communication. Le capteur communique à l’aide du protocole Dallas Semiconductor  . Ce protocole fonctionne de la même manière que I2C, mais avec des débits de données inférieurs et une portée plus longue.

Un autre avantage est que chaque capteur DS18B20 possède un code série 64 bits unique, ce qui permet à plusieurs capteurs de fonctionner sur le même bus 1-Wire. Ainsi, vous pouvez lire les données de plusieurs capteurs connectés avec une seule broche Arduino (voir les exemples de code ci-dessous).

La résolution du capteur peut être réglée par programme sur 9, 10, 11 ou 12 bits. Cela correspond à des incréments de température de 0,5 °C, 0,25 °C, 0,125 °C et 0,0635 °C, respectivement. La résolution par défaut à la mise sous tension est de 12 bits.

Vous pouvez trouver plus de spécifications dans le tableau ci-dessous.

Spécifications du capteur de température numérique DS18B20

Pour plus d’informations, vous pouvez également consulter la fiche technique ici:

Types de capteurs DS18B20

Le capteur se présente généralement sous trois facteurs de forme. Le type le plus courant est le  boîtier TO-92 à 3 broches , qui ressemble à un transistor.

Ce type de capteur est parfois monté sur une  carte de dérivation  qui peut inclure une LED d’alimentation et la résistance pull-up de 4,7 kΩ requise. Assurez-vous toujours de vérifier les marquages ​​​​sur le PCB car l’ordre des broches peut être différent selon le fabricant.

Enfin, vous pouvez acheter le capteur dans un  style de sonde étanche  avec un câble déjà attaché. Ce style peut être utile si vous souhaitez mesurer quelque chose de loin, sous l’eau ou sous le sol.

Notez que le câble du capteur étanche est généralement gainé de PVC, il est donc recommandé de le maintenir en dessous de 100 °C.

Câblage – Connexion du DS18B20 à un Arduino

Connecter un DS18B20 à l’Arduino est assez facile car il suffit de connecter 3 broches. Commencez par connecter la broche GND à la masse et la broche Vdd à la sortie 5 V de l’Arduino.

Ensuite, connectez la broche du milieu (DQ) à l’une des broches numériques de l’Arduino. Dans ce cas, j’ai utilisé la broche numérique 2. Vous devez également ajouter une  résistance de rappel de 4,7 kΩ  entre la broche DQ et 5 V. Cela maintiendra l’état d’inactivité du bus 1-Wire élevé.

Notez que la broche 1 (GND) est la broche la plus à gauche lorsque le côté plat du capteur (avec le texte imprimé dessus) est tourné vers vous.

Connexions du capteur de température numérique DS18B20

Un capteur étanche DS18B20 se connecte de la même manière. Cependant, la couleur des fils peut être différente selon le fabricant. Le fil de terre (GND) est généralement noir ou bleu, le fil d’alimentation (VDD) est généralement rouge et le fil de signal (DQ) est souvent jaune ou blanc. Je recommande fortement de toujours vérifier la fiche technique de votre capteur si vous n’êtes pas sûr.

Connexions étanches du capteur de température numérique DS18B20

Installation des bibliothèques DallasTemperature et OneWire Arduino

Le protocole de communication 1-Wire est quelque peu complexe et nécessite un tas de code pour analyser la communication. Par conséquent, nous utiliserons la bibliothèque DallasTemperature Arduino de Miles Burton pour faciliter la programmation de ces capteurs.

Cette bibliothèque vous permet d’émettre des commandes simples pour lire les données de température des capteurs.

Vous pouvez trouver le code source de cette bibliothèque  ici sur GitHub .

Pour installer la bibliothèque, accédez à  Outils > Gérer les bibliothèques  (Ctrl + Maj + I sous Windows) dans l’  IDE Arduino . Le gestionnaire de bibliothèques ouvrira et mettra à jour la liste des bibliothèques installées.

Vous pouvez rechercher  ‘ds18b20’  et rechercher la   bibliothèque  DallasTemperature de Miles Burton . Sélectionnez la dernière version, puis cliquez sur Installer.

La bibliothèque DallasTemperature s’appuie sur la  bibliothèque OneWire Arduino  que vous devez également installer. Cette bibliothèque prend en charge le protocole de communication 1-Wire.

Recherchez  « onewire »  et recherchez la   bibliothèque  OneWire de Jim Studt .

Capteur de température DS18B20 avec exemple de code Arduino

Avec l’exemple de code suivant, vous pouvez lire la température d’un capteur DS18B20 et l’afficher dans le moniteur série.

Vous pouvez télécharger l’exemple de code sur votre Arduino à l’aide de l’  IDE Arduino .

Pour copier le code, cliquez sur le bouton dans le coin supérieur droit du champ de code.

/* Capteur de température numérique à 1 fil DS18B20 avec exemple de code Arduino. Plus d'infos : https://www.makerguides.com */

// Incluez les bibliothèques Arduino requises :
#include <OneWire.h>
#include <DallasTemperature.h>

// Définir à quelle broche de l'Arduino le bus 1-Wire est connecté :
#define ONE_WIRE_BUS 2

// Crée une nouvelle instance de la classe oneWire pour communiquer avec n'importe quel appareil OneWire :
Un fil un fil(ONE_WIRE_BUS);

// Passez la référence oneWire à la bibliothèque DallasTemperature :
Capteurs de température Dallas(&oneWire);

void setup() {
  // Commencer la communication série à un débit en bauds de 9 600 :
  Série.begin(9600);
  // Démarrez la bibliothèque :
  capteurs.begin();
}

boucle vide() {
  // Envoie la commande à tous les appareils sur le bus pour effectuer une conversion de température :
  capteurs.requestTemperatures();

  // Récupère la température en degrés Celsius pour l'index de l'appareil :
  float tempC = capteurs.getTempCByIndex(0); // l'index 0 fait référence au premier appareil
  // Récupère la température en degrés Fahrenheit pour l'index de l'appareil :
  flotteur tempF = capteurs.getTempFByIndex(0);

  // Imprime la température en Celsius dans le Serial Monitor :
  Serial.print("Température : ");
  Serial.print(tempC);
  Serial.print(" \xC2\xB0"); // affiche le symbole du degré
  Serial.print("C | ");

  // Imprimer la température en Fahrenheit
  Serial.print(tempF);
  Serial.print(" \xC2\xB0"); // affiche le symbole du degré
  Serial.println("F");

  // Attendez 1 seconde :
  retard(1000);
}

Vous devriez voir la sortie suivante dans le moniteur série (Ctrl + Maj + M).

Assurez-vous que le débit en bauds du moniteur série est également défini sur 9600.

Comment fonctionne le code

La première étape consiste à inclure les bibliothèques Arduino requises :

// Incluez les bibliothèques Arduino requises :
#include <OneWire.h>
#include <DallasTemperature.h>

Ensuite, j’ai défini à quelle broche de l’Arduino la broche DQ du capteur est connectée. L’instruction  #define  peut être utilisée pour donner un nom à une valeur constante. Le compilateur remplacera toutes les références à cette constante par la valeur définie lors de la compilation du programme. Ainsi, partout où vous mentionnez ONE_WIRE_BUS, le compilateur le remplacera par la valeur 2 lorsque le programme sera compilé.

// Définir à quelle broche de l'Arduino le bus 1-Wire est connecté :
#define ONE_WIRE_BUS 2

Après cela, j’ai créé un nouvel objet de la classe OneWire et passé la broche DQ à son constructeur. Vous devez également créer un objet de la classe DallasTemperature et passer l’objet oneWire en paramètre.

Notez que j’ai appelé l’objet DallasTemperature “capteurs”, mais vous pouvez également utiliser d’autres noms.

Un fil un fil(ONE_WIRE_BUS);
Capteurs de température Dallas(&oneWire);

Dans la section de configuration du code, nous commençons la communication série à un débit en bauds de 9600. Ensuite, j’ai initialisé le bus avec la fonction begin().

void setup() {
  // Commencer la communication série à un débit en bauds de 9 600 :
  Série.begin(9600);
  // Démarrez la bibliothèque :
  capteurs.begin();
}

Dans la section boucle du code, nous commençons par la commande pour tous les capteurs du bus pour démarrer une conversion de température.

  // Envoie la commande à tous les appareils sur le bus pour effectuer une conversion de température :
  capteurs.requestTemperatures();

Ensuite, j’ai utilisé les fonctions getTempCByIndex(deviceIndex)et getTempFByIndex(deviceIndex)pour récupérer la température en degrés Celsius et Fahrenheit respectivement. Dans ce cas, nous n’avons qu’un seul capteur connecté au bus. Comme le comptage commence à zéro, j’ai défini l’index de notre capteur sur 0.

  // Récupère la température en degrés Celsius pour l'index de l'appareil :
  float tempC = capteurs.getTempCByIndex(0); // l'index 0 fait référence au premier appareil
  // Récupère la température en degrés Fahrenheit pour l'index de l'appareil :
  flotteur tempF = capteurs.getTempFByIndex(0);

Enfin, les températures sont imprimées dans le Serial Monitor :

  // Imprime la température en Celsius dans le Serial Monitor :
  Serial.print("Température : ");
  Serial.print(tempC);
  Serial.print(" \xC2\xB0"); // affiche le symbole du degré
  Serial.print("C | ");
  // Imprimer la température en Fahrenheit
  Serial.print(tempF);
  Serial.print(" \xC2\xB0"); // affiche le symbole du degré
  Serial.println("F");

Comme la conversion de température en mode 12 bits peut prendre jusqu’à 750 ms, j’ai ajouté un délai d’une seconde entre chaque mesure.

Utilisation de plusieurs capteurs DS18B20 avec Arduino

Comme je l’ai mentionné dans l’introduction, vous pouvez lire la température de plusieurs capteurs DS18B20 avec une seule broche de l’Arduino. Vous trouverez ci-dessous deux exemples de codes. Avec le premier exemple, vous pouvez lire la température des capteurs connectés par leur index. Comme tous les capteurs sont connectés au même bus 1-Wire, le premier capteur a l’indice 0, le second l’indice 1, etc.

Dans le deuxième exemple, je vais vous montrer comment lire l’adresse 64 bits unique de chaque capteur. Cette adresse peut ensuite être utilisée pour lire chaque capteur individuellement.

Câblage – Connexion de plusieurs capteurs DS18B20 à l’Arduino

Connecter plusieurs capteurs DS18B20 à l’Arduino est aussi simple que d’en connecter un seul. Tous les capteurs sont connectés en parallèle, c’est-à-dire que toutes les mêmes broches sont connectées ensemble. Comme auparavant, les broches GND sont connectées à la masse, les broches V _DD  à 5 V et les broches DQ à la broche 2 de l’Arduino. N’oubliez pas la résistance pull-up de 4,7 kΩ entre la broche DQ et 5 V.

Notez que j’ai utilisé une planche à pain pour connecter toutes les broches ensemble. Si vous n’êtes pas familier avec le fonctionnement d’une planche à pain, vous pouvez trouver une explication  ici .

Plusieurs capteurs DS18B20 avec un exemple de code Arduino

Avec l’exemple ci-dessous, vous pouvez lire la température de chaque capteur par son index et l’afficher dans le moniteur série.

/* Plusieurs capteurs de température numériques DS18B20 1-Wire avec exemple de code Arduino. Plus d'infos : https://www.makerguides.com */

// Incluez les bibliothèques Arduino requises :
#include <OneWire.h>
#include <DallasTemperature.h>

// Définir à quelle broche de l'Arduino le bus 1-Wire est connecté :
#define ONE_WIRE_BUS 2

// Crée une nouvelle instance de la classe oneWire pour communiquer avec n'importe quel appareil OneWire :
Un fil un fil(ONE_WIRE_BUS);

// Passez la référence oneWire à la bibliothèque DallasTemperature :
Capteurs de température Dallas(&oneWire);

int deviceCount = 0 ;
flotter tempC ;
flotteur tempF ;

void setup() {
  // Commencer la communication série à un débit en bauds de 9 600 :
  Série.begin(9600);
  // Démarrez la bibliothèque :
  capteurs.begin();

  // Localisez les appareils sur le bus :
  Serial.println("Localisation des périphériques...");
  Serial.print("Trouvé ");
  deviceCount = capteurs.getDeviceCount();
  Serial.print(deviceCount);
  Serial.println(" devices");
}

boucle vide() {
  // Envoie la commande à tous les appareils sur le bus pour effectuer une conversion de température :
  capteurs.requestTemperatures();

  // Affichage de la température de chaque capteur
  for (int je = 0; je < deviceCount; je++) {
    Serial.print("Capteur ");
    Serial.print(i + 1);
    Serial.print(" : ");
    tempC = capteurs.getTempCByIndex(i);
    tempF = capteurs.getTempFByIndex(i);
    Serial.print(tempC);
    Serial.print(" \xC2\xB0"); // affiche le symbole du degré
    Serial.print("C | ");
    Serial.print(tempF);
    Serial.print(" \xC2\xB0"); // affiche le symbole du degré
    Serial.println("F");
  }

  Serial.println();
  retard(1000);
}

La sortie dans le moniteur série devrait ressembler à ceci :

Comment fonctionne le code

Le code de cet exemple est essentiellement le même qu’avant.

Dans la section de configuration, j’ai ajouté une fonction supplémentaire qui compte le nombre d’appareils connectés au bus 1-Wire.

  // Localisez les appareils sur le bus :
  Serial.println("Localisation des périphériques...");
  Serial.print("Trouvé ");
  deviceCount = capteurs.getDeviceCount();
  Serial.print(deviceCount);
  Serial.println(" devices");

Dans la section boucle du code, j’ai utilisé une  boucle for  pour parcourir une section de code qui récupère la température de chaque capteur connecté au bus par leur index.

  // Affichage de la température de chaque capteur
  for (int je = 0; je < deviceCount; je++) {
    Serial.print("Capteur ");
    Serial.print(i + 1);
    Serial.print(" : ");
    tempC = capteurs.getTempCByIndex(i);
    tempF = capteurs.getTempFByIndex(i);
    Serial.print(tempC);
    Serial.print(" \xC2\xB0"); // affiche le symbole du degré
    Serial.print("C | ");
    Serial.print(tempF);
    Serial.print(" \xC2\xB0"); // affiche le symbole du degré
    Serial.println("F");
  }

Lire les capteurs par adresse

Afin de lire les capteurs par leur adresse individuelle, nous devons d’abord connaître l’adresse de chaque capteur. Pour cela, vous pouvez utiliser l’exemple de croquis ci-dessous.

Le croquis imprime les adresses des capteurs connectés dans le moniteur série. Afin de savoir de quel capteur il s’agit, vous pouvez câbler un seul capteur à la fois ou ajouter successivement un nouveau capteur. Ensuite, vous pouvez étiqueter chaque capteur connecté au bus 1-Wire.

Recherche d’adresse DS18B20

/* Plusieurs capteurs de température numériques DS18B20 1-Wire avec exemple de code Arduino. Plus d'infos : https://www.makerguides.com */

// Incluez les bibliothèques Arduino requises :
#include <OneWire.h>
#include <DallasTemperature.h>

// Définir à quelle broche de l'Arduino le bus 1-Wire est connecté :
#define ONE_WIRE_BUS 2

// Crée une nouvelle instance de la classe oneWire pour communiquer avec n'importe quel appareil OneWire :
Un fil un fil(ONE_WIRE_BUS);

// Passez la référence oneWire à la bibliothèque DallasTemperature :
Capteurs de température Dallas(&oneWire);

// Créer des variables :
int deviceCount = 0 ; // variable pour stocker le nombre d'appareils connectés
DeviceAddress deviceAddress ; // variable pour stocker l'adresse de l'appareil

void setup() {
  // Commencer la communication série à un débit en bauds de 9 600 :
  Série.begin(9600);
  // Démarrez la bibliothèque :
  capteurs.begin();

  // Localisez les appareils sur le bus :
  Serial.println("Localisation des périphériques...");
  Serial.print("Trouvé ");
  deviceCount = capteurs.getDeviceCount();
  Serial.print(deviceCount);
  Serial.println(" devices");

  Serial.println("Impression des adresses...");
  for (int je = 0; je < deviceCount; je++) {
    Serial.print("Capteur ");
    Serial.print(i + 1);
    Serial.print(" : ");
    capteurs.getAddress(deviceAddress, je);
    printAddress(deviceAddress);
  }
}

boucle vide() {
}

void printAddress(DeviceAddress deviceAddress) {
  pour (uint8_t je = 0; je < 8; je++) {
    Serial.print("0x");
    si (adresse_appareil[i] < 0x10) {
      Serial.print("0");
    }
    Serial.print(deviceAddress[i], HEX);
    si (je < 7) {
      Serial.print(", ");
    }
  }
  Serial.println();
}

La sortie dans le moniteur série devrait ressembler à ceci :

Notez maintenant les adresses de tous les capteurs, car vous en aurez besoin dans l’exemple suivant.

Lire les capteurs par adresse Exemple de code Arduino

Avec l’exemple suivant, vous pouvez lire la température de chaque capteur en spécifiant leur adresse unique.

/* Lire plusieurs capteurs de température numériques DS18B20 1-Wire par adresse. Plus d'infos : https://www.makerguides.com */  // Incluez les bibliothèques Arduino requises : #include <OneWire.h> #include <DallasTemperature.h>  // Définir à quelle broche de l'Arduino le bus 1-Wire est connecté : #define ONE_WIRE_BUS 2  // Crée une nouvelle instance de la classe oneWire pour communiquer avec n'importe quel appareil OneWire : Un fil un fil(ONE_WIRE_BUS);  // Passez la référence oneWire à la bibliothèque DallasTemperature : Capteurs de température Dallas(&oneWire);  // Adresses des capteurs DS18B20 connectés au bus 1-Wire capteur d'octets1[8] = {0x28, 0x18, 0xB4, 0x49, 0x0C, 0x00, 0x00, 0x7C} ; capteur d'octets2[8] = {0x28, 0xCC, 0x19, 0x49, 0x0C, 0x00, 0x00, 0xBB} ;capteur d'octets3[8] = {0x28, 0x19, 0xEF, 0x48, 0x0C, 0x00, 0x00, 0x21} ; void setup() { // Commence la communication série à un débit en bauds de 9600 : Serial.begin(9600); // Démarrage de la bibliothèque : sensors.begin(); } void loop() { // Envoie la commande à tous les appareils sur le bus pour effectuer une conversion de température : sensors.requestTemperatures(); Serial.print("Capteur 1 : "); printTemperature(capteur1); // appelle la fonction printTemperature avec l'adresse du capteur1 en entrée Serial.print("Sensor 2: "); printTemperature(capteur2); Serial.print("Capteur 3 : "); printTemperature(capteur3); Serial.println(); // imprime une ligne vide delay(1000); } void printTemperature(DeviceAddress address) { // Récupère la température en degrés Celsius pour l'adresse de l'appareil : float tempC = sensors.getTempC(address); // Récupère la température en degrés Fahrenheit pour l'adresse de l'appareil : float tempF = sensors.getTempF(address); Serial.print(tempC); Serial.print(" \xC2\xB0"); // affiche le symbole du degré Serial.print("C | "); // Affiche la température en Fahrenheit Serial.print(tempF); Serial.print(" \xC2\xB0"); // affiche le symbole de degré Serial.println("F"); }

Notez que vous devez  remplacer les adresses des  lignes 17 à 19 par les adresses que vous avez trouvées à l’aide de l’exemple de code précédent.

// Adresses des capteurs DS18B20 connectés au bus 1-Wire
capteur d'octets1[8] = {0x28, 0x18, 0xB4, 0x49, 0x0C, 0x00, 0x00, 0x7C} ;
capteur d'octets2[8] = {0x28, 0xCC, 0x19, 0x49, 0x0C, 0x00, 0x00, 0xBB} ;
capteur d'octets3[8] = {0x28, 0x19, 0xEF, 0x48, 0x0C, 0x00, 0x00, 0x21} ;

Vous devriez voir la sortie suivante dans le moniteur série.

Explication des codes

L’adresse de chaque capteur se compose de 64 bits. Dans le code, nous spécifions l’adresse sous la forme d’un tableau de huit octets de 8 bits.

// Adresses des capteurs DS18B20 connectés au bus 1-Wire capteur d'octets1[8] = {0x28, 0x18, 0xB4, 0x49, 0x0C, 0x00, 0x00, 0x7C} ; capteur d'octets2[8] = {0x28, 0xCC, 0x19, 0x49, 0x0C, 0x00, 0x00, 0xBB} ; capteur d'octets3[8] = {0x28, 0x19, 0xEF, 0x48, 0x0C, 0x00, 0x00, 0x21} ;

La section de configuration du code est la même que dans les exemples précédents.

Dans la boucle, nous appelons la printTemperature(DeviceAddress address)fonction. Dans cette fonction personnalisée, nous utilisons getTempC(address)et getTempF(address)pour récupérer la température d’un capteur dont l’adresse est passée en paramètre.

void printTemperature (adresse de l'adresse du périphérique) { // Récupère la température en degrés Celsius pour l'adresse de l'appareil : flotteur tempC = capteurs.getTempC(adresse); // Récupère la température en degrés Fahrenheit pour l'adresse de l'appareil : float tempF = capteurs.getTempF(tempC); Serial.print(tempC); Serial.print(" \xC2\xB0"); // affiche le symbole du degré Serial.print("C | ");  // Imprimer la température en Fahrenheit Serial.print(tempF); Serial.print(" \xC2\xB0"); // affiche le symbole du degré Serial.println("F"); }

La bibliothèque 

Autres fonctions de la bibliothèque DallasTemperature Arduino

DallasTemperature contient d’autres fonctions utiles intégrées que je n’ai pas encore couvertes dans les exemples ci-dessus. J’en ai donc énuméré quelques-uns ci-dessous :

setResolution()

Cette fonction peut être utilisée pour régler la résolution de la conversion température-numérique. Comme je l’ai mentionné dans l’introduction, cela peut être réglé sur 9, 10, 11 ou 12 bits, correspondant à des incréments de 0,5 °C, 0,25 °C, 0,125 °C et 0,0625 °C, respectivement.

Vous vous demandez peut-être pourquoi vous voudriez changer la résolution, n’est-ce pas toujours mieux ? L’un des avantages de la sélection d’une résolution inférieure est que la conversion température-numérique prend beaucoup moins de temps. Cela signifie que vous pouvez prendre plus de mesures de température dans le même laps de temps.

De la fiche technique, j’ai obtenu les informations suivantes:

La bibliothèque DallasTemperature vous permet de définir la résolution avec la fonction setResolution(). Cette fonction peut être ajoutée à la section setup ou loop de votre code.

Vous pouvez définir la résolution de tous les capteurs connectés comme suit :

// Définissez la résolution de tous les appareils sur 9, 10, 11 ou 12 bits :
capteurs.setResolution(9);

Ou vous pouvez le définir individuellement pour un capteur spécifique en spécifiant son adresse :

// Adresses des capteurs DS18B20 connectés au bus 1-Wire
capteur d'octets1[8] = {0x28, 0x18, 0xB4, 0x49, 0x0C, 0x00, 0x00, 0x7C} ;

// Définissez la résolution d'un périphérique spécifique sur 9, 10, 11 ou 12 bits :
capteurs.setResolution(capteur1, 9);

enFahrenheit()

Cette fonction peut être utilisée pour convertir la température en degrés Celsius en Fahrenheit.

float tempC = capteurs.getTempCbyIndex(0); 
float tempF = DallasTemperature::toFahrenheit(tempC);

setHighAlarmTemp() et setLowAlarmTemp()

Cette fonction définit les alarmes internes de température élevée et basse d’un appareil en degrés Celsius.

bool aAlarme()

Cette fonction renvoie vrai lorsqu’un appareil présente une condition d’alarme. Vous pouvez trouver un exemple de ces fonctions  ici .

Afficher les lectures de température DS18B20 sur un écran LCD I2C

Si vous souhaitez réaliser un projet autonome qui ne nécessite pas d’ordinateur, il peut être utile de savoir comment afficher les relevés de température sur un écran LCD.

Avec l’exemple de code ci-dessous, vous pouvez afficher les relevés de température sur un écran LCD I2C de 16 × 2 caractères.

La connexion de l’écran LCD I2C est très facile comme vous pouvez le voir dans le schéma de câblage ci-dessous. Vous pouvez consulter mon tutoriel détaillé ci-dessous pour plus d’informations.

• Comment contrôler un LCD I2C de caractères avec Arduino

Si vous souhaitez plutôt utiliser un écran LCD non I2C standard, consultez cet article :

• • Comment utiliser un écran LCD 16 × 2 caractères avec Arduino

Connexions LCD I2C

Pour utiliser un LCD I2C, vous devrez installer la  bibliothèque LiquidCrystal_I2C  Arduino.

Ouvrez le gestionnaire de bibliothèque dans l’IDE Arduino et recherchez “liquidcrystal_i2c”. Faites maintenant défiler vers le bas et recherchez la bibliothèque de  Frank de Brabander . Sélectionnez la dernière version, puis cliquez sur Installer.

DS18B20 avec exemple de code LCD I2C

/* DS18B20 1-Wire digital temperature sensor with 16x2 I2C LCD and Arduino example code. More info: https://www.makerguides.com */

// Incluez les bibliothèques Arduino requises :
#include <OneWire.h>
#include <DallasTemperature.h>
#include <LiquidCrystal_I2C.h>

// Définir à quelle broche de l'Arduino le bus 1-Wire est connecté :
#define ONE_WIRE_BUS 2

// Crée une nouvelle instance de la classe oneWire pour communiquer avec n'importe quel appareil OneWire :
Un fil un fil(ONE_WIRE_BUS);

// Passez la référence oneWire à la bibliothèque DallasTemperature :
Capteurs de température Dallas(&oneWire);

LCD LiquidCrystal_I2C (0x27, 16, 2);

// Symbole de degré :
octet Degré[] = {
  B00111, 
  B00101, 
  B00111, 
  B0000, 
  B0000, 
  B0000, 
  B0000, 
  B00000
};

void setup() {
  // Démarrez la bibliothèque :
  capteurs.begin();
  // Démarrez l'écran LCD et allumez le rétroéclairage :
  lcd.init();
  LCD rétro-éclairage();
  // Crée un personnage personnalisé :
  lcd.createChar(0, Degré);
}

void loop() {
  // Envoie la commande à tous les appareils sur le bus pour effectuer une conversion de température :
  capteurs.requestTemperatures();

  // Récupère la température en degrés Celsius pour l'index de l'appareil :
  float tempC = capteurs.getTempCByIndex(0); // l'index 0 fait référence au premier appareil

  // Imprimer la température sur l'écran LCD ;
  lcd.setCursor(0,0);
  lcd.print("Température :");
  lcd.setCursor(0,1);
  lcd.print(tempC);
  lcd.write(0); // imprime le caractère personnalisé
  lcd.print("C");

  // Attendez 1 seconde :
  retard(1000);
}

Vous devriez voir la sortie suivante sur l’écran LCD :

Conclusion

Dans ce tutoriel, je vous ai montré comment utiliser les capteurs de température numériques DS18B20 1-Wire avec Arduino. J’espère que vous l’avez trouvé utile et informatif. Si c’est le cas,  partagez cet article  avec un ami qui aime aussi l’électronique et la fabrication d’objets.

J’aimerais savoir quels projets vous envisagez de construire (ou avez déjà construit) avec ces capteurs. Si vous avez des questions, des suggestions ou si vous pensez qu’il manque des choses dans ce tutoriel,  veuillez laisser un commentaire ci-dessous .

Notez que les commentaires sont conservés pour modération afin d’éviter les spams.