Capteur de température DS18B20 avec Arduino, ESP32 et Pico

Le DS18B20 est un capteur de température numérique et l'un des moyens les plus précis et les plus souples de mesurer une température avec un Arduino. Il mesure de −55 °C à +125 °C, offre une précision de ±0,5 °C entre −10 °C et +85 °C et transmet le résultat sous forme de nombre numérique plutôt que de tension analogique : la mesure ne se dégrade donc pas, même sur de longs câbles. Son grand atout est la communication 1-Wire : tu peux brancher des dizaines de DS18B20 sur une seule broche de données et lire chacun séparément grâce à son adresse unique.

Dans cet article, tu vas découvrir comment fonctionne le DS18B20, la logique du bus 1-Wire, pourquoi il lui faut toujours une résistance de pull-up de 4,7 kΩ, la version sonde étanche et les couleurs de ses fils. Ensuite, nous verrons pas à pas le code pour un seul et pour plusieurs capteurs avec les bibliothèques OneWire et DallasTemperature, la lecture non bloquante sur l'ESP32 et l'utilisation en MicroPython sur le Raspberry Pi Pico. À la fin, tu trouveras les causes et les solutions des erreurs courantes −127 °C et 85 °C.

Qu'est-ce que le DS18B20 et comment fonctionne-t-il ?

Le DS18B20 contient un élément sensible à la température, un convertisseur analogique-numérique, une petite mémoire (le scratchpad) et un numéro de série unique de 64 bits gravé en usine. Quand le microcontrôleur envoie la commande de mesure, le capteur mesure la température, écrit le résultat dans sa mémoire sous forme d'un nombre de deux octets et attend d'être lu. Comme c'est le capteur lui-même qui mesure, il n'y a aucune erreur liée à l'entrée analogique de l'Arduino, à sa tension de référence ou à la résistance du câble. Contrairement à une thermistance CTN, tu n'as pas besoin de table d'étalonnage ni de formule : la valeur lue est directement en degrés Celsius.

Tu peux choisir la résolution du capteur par logiciel. Plus la résolution est élevée, plus le pas est fin, mais plus le temps de conversion s'allonge. Par défaut, elle est de 12 bits, le bon choix pour la plupart des projets ; si tu as besoin de mesures très rapides, tu peux descendre à 9 ou 10 bits.

Qu'est-ce que le 1-Wire ? Communiquer sur un seul fil

Comme son nom l'indique, le 1-Wire est un protocole qui transporte les données sur une seule ligne, la masse (GND) étant commune. Sur le bus se trouvent un maître (l'Arduino) et un ou plusieurs esclaves (les DS18B20). Quand le bus est au repos, une résistance de pull-up le maintient à l'état HIGH. Celui qui veut parler tire la ligne à LOW pendant de brefs instants ; les bits sont codés par la durée de ces impulsions LOW, de l'ordre de la microseconde. Chaque échange commence par une impulsion de reset, et les capteurs répondent par une impulsion de présence qui signifie « je suis là ».

Comme aucun appareil ne force la ligne à HIGH (structure à drain ouvert), tu peux mettre autant de capteurs que tu veux sur le même bus sans conflit. Le maître commence par trouver toutes les adresses de 64 bits du bus grâce à une commande de recherche, puis il sélectionne le capteur voulu par son adresse et dialogue avec lui. Ainsi, pour mesurer la température en cinq endroits différents, tu n'utilises pas cinq broches mais une seule.

DS18B20, DHT11, DHT22 et CTN : comparatif

En résumé, si tu dois aussi mesurer l'humidité, le DHT11 ou le DHT22 est le bon choix. Si tu veux mesurer la température de l'eau, du sol, d'un tuyau ou d'un congélateur, surveiller plusieurs points avec une seule broche ou travailler sous zéro, le DS18B20 est imbattable.

Brochage du DS18B20 et couleurs des fils

Câblage du DS18B20 : Arduino Uno, ESP32 et Pico

La résistance de pull-up est indispensable dans ce montage. Les appareils d'un bus 1-Wire ne peuvent que tirer la ligne à LOW ; c'est cette résistance qui la ramène à HIGH. Sans elle, la ligne reste flottante, le capteur n'est pas détecté et la bibliothèque renvoie −127 °C. Une valeur de 4,7 kΩ remonte la ligne assez vite tout en limitant le courant : quand la ligne est à LOW, la loi d'Ohm donne I = 5 V / 4700 Ω ≈ 1,06 mA. Les couleurs d'une résistance de 4,7 kΩ à quatre anneaux sont jaune, violet, rouge et or ; pour en être sûr, utilise l'outil du code couleur. Certains modules DS18B20 (le capteur sur une petite carte avec résistance et LED) ont déjà cette résistance ; dans ce cas, inutile d'en ajouter une.

