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 à 1 fil DS18B20 avec Arduino. J’ai inclus des schémas de câblage et plusieurs exemples de codes pour vous aider à démarrer.

Pour ce tutoriel, nous utiliserons la 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 écran LCD I2C .

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

Composants matériels

  1. Capteur de température numérique DS18B20 (TO-92) x3
  2. DS18B20 étanche (alternative)
  3. Carte de dérivation DS18B20 (alternative)
  4. Arduino Uno
  5. Breadbord
  6. Fils x15
  7. Résistance pull-up 4,7 kΩ
  8. LCD I2C 16 × 2 caractères
  9. Câble USB type A / B

À propos du capteur de température à 1 fil DS18B20

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 sur le marché et offre une précision assez élevée (± 0,5 ° C) sur une large plage de température (-55 ° C à + 125 ° C). Comme 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 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 en utilisant le protocole Dallas Semiconductor 1-Wire ® . 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 unique de 64 bits, 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

Tension d’alimentation3,0 à 5,5 V
Courant de veille1 μA
Courant actif1,5 mA
Plage de mesure-55 ° C à + 125 ° C (-67 ° F à +257 ° F)
Précision
(erreur du thermomètre)
± 0,5 ° C de -10 ° C à +85 ° C
± 1 ° C de -30 ° C à +100 ° C
± 2 ° C de -55 ° C à +125 ° C
Résolution9 bits à 12 bits (programmable)
Temps de conversion<750 ms (résolution 12 bits)
Protocole de communicationProtocole de bus 1-Wire®
PaquetTO-92 3 broches
FabricantMaxim intégré
CoûtVérifiez le prix

 

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.

 

q? encoding=UTF8&ASIN=B004G53D54&Format= SL250 &ID=AsinImage&MarketPlace=US&ServiceVersion=20070822&WS=1&tag=makerguides 20&language=en US

Ce type de capteur est parfois monté sur une carte de dérivation qui peut inclure une LED d’alimentation et la résistance de rappel 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.

 

q? encoding=UTF8&ASIN=B013GB27HS&Format= SL250 &ID=AsinImage&MarketPlace=US&ServiceVersion=20070822&WS=1&tag=makerguides 20&language=en US

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.

 

q? encoding=UTF8&ASIN=B012C597T0&Format= SL250 &ID=AsinImage&MarketPlace=US&ServiceVersion=20070822&WS=1&tag=makerguides 20&language=en US

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


Câblage – Connexion du DS18B20 à un Arduino

Connecter un DS18B20 à l’Arduino est assez facile car il vous suffit de connecter 3 broches. Commencez par connecter la broche GND à la terre et la broche V DD à 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 pull-up de 4,7 kΩ entre la broche DQ et 5 V. Cela gardera l’état inactif du bus 1-Wire élevé.

DS18B20-capteur-de-température-numérique-avec-connexions-Arduino-schéma-câblage-tutoriel-circuit-schématique
Capteur de température numérique DS18B20 avec schéma de câblage Arduino Uno

Les connexions sont également données dans le tableau ci-dessous.

DS18B20-brochage-capteur-de-temperature-numerique

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

DS18B20Arduino
Broche 1 (GND)GND
Broche 2 (DQ)Broche 2 Arduino et via une résistance de 4,7 kΩ à 5 V
PIN 3 (V DD )5V

