Sensore di temperatura DS18B20 con Arduino, ESP32 e Pico

Il DS18B20 è un sensore di temperatura digitale e uno dei modi più precisi e flessibili per misurare la temperatura con Arduino. Misura da −55 °C a +125 °C, offre una precisione di ±0,5 °C tra −10 °C e +85 °C e invia il risultato come numero digitale anziché come tensione analogica, quindi la lettura non si degrada nemmeno con cavi lunghi. Il suo asso nella manica è la comunicazione 1-Wire: puoi collegare decine di DS18B20 a un unico pin dati e leggerli uno per uno grazie al loro indirizzo univoco.

In questo articolo scoprirai come funziona il DS18B20, la logica del bus 1-Wire, perché serve sempre una resistenza di pull-up da 4,7 kΩ, la versione con sonda impermeabile e i colori dei suoi fili. Poi vedremo passo passo il codice per uno e per più sensori con le librerie OneWire e DallasTemperature, la lettura non bloccante sull'ESP32 e l'uso con MicroPython sul Raspberry Pi Pico. Alla fine troverai cause e soluzioni dei frequenti errori −127 °C e 85 °C.

Cos'è il DS18B20 e come funziona?

Dentro il DS18B20 ci sono un elemento sensibile alla temperatura, un convertitore analogico-digitale, una piccola memoria (scratchpad) e un numero di serie univoco a 64 bit scritto in fabbrica. Quando il microcontrollore invia il comando di misura, il sensore misura la temperatura, scrive il risultato in memoria come numero a due byte e aspetta di essere letto. Dato che la misura la fa il sensore stesso, non ci sono errori dovuti all'ingresso analogico di Arduino, alla sua tensione di riferimento o alla resistenza del cavo. A differenza di un termistore NTC, non servono nemmeno tabelle di calibrazione o formule: il valore letto è direttamente in gradi Celsius.

La risoluzione del sensore si sceglie via software. Più è alta, più il passo è fine, ma più si allunga il tempo di conversione. Il valore predefinito è 12 bit, la scelta giusta per la maggior parte dei progetti; se ti servono letture molto rapide puoi scendere a 9 o 10 bit.

Cos'è l'1-Wire? Comunicare su un solo filo

Come dice il nome, l'1-Wire è un protocollo che trasporta i dati su una sola linea, con la massa (GND) in comune. Sul bus ci sono un master (Arduino) e uno o più slave (i DS18B20). Quando il bus è libero, una resistenza di pull-up lo tiene a livello HIGH. Chi vuole parlare porta la linea a LOW per brevi istanti; i bit sono codificati nella durata di questi impulsi LOW, dell'ordine dei microsecondi. Ogni comunicazione inizia con un impulso di reset e i sensori rispondono con un impulso di presenza che significa «ci sono».

Poiché nessun dispositivo forza la linea a HIGH (struttura open-drain), puoi mettere sullo stesso bus tutti i sensori che vuoi senza conflitti. Il master trova prima tutti gli indirizzi a 64 bit del bus con un comando di ricerca, poi seleziona tramite l'indirizzo il sensore che gli interessa e comunica con lui. Così, per misurare la temperatura in cinque punti diversi, usi un solo pin invece di cinque.

DS18B20, DHT11, DHT22 e NTC a confronto

In breve, se devi misurare anche l'umidità, il DHT11 o il DHT22 è la scelta giusta. Se vuoi misurare la temperatura dell'acqua, del terreno, di un tubo o di un congelatore, controllare più punti con un solo pin o lavorare sotto zero, il DS18B20 non ha rivali.

Piedinatura del DS18B20 e colori dei fili

Collegamento del DS18B20: Arduino Uno, ESP32 e Pico