Installer les bibliothèques

1. Dans l'Arduino IDE, ouvre Outils > Gérer les bibliothèques.
2. Tape DallasTemperature dans la zone de recherche et installe la bibliothèque de Miles Burton.
3. Quand les dépendances te sont proposées, choisis Install all pour installer aussi la bibliothèque OneWire de Paul Stoffregen. Si rien ne t'est demandé, cherche OneWire et installe-la séparément.
4. Si tu veux, ouvre Fichier > Exemples > DallasTemperature > Simple, adapte le numéro de broche à ton montage et essaie-le.

Premier programme : lire un DS18B20

1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4#define ONE_WIRE_BUS 2                    // DS18B20 veri pini (DQ) / data pin (DQ)
5
6OneWire oneWire(ONE_WIRE_BUS);            // 1-Wire hattı / 1-Wire bus
7DallasTemperature sensors(&oneWire);      // sensör kütüphanesi / sensor library
8
9void setup() {
10  Serial.begin(9600);
11  sensors.begin();                        // hattaki sensörleri bul / find sensors on the bus
12  Serial.print(F("Sensor sayisi / Sensor count: "));
13  Serial.println(sensors.getDeviceCount());
14}
15
16void loop() {
17  sensors.requestTemperatures();          // ölçümü başlat, bitmesini bekle / start conversion and wait
18  float tempC = sensors.getTempCByIndex(0);  // ilk sensörün sıcaklığı / first sensor's temperature
19
20  if (tempC == DEVICE_DISCONNECTED_C) {   // -127: sensör yanıt vermedi / sensor did not respond
21    Serial.println(F("Hata: sensor yok / Error: no sensor"));
22  } else {
23    Serial.print(F("Sicaklik / Temperature: "));
24    Serial.print(tempC, 2);
25    Serial.println(F(" C"));
26  }
27  delay(1000);
28}

Avec le moniteur série réglé sur 9600 bauds, tu verras chaque seconde une ligne comme « Sicaklik / Temperature: 23.44 C ». Tu remarqueras que les derniers chiffres changent par multiples de 0,0625, le pas de la résolution 12 bits. Si tu tiens le capteur entre tes doigts, la température doit monter en quelques secondes. Si le moniteur série affiche −127, le capteur n'est pas trouvé du tout ; s'il affiche 85, le capteur a été trouvé mais lu avant la fin de la mesure. La solution de ces deux cas se trouve dans le tableau à la fin de l'article.

Plusieurs DS18B20 sur la même broche

Pour brancher plusieurs capteurs, il suffit de relier en parallèle toutes leurs broches VDD, GND et DQ ; tout le bus n'utilise qu'une seule résistance de pull-up de 4,7 kΩ. Lire avec getTempCByIndex() est pratique, mais l'ordre dépend des adresses des capteurs, pas de l'ordre dans lequel tu les as branchés. Si tu remplaces un capteur, l'ordre peut changer. C'est pourquoi, dans un projet durable, il vaut mieux lire chaque capteur par sa propre adresse. Le programme ci-dessous trouve tous les capteurs du bus, affiche leurs adresses et lit la température de chacun par son adresse :

1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4#define ONE_WIRE_BUS 2                    // tüm sensörler aynı pinde / all sensors on the same pin
5
6OneWire oneWire(ONE_WIRE_BUS);
7DallasTemperature sensors(&oneWire);
8DeviceAddress addr;                       // 8 baytlık sensör adresi / 8-byte sensor address
9int count = 0;
10
11void printAddress(const DeviceAddress a) {
12  for (uint8_t i = 0; i < 8; i++) {
13    Serial.print(F("0x"));
14    if (a[i] < 0x10) Serial.print('0');   // tek haneyi sıfırla tamamla / pad single digit
15    Serial.print(a[i], HEX);
16    if (i < 7) Serial.print(F(", "));
17  }
18}
19
20void setup() {
21  Serial.begin(9600);
22  sensors.begin();
23  count = sensors.getDeviceCount();       // hatta kaç sensör var? / how many sensors on the bus?
24  Serial.print(F("Sensor sayisi / Sensor count: "));
25  Serial.println(count);
26  sensors.setResolution(12);              // hepsi 12 bit (0,0625 C) / all 12-bit (0.0625 C)
27}
28
29void loop() {
30  sensors.requestTemperatures();          // tüm sensörler aynı anda ölçer / all sensors convert at once
31  for (int i = 0; i < count; i++) {
32    if (!sensors.getAddress(addr, i)) continue;   // adresi al / get the address
33    Serial.print(F("Sensor "));
34    Serial.print(i);
35    Serial.print(F(" { "));
36    printAddress(addr);
37    Serial.print(F(" }: "));
38    Serial.print(sensors.getTempC(addr), 2);      // adrese göre oku / read by address
39    Serial.println(F(" C"));
40  }
41  Serial.println();
42  delay(2000);
43}