Un capteur DS18B20 étanche se connecte de la même manière. Cependant, la couleur des fils peut être différente selon le fabricant. Le fil de masse (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 du capteur de température numérique DS18B20 étanche

DS18B20 étancheArduino
Fil noir (GND)GND
Fil jaune (DQ)Broche 2 Arduino et via une résistance de 4,7 kΩ à 5 V
Fil rouge (V DD )5V

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èque ouvrira et mettra à jour la liste des bibliothèques installées.

Installation d'une bibliothèque Arduino Étape 1 Ouvrez Library Manager

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

Installing the DallasTemperature Arduino library

La bibliothèque DallasTemperature repose 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 .

Installing the OneWire Arduino library

Capteur de température DS18B20 avec exemple de code Arduino

Avec l’exemple de code suivant, vous pouvez lire la température à partir 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.

/* DS18B20 1-Wire digital temperature sensor with Arduino example code. More info: https://www.makerguides.com */
// Include the required Arduino libraries:
#include <OneWire.h>
#include <DallasTemperature.h>
// Define to which pin of the Arduino the 1-Wire bus is connected:
#define ONE_WIRE_BUS 2
// Create a new instance of the oneWire class to communicate with any OneWire device:
OneWire oneWire(ONE_WIRE_BUS);
// Pass the oneWire reference to DallasTemperature library:
Capteurs de température Dallas ( & oneWire ) ;
void setup () {
// Commencez la communication série à une vitesse de transmission de 9600:
En série. commencer ( 9600 ) ;
// Démarrez la bibliothèque:
capteurs. begin () ;
}
boucle void () {
// 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:
float tempF = capteurs. getTempFByIndex ( 0 ) ;
// Imprimer la température en Celsius dans le moniteur série:
En série. print ( “Température:” ) ;
En série. impression ( tempC ) ;
En série. impression ( “\ xC2 \ xB0” ) ; // montre le symbole du degré
En série. imprimer ( “C |” ) ;
// Imprimer la température en Fahrenheit
En série. impression ( tempF ) ;
En série. impression ( “\ xC2 \ xB0” ) ; // montre le symbole du degré
En série. println ( “F” ) ;
// Attendez 1 seconde:
retard ( 1000 ) ;
}

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

DS18B20 temperature reading Serial Monitor output
Sortie moniteur série

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

Comment fonctionne le code

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

// Inclut 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. Donc, partout où vous le mentionnez  ONE_WIRE_BUS, le compilateur le remplacera par la valeur 2 lorsque le programme sera compilé.

// Définissez à 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 transmettre l’objet oneWire en tant que paramètre.

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

OneWire oneWire ( ONE_WIRE_BUS ) ;
Capteurs de température Dallas ( & oneWire ) ;

Dans la section de configuration du code, nous commençons la communication série à une vitesse de transmission de 9600. Ensuite, j’ai initialisé le bus avec la fonction  begin().

void setup () {
// Commencez la communication série à une vitesse de transmission de 9600:
En série. commencer ( 9600 ) ;
// Démarrez la bibliothèque:
capteurs. begin () ;
}

Dans la section boucle du code, nous commençons par la commande pour tous les capteurs sur le bus de 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. Parce que le comptage commence à zéro, j’ai mis l’index de notre capteur à 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:
float tempF = capteurs. getTempFByIndex ( 0 ) ;

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

// Imprimer la température en Celsius dans le moniteur série:
En série. print ( “Température:” ) ;
En série. impression ( tempC ) ;
En série. impression ( “\ xC2 \ xB0” ) ; // montre le symbole du degré
En série. imprimer ( “C |” ) ;
// Imprimer la température en Fahrenheit
En série. impression ( tempF ) ;
En série. impression ( “\ xC2 \ xB0” ) ; // montre le symbole du degré
En série. println ( “F” ) ;

La conversion de température en mode 12 bits pouvant 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. Étant donné que tous les capteurs sont connectés au même bus 1-Wire, le premier capteur a l’index 0, le second index 1, et ainsi de suite.

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

La connexion de plusieurs capteurs DS18B20 à l’Arduino est aussi simple que la connexion d’un seul. Tous les capteurs sont connectés en parallèle, c’est-à-dire que toutes les mêmes broches sont connectées ensemble. Tout comme avant, les broches GND sont connectées à la terre, 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 maquette pour connecter toutes les broches ensemble. Si vous ne connaissez pas le fonctionnement d’une maquette, vous pouvez trouver une explication  ici .

1 multiple DS18B20 digital temperature sensors with Arduino connections wiring diagram schematic circuit tutorial 1
Plusieurs capteurs de température numériques DS18B20 à 1 fil connectés à un Arduino

Plusieurs capteurs DS18B20 avec 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 * /
// Inclut les bibliothèques Arduino requises:
#include <OneWire.h>
#include <DallasTemperature.h>
// Définissez à quelle broche de l’Arduino le bus 1-Wire est connecté:
#define ONE_WIRE_BUS 2
// Créez une nouvelle instance de la classe oneWire pour communiquer avec n’importe quel appareil OneWire:
OneWire oneWire ( ONE_WIRE_BUS ) ;
// Passez la référence oneWire à la bibliothèque DallasTemperature:
Capteurs de température Dallas ( & oneWire ) ;
int deviceCount = 0;
float tempC;
float tempF;
void setup () {
// Commencez la communication série à une vitesse de transmission de 9600:
En série. commencer ( 9600 ) ;
// Démarrez la bibliothèque:
capteurs. begin () ;
// Localisez les appareils sur le bus:
En série. println ( “Localisation des périphériques …” ) ;
En série. print ( “Trouvé” ) ;
deviceCount = capteurs. getDeviceCount () ;
En série. print ( deviceCount ) ;
En série. println ( “périphériques” ) ;
}
boucle void () {
// 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
pour ( int i = 0; i < deviceCount; i ++ ) {
En série. impression ( “Capteur” ) ;
En série. imprimer ( i + 1 ) ;
En série. imprimer ( “:” ) ;
tempC = capteurs. getTempCByIndex ( i ) ;
tempF = capteurs. getTempFByIndex ( i ) ;
En série. impression ( tempC ) ;
En série. impression ( “\ xC2 \ xB0” ) ; // montre le symbole du degré
En série. imprimer ( “C |” ) ;
En série. impression ( tempF ) ;
En série. impression ( “\ xC2 \ xB0” ) ; // montre le symbole du degré
En série. println ( “F” ) ;
}
En série. println () ;
retard ( 1000 ) ;
}

La sortie du moniteur série devrait ressembler à ceci:

Multiple-DS18B20-capteurs-de-température-sortie-moniteur-série
Sortie moniteur série de plusieurs capteurs DS18B20

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:
En série. println ( “Localisation des périphériques …” ) ;
En série. print ( “Trouvé” ) ;
deviceCount = capteurs. getDeviceCount () ;
En série. print ( deviceCount ) ;
En série. println ( “périphériques” ) ;

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
pour ( int i = 0; i < deviceCount; i ++ ) {
En série. impression ( “Capteur” ) ;
En série. imprimer ( i + 1 ) ;
En série. imprimer ( “:” ) ;
tempC = capteurs. getTempCByIndex ( i ) ;
tempF = capteurs. getTempFByIndex ( i ) ;
En série. impression ( tempC ) ;
En série. impression ( “\ xC2 \ xB0” ) ; // montre le symbole du degré
En série. imprimer ( “C |” ) ;
En série. impression ( tempF ) ;
En série. impression ( “\ xC2 \ xB0” ) ; // montre le symbole du degré
En série. println ( “F” ) ;
}

Lire les capteurs par adresse

Afin de lire les capteurs par leur adresse individuelle, nous devons d’abord savoir quelle est l’adresse de chaque capteur. Pour cela, vous pouvez utiliser l’exemple d’esquisse ci-dessous.

Le croquis imprime les adresses des capteurs connectés dans le moniteur série. Afin de savoir quel capteur est lequel, 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 * /
// Inclut les bibliothèques Arduino requises:
#include <OneWire.h>
#include <DallasTemperature.h>
// Définissez à quelle broche de l’Arduino le bus 1-Wire est connecté:
#define ONE_WIRE_BUS 2
// Créez une nouvelle instance de la classe oneWire pour communiquer avec n’importe quel appareil OneWire:
OneWire oneWire ( 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 () {
// Commencez la communication série à une vitesse de transmission de 9600:
En série. commencer ( 9600 ) ;
// Démarrez la bibliothèque:
capteurs. begin () ;
// Localisez les appareils sur le bus:
En série. println ( “Localisation des périphériques …” ) ;
En série. print ( “Trouvé” ) ;
deviceCount = capteurs. getDeviceCount () ;
En série. print ( deviceCount ) ;
En série. println ( “périphériques” ) ;
En série. println ( “Impression des adresses …” ) ;
pour ( int i = 0; i < deviceCount; i ++ ) {
En série. impression ( “Capteur” ) ;
En série. imprimer ( i + 1 ) ;
En série. imprimer ( “:” ) ;
capteurs. getAddress ( deviceAddress, i ) ;
printAddress ( deviceAddress ) ;
}
}
boucle void () {
}
void printAddress ( DeviceAddress deviceAddress ) {
pour ( uint8_t i = 0; i < 8; i ++ ) {
En série. impression ( “0x” ) ;
if ( deviceAddress [ i ] < 0x10 ) {
En série. imprimer ( “0” ) ;
}
En série. impression ( deviceAddress [ i ] , HEX ) ;
si ( i < 7 ) {
En série. imprimer ( “,” ) ;
}
}
En série. println () ;
}

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

Recherche-adresse DS18B20

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 à 1 fil DS18B20 par adresse. Plus d’infos: https://www.makerguides.com * /
// Inclut les bibliothèques Arduino requises:
#include <OneWire.h>
#include <DallasTemperature.h>
// Définissez à quelle broche de l’Arduino le bus 1-Wire est connecté:
#define ONE_WIRE_BUS 2
// Créez une nouvelle instance de la classe oneWire pour communiquer avec n’importe quel appareil OneWire:
OneWire oneWire ( 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
byte sensor1 [ 8 ] = { 0x28 , 0x18 , 0xB4 , 0x49 , 0x0C , 0x00 , 0x00 , 0x7C } ;
byte sensor2 [ 8 ] = { 0x28 , 0xCC , 0x19 , 0x49 , 0x0C , 0x00 , 0x00 , 0xBB } ;
byte sensor3 [ 8 ] = { 0x28 , 0x19 , 0xEF , 0x48 , 0x0C , 0x00 , 0x00 , 0x21 } ;
void setup () {
// Commencez la communication série à une vitesse de transmission de 9600:
En série. commencer ( 9600 ) ;
// Démarrez la bibliothèque:
capteurs. begin () ;
}
boucle void () {
// Envoie la commande à tous les appareils sur le bus pour effectuer une conversion de température:
capteurs. requestTemperatures () ;
En série. impression ( “Capteur 1:” ) ;
printTemperature ( sensor1 ) ; // appelle la fonction printTemperature avec l’adresse de sensor1 comme entrée
En série. impression ( “Capteur 2:” ) ;
printTemperature ( sensor2 ) ;
En série. impression ( “Capteur 3:” ) ;
printTemperature ( sensor3 ) ;
En série. println () ; // imprime une ligne vide
retard ( 1000 ) ;
}
void printTemperature ( adresse DeviceAddress ) {
// Récupère la température en degrés Celsius pour l’adresse de l’appareil:
float tempC = capteurs. getTempC ( adresse ) ;
// Récupère la température en degrés Fahrenheit pour l’adresse de l’appareil:
float tempF = capteurs. getTempF ( adresse ) ;
En série. impression ( tempC ) ;
En série. impression ( “\ xC2 \ xB0” ) ; // montre le symbole du degré
En série. imprimer ( “C |” ) ;
// Imprimer la température en Fahrenheit
En série. impression ( tempF ) ;
En série. impression ( “\ xC2 \ xB0” ) ; // montre le symbole du degré
En série. 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
byte sensor1 [ 8 ] = { 0x28 , 0x18 , 0xB4 , 0x49 , 0x0C , 0x00 , 0x00 , 0x7C } ;
byte sensor2 [ 8 ] = { 0x28 , 0xCC , 0x19 , 0x49 , 0x0C , 0x00 , 0x00 , 0xBB } ;
byte sensor3 [ 8 ] = { 0x28 , 0x19 , 0xEF , 0x48 , 0x0C , 0x00 , 0x00 , 0x21 } ;

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

Multiple DS18B20 temperature sensors Serial Monitor output by address

Code

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
byte sensor1 [ 8 ] = { 0x28 , 0x18 , 0xB4 , 0x49 , 0x0C , 0x00 , 0x00 , 0x7C } ;
byte sensor2 [ 8 ] = { 0x28 , 0xCC , 0x19 , 0x49 , 0x0C , 0x00 , 0x00 , 0xBB } ;
byte sensor3 [ 8 ] = { 0x28 , 0x19 , 0xEF , 0x48 , 0x0C , 0x00 , 0x00 , 0x21 } ;

La section d’installation du code est la même que 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 DeviceAddress ) {
// Récupère la température en degrés Celsius pour l’adresse de l’appareil:
float 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 ) ;
En série. impression ( tempC ) ;
En série. impression ( “\ xC2 \ xB0” ) ; // montre le symbole du degré
En série. imprimer ( “C |” ) ;
// Imprimer la température en Fahrenheit
En série. impression ( tempF ) ;
En série. impression ( “\ xC2 \ xB0” ) ; // montre le symbole du degré
En série. println ( “F” ) ;
}

Autres fonctions de la bibliothèque Arduino DallasTemperature

La bibliothèque DallasTemperature a quelques 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:

RésolutionIncrément de températureTemps de conversion maximum
9 bits0.5 °C93,75 ms
10 bits0.25 °C187,5 ms
11 bits0.125 °C375 ms
12 bits0.0625 °C750 ms

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

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

// Définit 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
byte sensor1 [ 8 ] = { 0x28 , 0x18 , 0xB4 , 0x49 , 0x0C , 0x00 , 0x00 , 0x7C } ;
// Définit la résolution d’un périphérique spécifique sur 9, 10, 11 ou 12 bits:
capteurs. setResolution ( sensor1, 9 ) ;

toFahrenheit ()

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 règle les alarmes internes de haute et basse température d’un appareil en degrés Celsius.

booléen hasAlarm ()

Cette fonction retourne true lorsqu’un périphérique a une condition d’alarme. Vous pouvez trouver un exemple de ces fonctions  ici .


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

Si vous souhaitez créer un projet autonome qui ne nécessite pas d’ordinateur, il peut être intéressant de savoir comment afficher les lectures de température sur un écran LCD.

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

La connexion de l’écran LCD I2C est très simple 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 écran LCD I2C avec Arduino

Si vous souhaitez utiliser un écran LCD non I2C standard à la place, consultez cet article:

  • Comment utiliser un écran LCD 16 × 2 caractères avec Arduino
1 DS18B20 digital temperature sensor with Arduino and I2C LCD display wiring diagram schematic circuit tutorial 1
DS18B20 avec écran LCD I2C 16 × 2 caractères et Arduino

Les connexions sont également données dans le tableau ci-dessous:

Connexions LCD I2C

Ecran LCD à caractères I2CArduino
GNDGND
VCC5 V
SDAA4
SCLA5

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

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

Installing the LiquidCrystal I2C Arduino library
Installation de la bibliothèque Arduino LiquidCrystal_I2C

DS18B20 avec exemple de code LCD I2C

/ * Capteur de température numérique 1 fil DS18B20 avec écran LCD 16×2 I2C et exemple de code Arduino. Plus d’infos: https://www.makerguides.com * /
// Include the required Arduino libraries:
#include <OneWire.h>
#include <DallasTemperature.h>
#include <LiquidCrystal_I2C.h>
// Define to which pin of the Arduino the 1-Wire bus is connected:
#define ONE_WIRE_BUS 2
// Create a new instance of the oneWire class to communicate with any OneWire device:
OneWire oneWire(ONE_WIRE_BUS);
// Pass the oneWire reference to DallasTemperature library:
DallasTemperature sensors(&oneWire);
LiquidCrystal_I2C lcd(0x27, 16, 2);
// Degree symbol:
byte Degree[] = {
B00111,
B00101,
B00111,
B00000,
B00000,
B00000,
B00000,
B00000
};
void setup() {
// Start up the library:
sensors.begin();
// Start the LCD and turn on the backlight:
lcd.init();
lcd.backlight();
// Create a custom character:
lcd.createChar(0, Degree);
}
void loop() {
// Send the command for all devices on the bus to perform a temperature conversion:
sensors.requestTemperatures();
// Fetch the temperature in degrees Celsius for device index:
float tempC = sensors.getTempCByIndex(0); // the index 0 refers to the first device
// Print the temperature on the LCD;
lcd.setCursor(0,0);
lcd.print(“Temperature:”);
lcd.setCursor(0,1);
lcd.print(tempC);
lcd.write(0); // print the custom character
lcd.print(“C”);
// Wait 1 second:
retard ( 1000 ) ;
}

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

DS18B20-16x2-I2C-sortie 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 instructif. 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 prévoyez de construire (ou avez déjà construits) avec ces capteurs. Si vous avez des questions, des suggestions ou si vous pensez que des éléments manquent dans ce tutoriel,  veuillez laisser un commentaire ci-dessous .

    Laisser un commentaire

    Votre adresse e-mail ne sera pas publiée.

    Rejoindre la liste d'attente Nous vous informerons lorsque le produit arrivera en stock. Veuillez laisser votre adresse E-mail et la quantité voulue.

    Main Menu

    بحاجة الى مساعدة ؟