La resistenza di pull-up è indispensabile in questo circuito. I dispositivi sul bus 1-Wire possono solo portare la linea a LOW; è questa resistenza a riportarla a HIGH. Senza di essa la linea resta fluttuante, il sensore non viene trovato e la libreria restituisce −127 °C. Un valore di 4,7 kΩ alza la linea abbastanza in fretta mantenendo bassa la corrente: con la linea a LOW, per la legge di Ohm scorrono I = 5 V / 4700 Ω ≈ 1,06 mA. I colori di una resistenza da 4,7 kΩ a quattro fasce sono giallo, viola, rosso e oro; per esserne sicuro usa lo strumento del codice colori. Alcuni moduli DS18B20 (il sensore su una schedina con resistenza e LED) hanno già questa resistenza montata; in quel caso non serve aggiungerne un'altra.

Installare le librerie

1. Nell'Arduino IDE apri Strumenti > Gestione librerie.
2. Scrivi DallasTemperature nella casella di ricerca e installa la libreria di Miles Burton.
3. Quando ti vengono proposte le dipendenze, scegli Install all così viene installata anche la libreria OneWire di Paul Stoffregen. Se non te lo chiede, cerca OneWire e installala a parte.
4. Se vuoi, apri File > Esempi > DallasTemperature > Simple, cambia il numero di pin in base al tuo circuito e provalo.

Primo sketch: leggere 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}

Con il monitor seriale a 9600 baud vedrai ogni secondo una riga come «Sicaklik / Temperature: 23.44 C». Noterai che le ultime cifre cambiano in multipli di 0,0625, il passo della risoluzione a 12 bit. Se tieni il sensore tra le dita, la temperatura dovrebbe salire in pochi secondi. Se il monitor seriale mostra −127, il sensore non viene trovato affatto; se mostra 85, il sensore è stato trovato ma letto prima della fine della misura. La soluzione per entrambi i casi è nella tabella alla fine dell'articolo.

Più DS18B20 sullo stesso pin

Per collegare più sensori basta mettere in parallelo tutti i loro pin VDD, GND e DQ; per tutto il bus si usa una sola resistenza di pull-up da 4,7 kΩ. Leggere con getTempCByIndex() è comodo, ma l'ordine dipende dagli indirizzi dei sensori, non dall'ordine in cui li hai collegati. Se sostituisci un sensore, l'ordine può cambiare. Per questo nei progetti permanenti conviene leggere ogni sensore tramite il suo indirizzo. Lo sketch qui sotto trova tutti i sensori del bus, ne stampa gli indirizzi e legge la temperatura di ciascuno tramite l'indirizzo:

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}

Esegui lo sketch una volta e scalda i sensori uno alla volta (per esempio tenendoli in mano) per capire quale indirizzo corrisponde a quale punto. Poi scrivi nel codice l'indirizzo che hai visto nel monitor seriale: aggiungi una riga come DeviceAddress sensoreAcqua = {0x28, 0xFF, 0x64, 0x1E, 0x0F, 0x16, 0x03, 0x90}; e leggila con sensors.getTempC(sensoreAcqua). Nel DS18B20 il primo byte dell'indirizzo è sempre 0x28, mentre l'ultimo è un CRC che verifica la validità dell'indirizzo. Così, qualunque sia l'ordine dei sensori, i valori di «acqua», «esterno» o «caldaia» arrivano sempre dal punto giusto.

DS18B20 con ESP32: lettura senza bloccare il programma

Il DS18B20 funziona sull'ESP32 con le stesse librerie OneWire e DallasTemperature. Per la linea dati il GPIO 4 è una buona scelta. Non usare i GPIO 34–39, perché sono solo ingressi e non possono portare a LOW la linea 1-Wire; evita anche i GPIO 0, 2, 12 e 15, il cui livello conta all'avvio. Collega sempre il sensore e la resistenza di pull-up al 3V3: se colleghi la pull-up a 5 V, applichi 5 V a un pin dell'ESP32.

Per impostazione predefinita, requestTemperatures() aspetta 750 ms a 12 bit. In quel tempo la scheda non può fare nient'altro: il web server, i pulsanti o il display si bloccano. La soluzione è disattivare l'attesa con setWaitForConversion(false) e leggere il risultato 750 ms dopo usando millis(). Nello sketch per ESP32 qui sotto, il LED continua a lampeggiare in modo fluido anche mentre si misura la temperatura:

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}