Lance le programme une fois et réchauffe les capteurs l'un après l'autre (en les tenant dans ta main, par exemple) pour savoir quelle adresse correspond à quel endroit. Écris ensuite dans ton code l'adresse vue dans le moniteur série : ajoute une ligne comme DeviceAddress capteurEau = {0x28, 0xFF, 0x64, 0x1E, 0x0F, 0x16, 0x03, 0x90}; et lis-la avec sensors.getTempC(capteurEau). Sur un DS18B20, le premier octet de l'adresse vaut toujours 0x28 et le dernier est un CRC qui vérifie la validité de l'adresse. Ainsi, quel que soit l'ordre des capteurs, les valeurs « eau », « extérieur » ou « chaudière » proviennent toujours du bon endroit.

DS18B20 avec l'ESP32 : lecture non bloquante

Le DS18B20 fonctionne sur l'ESP32 avec les mêmes bibliothèques OneWire et DallasTemperature. Pour la ligne de données, le GPIO 4 est un bon choix. N'utilise pas les GPIO 34 à 39, qui ne sont que des entrées et ne peuvent pas tirer la ligne 1-Wire à LOW ; évite aussi les GPIO 0, 2, 12 et 15, dont le niveau compte au démarrage. Branche toujours le capteur et la résistance de pull-up sur 3V3 : si tu relies le pull-up au 5 V, tu appliques 5 V sur une broche de l'ESP32.

Par défaut, requestTemperatures() attend 750 ms en 12 bits. Pendant ce temps, la carte ne peut rien faire d'autre : le serveur web, les boutons ou l'écran se figent. La solution consiste à désactiver l'attente avec setWaitForConversion(false) et à lire le résultat 750 ms plus tard grâce à millis(). Dans le programme ESP32 ci-dessous, la LED continue de clignoter sans à-coups pendant la mesure de température :

1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4const int ONE_WIRE_PIN = 4;               // ESP32 GPIO 4 (DQ)
5const int LED_PIN = 2;                    // dahili LED (çoğu kartta) / onboard LED (most boards)
6
7OneWire oneWire(ONE_WIRE_PIN);
8DallasTemperature sensors(&oneWire);
9
10unsigned long requestTime = 0;
11unsigned long lastBlink = 0;
12bool converting = false;
13
14void setup() {
15  Serial.begin(115200);
16  pinMode(LED_PIN, OUTPUT);
17  sensors.begin();
18  sensors.setResolution(12);
19  sensors.setWaitForConversion(false);    // requestTemperatures() beklemesin / do not block
20}
21
22void loop() {
23  unsigned long now = millis();
24
25  if (!converting) {
26    sensors.requestTemperatures();        // ölçümü başlat, hemen dön / start and return at once
27    requestTime = now;
28    converting = true;
29  }
30
31  if (converting && now - requestTime >= 750) {   // 12 bit için 750 ms / 750 ms for 12-bit
32    float t = sensors.getTempCByIndex(0);
33    if (t == DEVICE_DISCONNECTED_C) {
34      Serial.println("Sensor yok / No sensor");
35    } else {
36      Serial.printf("Sicaklik / Temperature: %.2f C\n", t);
37    }
38    converting = false;                   // bir sonraki ölçüme geç / move to the next reading
39  }
40
41  if (now - lastBlink >= 250) {           // bu arada LED yanıp söner / meanwhile the LED blinks
42    lastBlink = now;
43    digitalWrite(LED_PIN, !digitalRead(LED_PIN));
44  }
45}

Ce modèle est particulièrement important dans les projets Wi-Fi : l'ESP32 peut mesurer la température tout en servant une page web, en envoyant des données sur internet ou en mettant à jour un écran. Si tu débutes avec l'ESP32, consulte Qu'est-ce que l'ESP32 ? pour le choix des broches et l'installation ; tu trouveras aussi le brochage de ta carte dans l'outil Pinout.

DS18B20 avec le Raspberry Pi Pico et MicroPython

