Ce tutoriel inclut tout ce que vous devez savoir sur l’utilisation de DS18B20 capteurs de température numériques 1-Wire avec Arduino.
Pour ce tutoriel, nous utiliserons la bibliothèque DallasTemperature en combinaison avec la bibliothèque OneWire Arduino. Ces bibliothèques facilitent grandement 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 vous montrerai comment prendre des mesures de température avec 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 vous montrerai comment afficher la température sur un I2C LCD.
Fournitures
Composants matériels
| DS18B20 digital temperature sensor (TO-92) | × 3 | Amazon |
| Waterproof DS18B20 (alternative) | × 1 | Amazon |
| DS18B20 breakout board (alternative) | × 1 | Amazon |
| Arduino Uno | × 1 | Amazon |
| Breadboard | × 1 | Amazon |
| Jumper wires | ~ 15 | Amazon |
| 4.7 kΩ pull-up resistor | × 1 | Amazon |
| 16×2 character I2C LCD | × 1 | Amazon |
| USB cable type A/B | × 1 | Amazon |
Logiciel
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
À propos du capteur de température 1-Wire 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é, offrant une précision assez élevée (±0,5 °C) sur une large plage de températures (-55 °C à +125 °C). Comme la tension d’alimentation du capteur est de 3,0 à 5,5 V, vous pouvez l’utiliser aussi bien avec l’Arduino (qui fonctionne en 5 V) qu’avec des appareils comme l’ESP32 ou le Raspberry Pi qui ont des broches GPIO en 3,3 V.
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 manière similaire à l’I2C, mais avec des débits de données plus faibles et une portée plus longue.
Un autre avantage est que chaque capteur DS18B20 possède un code série unique de 64 bits, ce qui permet à plusieurs capteurs de fonctionner sur le même bus 1-Wire. Vous pouvez donc lire les données de plusieurs capteurs connectés ensemble avec une seule broche Arduino (voir les exemples de code ci-dessous).
La résolution du capteur peut être réglée par programmation à 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 au démarrage est de 12 bits.
Vous trouverez plus de spécifications dans le tableau ci-dessous.
Spécifications du capteur de température numérique DS18B20
| Tension d’alimentation | 3,0 à 5,5 V |
| Courant en veille | 1 μA |
| Courant actif | 1,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ésolution | 9 bits à 12 bits (programmable) |
| Temps de conversion | < 750 ms (résolution 12 bits) |
| Protocole de communication | Protocole bus 1-Wire® |
| Boîtier | TO-92 3 broches |
| Fabricant | Maxim Integrated |
| Coût | Check price |
Pour plus d’informations, vous pouvez aussi consulter la fiche technique ici :
Types de capteurs DS18B20
Le capteur se présente généralement sous trois formes. Le type le plus courant est le 3-pin TO-92 boîtier, qui ressemble à un transistor.
Ce type de capteur est parfois monté sur une breakout board qui peut inclure une LED d’alimentation et la résistance de tirage de 4,7 kΩ requise. Veillez toujours à vérifier les marquages sur le PCB car l’ordre des broches peut varier selon le fabricant.
Enfin, vous pouvez acheter le capteur sous forme de sonde étanche avec un câble déjà attaché. Ce type est utile si vous souhaitez mesurer quelque chose à distance, sous l’eau ou sous terre.
Notez que le câble du capteur étanche est généralement gainé en PVC, il est donc recommandé de ne pas l’exposer à des températures supérieures à 100 °C.
Câblage – Connexion du DS18B20 à un Arduino
Connecter un DS18B20 à l’Arduino est assez simple car il suffit de connecter 3 broches. Commencez par connecter la broche GND à la masse et la broche V DD à la sortie 5 V de l’Arduino.
Ensuite, connectez la broche centrale (DQ) à n’importe quelle broche numérique de l’Arduino. Ici, j’ai utilisé la broche numérique 2. Il faut aussi ajouter une résistance de tirage de 4,7 kΩ entre la broche DQ et le 5 V. Cela maintient l’état au repos du bus 1-Wire à un niveau haut.
Les connexions sont aussi indiquées dans le tableau ci-dessous.
Notez que la broche 1 (GND) est la broche la plus à gauche lorsque la face plate du capteur (avec le texte imprimé) est tournée vers vous.
Connexions du capteur de température numérique DS18B20
| DS18B20 | Arduino |
|---|---|
| Broche 1 (GND) | GND |
| Broche 2 (DQ) | Broche 2 Arduino et via une résistance de 4,7 kΩ vers 5 V |
| Broche 3 (V DD ) | 5 V |
Un capteur DS18B20 étanche se connecte de la même manière. Cependant, la couleur des fils peut varier selon le fabricant. Le fil de masse (GND) est généralement noir ou bleu, le fil d’alimentation (VDD) est habituellement rouge, et le fil de signal (DQ) est souvent jaune ou blanc. Je recommande vivement de toujours vérifier la fiche technique de votre capteur si vous avez un doute.
Connexions du capteur de température numérique DS18B20 étanche
| DS18B20 étanche | Arduino |
|---|---|
| Fil noir (GND) | GND |
| Fil jaune (DQ) | Broche 2 Arduino et via une résistance de 4,7 kΩ vers 5 V |
| Fil rouge (V DD ) | 5 V |
Installation des bibliothèques DallasTemperature et OneWire Arduino
Le protocole de communication 1-Wire est assez complexe et nécessite beaucoup de code pour gérer la communication. C’est pourquoi nous utiliserons la Arduino-Temperature-Control-Library de Miles Burton pour faciliter la programmation de ces capteurs.
Pour installer la bibliothèque, allez dans Tools > Manage Libraries (Ctrl + Shift + I sous Windows) dans l’ Arduino IDE. Le gestionnaire de bibliothèques s’ouvrira et mettra à jour la liste des bibliothèques installées.
Vous pouvez chercher ‘ds18b20’ et trouver la bibliothèque DallasTemperature de Miles Burton. Sélectionnez la dernière version puis cliquez sur Install.
La bibliothèque DallasTemperature dépend de la OneWire Arduino library que vous devez aussi installer. Cette bibliothèque gère le protocole de communication 1-Wire.
Cherchez ‘onewire’ et trouvez la bibliothèque OneWire de Jim Studt.
Exemple de code Arduino pour capteur de température DS18B20
Avec l’exemple de code suivant, vous pouvez lire la température d’un capteur DS18B20 et l’afficher dans le Moniteur Série.
/* DS18B20 1-Wire digital temperature sensor with Arduino example code.
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:
DallasTemperature sensors(&oneWire);
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
// Start up the library:
sensors.begin();
}
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
// Fetch the temperature in degrees Fahrenheit for device index:
float tempF = sensors.getTempFByIndex(0);
// Print the temperature in Celsius in the Serial Monitor:
Serial.print("Temperature: ");
Serial.print(tempC);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.print("C | ");
// Print the temperature in Fahrenheit
Serial.print(tempF);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.println("F");
// Wait 1 second:
delay(1000);
}
Vous devriez voir la sortie suivante dans le Moniteur Série (Ctrl + Shift + M).
Assurez-vous que la vitesse de transmission du Moniteur Série est aussi réglée à 9600.
Comment fonctionne le code
La première étape est d’inclure les bibliothèques Arduino nécessaires :
// Include the required Arduino libraries: #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 permet de 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. Ainsi, partout où vous mentionnez ONE_WIRE_BUS, le compilateur la remplacera par la valeur 2 lors de la compilation.
// Define to which pin of the Arduino the 1-Wire bus is connected: #define ONE_WIRE_BUS 2
Après cela, j’ai créé un nouvel objet de la classe OneWire en passant la broche DQ à son constructeur. Vous devez aussi créer un objet de la classe DallasTemperature en passant l’objet oneWire en paramètre.
Notez que j’ai nommé l’objet DallasTemperature ‘sensors’, mais vous pouvez utiliser d’autres noms.
OneWire oneWire(ONE_WIRE_BUS); DallasTemperature sensors(&oneWire);
Dans la section setup du code, nous commençons la communication série à 9600 bauds. Ensuite, j’ai initialisé le bus avec la fonction begin().
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
// Start up the library:
sensors.begin();
}
Dans la section loop du code, on commence par la commande pour que tous les capteurs du bus lancent une conversion de température.
// Send the command for all devices on the bus to perform a temperature conversion: sensors.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. Ici, nous n’avons qu’un seul capteur connecté au bus. Comme le comptage commence à zéro, j’ai mis l’index de notre capteur à 0.
// Fetch the temperature in degrees Celsius for device index: float tempC = sensors.getTempCByIndex(0); // the index 0 refers to the first device // Fetch the temperature in degrees Fahrenheit for device index: float tempF = sensors.getTempFByIndex(0);
Enfin, les températures sont affichées dans le Moniteur Série :
// Print the temperature in Celsius in the Serial Monitor:
Serial.print("Temperature: ");
Serial.print(tempC);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.print("C | ");
// Print the temperature in Fahrenheit
Serial.print(tempF);
Serial.print(" \xC2\xB0"); // shows degree symbol
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 mentionné dans l’introduction, vous pouvez lire la température de plusieurs capteurs DS18B20 avec une seule broche Arduino. Vous trouverez ci-dessous deux exemples de code. 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’index 0, le second l’index 1, etc.
Dans le second exemple, je vous montrerai comment lire l’adresse unique 64 bits 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 reliées ensemble. Comme précédemment, les broches GND sont reliées à la masse, les broches V DD aux 5 V, et les broches DQ à la broche 2 de l’Arduino. N’oubliez pas la résistance de tirage de 4,7 kΩ entre la broche DQ et le 5 V.
Exemple de code Arduino pour plusieurs capteurs DS18B20
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.
/* Multiple DS18B20 1-Wire digital temperature sensors with Arduino example code. M
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:
DallasTemperature sensors(&oneWire);
int deviceCount = 0;
float tempC;
float tempF;
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
// Start up the library:
sensors.begin();
// Locate the devices on the bus:
Serial.println("Locating devices...");
Serial.print("Found ");
deviceCount = sensors.getDeviceCount();
Serial.print(deviceCount);
Serial.println(" devices");
}
void loop() {
// Send the command for all devices on the bus to perform a temperature conversion:
sensors.requestTemperatures();
// Display temperature from each sensor
for (int i = 0; i < deviceCount; i++) {
Serial.print("Sensor ");
Serial.print(i + 1);
Serial.print(" : ");
tempC = sensors.getTempCByIndex(i);
tempF = sensors.getTempFByIndex(i);
Serial.print(tempC);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.print("C | ");
Serial.print(tempF);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.println("F");
}
Serial.println();
delay(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 que précédemment.
Dans la section setup, j’ai ajouté une fonction supplémentaire qui compte le nombre d’appareils connectés au bus 1-Wire.
// Locate the devices on the bus:
Serial.println("Locating devices...");
Serial.print("Found ");
deviceCount = sensors.getDeviceCount();
Serial.print(deviceCount);
Serial.println(" devices");
Dans la section loop du code, j’ai utilisé une for loop pour parcourir une section de code qui récupère la température de chaque capteur connecté au bus par leur index.
// Display temperature from each sensor
for (int i = 0; i < deviceCount; i++) {
Serial.print("Sensor ");
Serial.print(i + 1);
Serial.print(" : ");
tempC = sensors.getTempCByIndex(i);
tempF = sensors.getTempFByIndex(i);
Serial.print(tempC);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.print("C | ");
Serial.print(tempF);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.println("F");
}
Lire les capteurs par adresse
Pour lire les capteurs par leur adresse individuelle, il faut d’abord connaître l’adresse de chaque capteur. Pour cela, vous pouvez utiliser l’exemple de sketch ci-dessous.
Le sketch affiche les adresses des capteurs connectés dans le Moniteur Série. Pour 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
/* Multiple DS18B20 1-Wire digital temperature sensors 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:
DallasTemperature sensors(&oneWire);
// Create variables:
int deviceCount = 0; // variable to store the number of devices connected
DeviceAddress deviceAddress; // variable to store the device address
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
// Start up the library:
sensors.begin();
// Locate the devices on the bus:
Serial.println("Locating devices...");
Serial.print("Found ");
deviceCount = sensors.getDeviceCount();
Serial.print(deviceCount);
Serial.println(" devices");
Serial.println("Printing addresses...");
for (int i = 0; i < deviceCount; i++) {
Serial.print("Sensor ");
Serial.print(i + 1);
Serial.print(" : ");
sensors.getAddress(deviceAddress, i);
printAddress(deviceAddress);
}
}
void loop() {
}
void printAddress(DeviceAddress deviceAddress) {
for (uint8_t i = 0; i < 8; i++) {
Serial.print("0x");
if (deviceAddress[i] < 0x10) {
Serial.print("0");
}
Serial.print(deviceAddress[i], HEX);
if (i < 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.
Exemple de code Arduino pour lire les capteurs par adresse
Avec l’exemple suivant, vous pouvez lire la température de chaque capteur en spécifiant son adresse unique.
/* Read multiple DS18B20 1-Wire digital temperature sensors by address.
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:
DallasTemperature sensors(&oneWire);
// Addresses of DS18B20 sensors connected to the 1-Wire bus
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() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
// Start up the library:
sensors.begin();
}
void loop() {
// Send the command for all devices on the bus to perform a temperature conversion:
sensors.requestTemperatures();
Serial.print("Sensor 1: ");
printTemperature(sensor1); // call the printTemperature function with the address of sensor1 as input
Serial.print("Sensor 2: ");
printTemperature(sensor2);
Serial.print("Sensor 3: ");
printTemperature(sensor3);
Serial.println(); // prints an empty line
delay(1000);
}
void printTemperature(DeviceAddress address) {
// Fetch the temperature in degrees Celsius for device address:
float tempC = sensors.getTempC(address);
// Fetch the temperature in degrees Fahrenheit for device address:
float tempF = sensors.getTempF(address);
Serial.print(tempC);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.print("C | ");
// Print the temperature in Fahrenheit
Serial.print(tempF);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.println("F");
}
Notez que vous devez remplacer les adresses aux lignes 17 à 19 par celles que vous avez trouvées avec l’exemple précédent.
// Addresses of DS18B20 sensors connected to the 1-Wire bus
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.
Explication du code
L’adresse de chaque capteur est composée de 64 bits. Dans le code, nous spécifions l’adresse comme un tableau de huit octets de 8 bits.
// Addresses of DS18B20 sensors connected to the 1-Wire bus
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 setup du code est la même que dans les exemples précédents.
Dans la boucle, nous appelons la fonction printTemperature(DeviceAddress address). 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(DeviceAddress address) {
// Fetch the temperature in degrees Celsius for device address:
float tempC = sensors.getTempC(address);
// Fetch the temperature in degrees Fahrenheit for device address:
float tempF = sensors.getTempF(tempC);
Serial.print(tempC);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.print("C | ");
// Print the temperature in Fahrenheit
Serial.print(tempF);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.println("F");
}
Autres fonctions de la bibliothèque DallasTemperature Arduino
La bibliothèque DallasTemperature inclut d’autres fonctions utiles que je n’ai pas encore couvertes dans les exemples ci-dessus. J’en ai listé quelques-unes ci-dessous :
setResolution()
Cette fonction permet de régler la résolution de la conversion température-numérique. Comme mentionné en introduction, elle peut être réglée à 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 changer la résolution, n’est-ce pas toujours mieux d’avoir la plus haute ? Un avantage de choisir une résolution plus basse 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.
D’après la fiche technique, voici les informations :
| Résolution | Incrément de température | Temps max de conversion |
|---|---|---|
| 9 bits | 0,5 °C | 93,75 ms |
| 10 bits | 0,25 °C | 187,5 ms |
| 11 bits | 0,125 °C | 375 ms |
| 12 bits | 0,0625 °C | 750 ms |
La bibliothèque DallasTemperature vous permet de régler la résolution avec la fonction setResolution(). Cette fonction peut être ajoutée dans la section setup ou loop de votre code.
Vous pouvez régler la résolution pour tous les capteurs connectés ainsi :
// Set the resolution for all devices to 9, 10, 11, or 12 bits: sensors.setResolution(9);
Ou vous pouvez la régler individuellement pour un capteur spécifique en précisant son adresse :
// Addresses of DS18B20 sensors connected to the 1-Wire bus
byte sensor1[8] = {0x28, 0x18, 0xB4, 0x49, 0x0C, 0x00, 0x00, 0x7C};
// Set the resolution of a specific device to 9, 10, 11, or 12 bits:
sensors.setResolution(sensor1, 9);
toFahrenheit()
Cette fonction permet de convertir la température en degrés Celsius en degrés Fahrenheit.
float tempC = sensors.getTempCbyIndex(0); float tempF = DallasTemperature::toFahrenheit(tempC);
setHighAlarmTemp() et setLowAlarmTemp()
Ces fonctions définissent les alarmes internes de température haute et basse pour un appareil en degrés Celsius.
bool hasAlarm()
Cette fonction retourne true lorsqu’un appareil est en condition d’alarme. Voir le sketch AlarmHandler.ino pour un exemple d’utilisation de cette fonction.
Afficher les mesures 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 mesures de température sur un écran LCD.
Avec l’exemple de code ci-dessous, vous pouvez afficher les mesures de température sur un écran LCD I2C 16×2 caractères.
Le câblage de l’écran LCD I2C est très simple comme vous pouvez le voir sur le schéma ci-dessous. Vous pouvez consulter mon tutoriel détaillé ci-dessous pour plus d’informations. How to control a character I2C LCD with Arduino. Si vous souhaitez utiliser un écran LCD standard non-I2C, consultez cet article : How to use a 16×2 character LCD with Arduino
Les connexions sont aussi indiquées dans le tableau ci-dessous :
Connexions écran LCD I2C
| Écran LCD caractère I2C | Arduino |
|---|---|
| GND | GND |
| VCC | 5 V |
| SDA | A4 |
| SCL | A5 |
Pour utiliser un écran LCD I2C, vous devez installer la bibliothèque LiquidCrystal_I2C Arduino.
Ouvrez le gestionnaire de bibliothèques dans l’IDE Arduino et cherchez ‘liquidcrystal_i2c’. Faites défiler et trouvez la bibliothèque de Frank de Brabander. Sélectionnez la dernière version puis cliquez sur Install.
Exemple de code DS18B20 avec écran LCD I2C
/* DS18B20 1-Wire digital temperature sensor with 16x2 I2C LCD and Arduino example code.
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:
delay(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 1-Wire DS18B20 avec Arduino. J’espère que vous l’avez trouvé utile et instructif.
Si vous souhaitez en savoir plus sur d’autres capteurs de température, consultez les articles ci-dessous.
- How to use DHT11 and DHT22 sensors with Arduino
- LM35 analog temperature sensor with Arduino tutorial
- TMP36 analog temperature sensor with Arduino tutorial
Si vous avez des questions, n’hésitez pas à laisser un commentaire ci-dessous.