Questo schema è particolarmente importante nei progetti Wi-Fi: l'ESP32 può misurare la temperatura mentre serve una pagina web, invia dati su internet o aggiorna un display. Se l'ESP32 è nuovo per te, leggi Cos'è l'ESP32? per la scelta dei pin e la configurazione; la mappa dei pin della tua scheda è nello strumento Pinout.

DS18B20 con Raspberry Pi Pico e MicroPython

I moduli onewire e ds18x20 sono già inclusi in MicroPython per il Raspberry Pi Pico, quindi non devi caricare nessun file in più. Collega il sensore a 3V3(OUT) e GND, la linea dati a GP22, e non dimenticare la pull-up da 4,7 kΩ tra DQ e 3V3. Le resistenze di pull-up interne del Pico sono troppo deboli per l'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() restituisce l'elenco degli indirizzi a 8 byte di tutti i sensori del bus. convert_temp() invia il comando di misura a tutti i sensori contemporaneamente, per questo subito dopo bisogna aspettare 750 ms. read_temp(rom) legge in gradi Celsius la temperatura del sensore con quell'indirizzo. Se l'elenco è vuoto, controlla per prima cosa la resistenza di pull-up e il numero di pin. Se il Pico è nuovo per te, leggi Cos'è il Raspberry Pi Pico? per installare MicroPython.

La sonda impermeabile DS18B20

La forma più diffusa del DS18B20 è la sonda impermeabile, in cui il chip è inserito in un tubo di acciaio inox e sigillato con resina. Di solito ha una punta di 6 mm di diametro e 50 mm di lunghezza e un cavo a tre fili da 1 metro (esistono anche versioni da 2, 3 e 5 metri). È ideale per acquari, serbatoi d'acqua, scaldabagni, terreno, frigoriferi e congelatori. Puoi immergere brevemente la punta d'acciaio nell'acqua bollente, ma poiché il cavo è quasi sempre in PVC, non tenere a lungo il cavo e la giunzione sopra gli 85–100 °C. L'involucro della sonda rallenta il passaggio del calore verso il sensore, quindi dopo un brusco cambio di temperatura la lettura può impiegare da qualche secondo a qualche decina di secondi per stabilizzarsi.

Sul mercato ci sono molte copie del DS18B20. Alcune non raggiungono la precisione dichiarata o non funzionano in modalità di alimentazione parassita. Immergere due sensori nello stesso bicchiere d'acqua e confrontarne le letture è un modo semplice per capire se il tuo è affidabile. Se differiscono di più di 0,5 °C, puoi applicare nel codice un piccolo valore di correzione (offset).

Idee di progetto con il DS18B20

• Termostato per acquario: Accendi e spegni un riscaldatore con la sonda impermeabile e un modulo relè; con l'isteresi mantieni l'acqua tra 25 e 26 °C.
• Monitoraggio della temperatura in più punti: Collega cinque sensori a un pin e controlla insieme stanza, esterno, frigorifero e mandata e ritorno della caldaia.
• Termometro OLED: Mostra la temperatura con cifre grandi su un display OLED, insieme alla minima e alla massima del giorno.
• Indicatore di temperatura con LCD: Scrivi le letture di due sensori sulle due righe di un display LCD I2C.
• Pagina web della temperatura via Wi-Fi: Segui in diretta la temperatura misurata da un ESP32 su una pagina web aperta dal telefono.
• Controllo della serra: Misura la temperatura del terreno con un DS18B20 e l'umidità con un sensore di umidità del terreno per decidere quando irrigare.

Problemi frequenti e soluzioni

Grazie alla sua robustezza, alla sonda impermeabile e alla possibilità di collegare molti sensori a un solo pin, il DS18B20 è uno dei sensori di temperatura più utili nell'elettronica amatoriale. Puoi mostrare la temperatura su un display, comandare un riscaldatore o una ventola con un relè, oppure portarla su internet con un ESP32. Nell'app BlueGrays trovi progetti di misura della temperatura con DHT11 e NTC, display LCD I2C, un registratore di temperatura con ESP32 e un'irrigazione intelligente per Arduino ed ESP32, con schemi di collegamento e codice passo passo.