Les modules onewire et ds18x20 sont intégrés à MicroPython sur le Raspberry Pi Pico : aucun fichier supplémentaire à téléverser. Branche le capteur sur 3V3(OUT) et GND, la ligne de données sur GP22, et n'oublie pas le pull-up de 4,7 kΩ entre DQ et 3V3. Les résistances de pull-up internes du Pico sont trop faibles pour le 1-Wire.

1from machine import Pin
2import onewire, ds18x20, time, binascii
3
4ds_pin = Pin(22)                                   # DQ -> GP22 (fiziksel pin 29 / physical pin 29)
5sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
6
7roms = sensor.scan()                               # hattaki sensör adresleri / sensor addresses on the bus
8print("Sensor sayisi / Sensor count:", len(roms))
9
10while True:
11    sensor.convert_temp()                          # hepsi aynı anda ölçer / all sensors convert at once
12    time.sleep_ms(750)                             # 12 bit dönüşüm süresi / 12-bit conversion time
13    for rom in roms:
14        t = sensor.read_temp(rom)                  # adrese göre oku / read by address
15        print(binascii.hexlify(rom).decode(), "{:.2f} C".format(t))
16    time.sleep(2)

scan() renvoie la liste des adresses de 8 octets de tous les capteurs du bus. convert_temp() envoie la commande de mesure à tous les capteurs en même temps, d'où l'attente de 750 ms qui suit. read_temp(rom) lit en degrés Celsius la température du capteur portant cette adresse. Si la liste est vide, vérifie d'abord la résistance de pull-up et le numéro de broche. Si tu découvres le Pico, consulte Qu'est-ce que le Raspberry Pi Pico ? pour installer MicroPython.

La sonde étanche DS18B20

La forme la plus répandue du DS18B20 est la sonde étanche, dans laquelle la puce est placée dans un tube en acier inoxydable puis scellée à la résine. Elle se compose généralement d'une pointe de 6 mm de diamètre et de 50 mm de long et d'un câble à trois fils de 1 mètre (il existe aussi des versions de 2, 3 et 5 mètres). Elle est idéale pour les aquariums, les cuves d'eau, les ballons d'eau chaude, le sol, les réfrigérateurs et les congélateurs. Tu peux plonger brièvement la pointe en acier dans l'eau bouillante, mais comme le câble est le plus souvent en PVC, ne laisse pas longtemps le câble et la jonction au-dessus de 85–100 °C. Le boîtier de la sonde ralentit le passage de la chaleur jusqu'au capteur : après un brusque changement de température, la mesure peut mettre de quelques secondes à quelques dizaines de secondes à se stabiliser.

On trouve beaucoup de copies du DS18B20 dans le commerce. Certaines n'atteignent pas la précision annoncée ou ne fonctionnent pas en mode d'alimentation parasite. Plonger deux capteurs dans le même verre d'eau et comparer leurs mesures est un moyen simple de savoir si le tien est fiable. S'ils diffèrent de plus de 0,5 °C, tu peux appliquer une petite valeur de correction (offset) dans ton code.

Idées de projets avec le DS18B20

• Thermostat d'aquarium : Allume et éteins un chauffage avec la sonde étanche et un module relais ; avec une hystérésis, garde l'eau entre 25 et 26 °C.
• Surveillance de température en plusieurs points : Branche cinq capteurs sur une broche et surveille en même temps la pièce, l'extérieur, le réfrigérateur ainsi que le départ et le retour de la chaudière.
• Thermomètre OLED : Affiche la température en gros chiffres sur un écran OLED, avec le minimum et le maximum de la journée.
• Afficheur de température LCD : Écris les mesures de deux capteurs sur les deux lignes d'un écran LCD I2C.
• Page web de température en Wi-Fi : Suis en direct la température mesurée par un ESP32 sur une page web ouverte depuis ton téléphone.
• Gestion de serre : Mesure la température du sol avec un DS18B20 et l'humidité avec un capteur d'humidité du sol pour décider quand arroser.

Problèmes fréquents et solutions

Grâce à sa robustesse, à sa sonde étanche et à la possibilité de mettre de nombreux capteurs sur une seule broche, le DS18B20 est l'un des capteurs de température les plus utiles en électronique de loisir. Tu peux afficher la température sur un écran, piloter un chauffage ou un ventilateur avec un relais, ou l'envoyer sur internet avec un ESP32. Dans l'application BlueGrays, tu trouveras des projets de mesure de température avec DHT11 et CTN, des écrans LCD I2C, un enregistreur de température ESP32 et un arrosage intelligent pour Arduino et ESP32, avec schémas de câblage et code pas à pas.