La guida completa per i sensori di temperatura digitali DS18B20 con Arduino

Questo tutorial include tutto ciò che devi sapere sull’uso di DS18B20 sensori di temperatura digitali 1-Wire con Arduino.

Per questo tutorial, useremo la libreria DallasTemperature in combinazione con la libreria OneWire per Arduino. Queste librerie rendono la comunicazione con uno o più sensori molto semplice. Nella prima parte di questo articolo, troverai le specifiche e le informazioni sui diversi tipi di sensori DS18B20. Successivamente, vedremo come collegare il sensore all’Arduino.

Nel primo esempio di codice, ti mostrerò come rilevare la temperatura da un singolo sensore e visualizzare il risultato nel Serial Monitor. Gli esempi successivi spiegano come leggere più sensori con un solo pin Arduino. Infine, ti mostrerò come visualizzare la temperatura su un I2C LCD.

Materiali

Componenti hardware

DS18B20 digital temperature sensor (TO-92)	× 3	Amazon
Waterproof DS18B20 (alternativo)	× 1	Amazon
DS18B20 breakout board (alternativo)	× 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

Software

Arduino IDE

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.

Informazioni sul sensore di temperatura 1-Wire DS18B20

Il DS18B20 è un sensore di temperatura digitale prodotto da Maxim Integrated (ex Dallas Semiconductor). È uno dei sensori di temperatura più popolari sul mercato e offre un’accuratezza abbastanza elevata (±0,5 °C) su un ampio intervallo di temperature (-55 °C a +125 °C). Poiché la tensione di alimentazione del sensore è da 3,0 a 5,5 V, può essere utilizzato sia con Arduino (che funziona a 5 V), sia con dispositivi come ESP32 e Raspberry Pi che hanno pin GPIO a 3,3 V.

Uno dei principali vantaggi di questo sensore è che richiede solo un pin digitale dell’Arduino per la comunicazione. Il sensore comunica usando il protocollo Dallas Semiconductor 1-Wire. Questo protocollo funziona in modo simile all’I2C, ma con velocità di trasmissione dati inferiori e portata maggiore.

Un altro vantaggio è che ogni sensore DS18B20 ha un codice seriale unico a 64 bit, che permette a più sensori di funzionare sullo stesso bus 1-Wire. Quindi puoi leggere i dati da più sensori collegati insieme usando un solo pin Arduino (vedi esempi di codice più avanti).

La risoluzione del sensore può essere impostata programmaticamente a 9, 10, 11 o 12 bit. Questo corrisponde a incrementi di temperatura di 0,5 °C, 0,25 °C, 0,125 °C e 0,0635 °C rispettivamente. La risoluzione predefinita all’accensione è 12 bit.

Puoi trovare ulteriori specifiche nella tabella qui sotto.

Specifiche del sensore di temperatura digitale DS18B20

Tensione di alimentazione	3,0 a 5,5 V
Corrente in standby	1 μA
Corrente attiva	1,5 mA
Intervallo di misura	-55 °C a +125 °C (-67 °F a +257 °F)
Precisione (Errore del termometro)	±0,5 °C da -10 °C a +85 °C ±1 °C da -30 °C a +100 °C ±2 °C da -55 °C a +125 °C
Risoluzione	Da 9 a 12 bit (programmabile)
Tempo di conversione	< 750 ms (risoluzione 12 bit)
Protocollo di comunicazione	Protocollo bus 1-Wire®
Package	TO-92 a 3 pin
Produttore	Maxim Integrated
Costo	Check price

Per maggiori informazioni, puoi consultare anche il datasheet qui:

Tipi di sensori DS18B20

Il sensore è solitamente disponibile in tre formati. Il tipo più comune è il 3-pin TO-92 package, che assomiglia a un transistor.

Questo tipo di sensore è talvolta montato su una breakout board scheda breakout che può includere un LED di alimentazione e la resistenza di pull-up da 4,7 kΩ necessaria. Assicurati sempre di controllare le marcature sulla PCB, poiché l’ordine dei pin può variare a seconda del produttore.

Infine, puoi acquistare il sensore in versione sonda impermeabile con cavo già collegato. Questo tipo è utile se vuoi misurare temperature a distanza, sott’acqua o sotto terra.

Nota che il cavo del sensore impermeabile è solitamente rivestito in PVC, quindi si consiglia di non superare i 100 °C.

Collegamenti – Collegare il DS18B20 a un Arduino

Collegare un DS18B20 all’Arduino è abbastanza semplice, poiché servono solo 3 pin. Inizia collegando il pin GND a massa e il pin V _DD al pin 5 V dell’Arduino.

Successivamente, collega il pin centrale (DQ) a uno qualsiasi dei pin digitali dell’Arduino. In questo caso ho usato il pin digitale 2. Devi anche aggiungere una resistenza di pull-up da 4,7 kΩ tra il pin DQ e 5 V. Questo mantiene lo stato di riposo del bus 1-Wire alto.

I collegamenti sono anche riportati nella tabella qui sotto.

Nota che il pin 1 (GND) è il pin più a sinistra quando il lato piatto del sensore (con la scritta) è rivolto verso di te.

Collegamenti del sensore di temperatura digitale DS18B20

DS18B20	Arduino
Pin 1 (GND)	GND
Pin 2 (DQ)	Pin 2 Arduino e tramite resistenza da 4,7 kΩ a 5V
Pin 3 (V DD )	5V

Un sensore DS18B20 impermeabile si collega allo stesso modo. Tuttavia, il colore dei fili può variare a seconda del produttore. Il filo di massa (GND) è solitamente nero o blu, il filo di alimentazione (VDD) è di solito rosso, e il filo del segnale (DQ) è spesso giallo o bianco. Ti consiglio vivamente di controllare sempre il datasheet del tuo sensore se non sei sicuro.

Collegamenti del sensore di temperatura digitale DS18B20 impermeabile

DS18B20 impermeabile	Arduino
Filo nero (GND)	GND
Filo giallo (DQ)	Pin 2 Arduino e tramite resistenza da 4,7 kΩ a 5V
Filo rosso (V DD )	5V

Installazione delle librerie DallasTemperature e OneWire per Arduino

Il protocollo di comunicazione 1-Wire è piuttosto complesso e richiede molto codice per gestire la comunicazione. Per questo useremo la libreria Arduino-Temperature-Control-Library di Miles Burton, che semplifica molto la programmazione di questi sensori.

Per installare la libreria, vai su Tools > Manage Libraries (Ctrl + Shift + I su Windows) nell’ Arduino IDE. Si aprirà il Library Manager che aggiornerà la lista delle librerie installate.

Puoi cercare ‘ds18b20’ e trovare la libreria DallasTemperature di Miles Burton. Seleziona l’ultima versione e clicca su Install.

La libreria DallasTemperature si basa sulla OneWire Arduino library che devi installare a parte. Questa libreria gestisce il protocollo di comunicazione 1-Wire.

Cerca ‘onewire’ e trova la libreria OneWire di Jim Studt.

Esempio di codice per sensore di temperatura DS18B20 con Arduino

Con il seguente esempio di codice puoi leggere la temperatura da un sensore DS18B20 e visualizzarla nel Serial Monitor.

/* 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);
}

Dovresti vedere il seguente output nel Serial Monitor (Ctrl + Shift + M).

Assicurati che la velocità di trasmissione del Serial Monitor sia impostata a 9600.

Come funziona il codice

Il primo passo è includere le librerie Arduino necessarie:

// Include the required Arduino libraries:
#include "OneWire.h"
#include "DallasTemperature.h"

Poi ho definito a quale pin dell’Arduino è collegato il pin DQ del sensore. L’istruzione #define serve per dare un nome a un valore costante. Il compilatore sostituirà tutte le occorrenze di questa costante con il valore definito durante la compilazione. Quindi ovunque menzioni ONE_WIRE_BUS, il compilatore lo sostituirà con il valore 2 durante la compilazione.

// Define to which pin of the Arduino the 1-Wire bus is connected:
#define ONE_WIRE_BUS 2

Dopodiché ho creato un nuovo oggetto della classe OneWire passando il pin DQ al suo costruttore. Devi anche creare un oggetto della classe DallasTemperature passando l’oggetto oneWire come parametro.

Nota che ho chiamato l’oggetto DallasTemperature ‘sensors’, ma puoi usare altri nomi.

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

Nella sezione setup del codice, iniziamo la comunicazione seriale a 9600 baud. Poi inizializzo il bus con la funzione begin().

void setup() {
  // Begin serial communication at a baud rate of 9600:
  Serial.begin(9600);
  // Start up the library:
  sensors.begin();
}

Nella sezione loop del codice, iniziamo con il comando per tutti i sensori sul bus di avviare una conversione di temperatura.

  // Send the command for all devices on the bus to perform a temperature conversion:
  sensors.requestTemperatures();

Poi ho usato le funzioni getTempCByIndex(deviceIndex) e getTempFByIndex(deviceIndex) per ottenere la temperatura in gradi Celsius e Fahrenheit rispettivamente. In questo caso abbiamo un solo sensore collegato al bus. Poiché la numerazione parte da zero, ho impostato l’indice del nostro sensore a 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);

Infine, le temperature vengono stampate nel Serial Monitor:

  // 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");

Poiché la conversione della temperatura in modalità 12 bit può richiedere fino a 750 ms, ho aggiunto un ritardo di un secondo tra ogni misura.

Uso di più sensori DS18B20 con Arduino

Come accennato nell’introduzione, puoi leggere la temperatura da più sensori DS18B20 usando un solo pin dell’Arduino. Qui sotto trovi due esempi di codice. Con il primo esempio puoi leggere la temperatura dai sensori collegati tramite il loro indice. Poiché tutti i sensori sono collegati allo stesso bus 1-Wire, il primo sensore ha indice 0, il secondo indice 1, e così via.

Nel secondo esempio ti mostrerò come leggere l’indirizzo unico a 64 bit di ogni sensore. Questo indirizzo può poi essere usato per leggere ogni sensore individualmente.

Collegamenti – Collegare più sensori DS18B20 all’Arduino

Collegare più sensori DS18B20 all’Arduino è semplice come collegarne uno solo. Tutti i sensori sono collegati in parallelo, cioè tutti i pin corrispondenti sono collegati insieme. Come prima, i pin GND sono collegati a massa, i pin V _DD a 5 V, e i pin DQ al pin 2 dell’Arduino. Non dimenticare la resistenza di pull-up da 4,7 kΩ tra il pin DQ e 5 V.

Esempio di codice per più sensori DS18B20 con Arduino

Con l’esempio qui sotto puoi leggere la temperatura di ogni sensore tramite il suo indice e visualizzarla nel Serial Monitor.

/* 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);
}

L’output nel Serial Monitor dovrebbe essere simile a questo:

Come funziona il codice

Il codice in questo esempio è per lo più uguale a prima.

Nella sezione setup, ho aggiunto una funzione che conta il numero di dispositivi collegati al 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");

Nella sezione loop del codice, ho usato un for loop per ciclare su una sezione di codice che legge la temperatura di ogni sensore collegato al bus tramite il loro indice.

  // 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");
  }

Leggere i sensori tramite indirizzo

Per leggere i sensori tramite il loro indirizzo individuale, dobbiamo prima conoscere l’indirizzo di ogni sensore. Per questo puoi usare lo sketch di esempio qui sotto.

Lo sketch stampa gli indirizzi dei sensori collegati nel Serial Monitor. Per sapere quale sensore è quale, puoi collegare un sensore alla volta o aggiungerli uno dopo l’altro. Poi puoi etichettare ogni sensore collegato al bus 1-Wire.

Ricerca indirizzo 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();
}

L’output nel Serial Monitor dovrebbe essere simile a questo:

Ora annota gli indirizzi di tutti i sensori, perché ti serviranno nel prossimo esempio.

Esempio di codice Arduino per leggere i sensori tramite indirizzo

Con il seguente esempio puoi leggere la temperatura di ogni sensore specificando il suo indirizzo unico.

/* 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");
}

Nota che devi sostituire gli indirizzi nelle righe 17-19 con quelli che hai trovato usando l’esempio precedente.

// 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};

Dovresti vedere il seguente output nel Serial Monitor.

Spiegazione del codice

L’indirizzo di ogni sensore è composto da 64 bit. Nel codice specifichiamo l’indirizzo come un array di otto byte da 8 bit.

// 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 sezione setup del codice è uguale agli esempi precedenti.

Nel loop chiamiamo la funzione printTemperature(DeviceAddress address). In questa funzione personalizzata usiamo getTempC(address) e getTempF(address) per leggere la temperatura da un sensore il cui indirizzo è passato come parametro.

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");
}

Altre funzioni della libreria DallasTemperature per Arduino

La libreria DallasTemperature include altre funzioni utili che non ho ancora trattato negli esempi sopra. Eccone alcune elencate qui sotto:

setResolution()

Questa funzione serve per impostare la risoluzione della conversione temperatura-digitale. Come detto in precedenza, può essere impostata a 9, 10, 11 o 12 bit, corrispondenti a incrementi di 0,5 °C, 0,25 °C, 0,125 °C e 0,0625 °C rispettivamente.

Potresti chiederti perché cambiare la risoluzione, non è sempre meglio quella più alta? Un vantaggio di scegliere una risoluzione più bassa è che la conversione temperatura-digitale richiede molto meno tempo. Questo significa che puoi effettuare più letture di temperatura nello stesso intervallo di tempo.

Dal datasheet ho ricavato le seguenti informazioni:

Risoluzione	Incremento temperatura	Tempo massimo di conversione
9 bit	0,5 °C	93,75 ms
10 bit	0,25 °C	187,5 ms
11 bit	0,125 °C	375 ms
12 bit	0,0625 °C	750 ms

La libreria DallasTemperature ti permette di impostare la risoluzione con la funzione setResolution(). Questa funzione può essere inserita nella sezione setup o loop del tuo codice.

Puoi impostare la risoluzione per tutti i sensori collegati così:

// Set the resolution for all devices to 9, 10, 11, or 12 bits:
sensors.setResolution(9);

Oppure impostarla individualmente per un sensore specifico specificandone l’indirizzo:

// 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()

Questa funzione converte la temperatura da gradi Celsius a Fahrenheit.

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

setHighAlarmTemp() e setLowAlarmTemp()

Queste funzioni impostano gli allarmi interni di temperatura alta e bassa per un dispositivo in gradi Celsius.

bool hasAlarm()

Questa funzione restituisce true quando un dispositivo ha una condizione di allarme. Vedi lo sketch AlarmHandler.ino per un esempio di utilizzo di questa funzione.

Visualizzare le letture di temperatura DS18B20 su un LCD I2C

Se vuoi realizzare un progetto standalone che non richiede un computer, può essere utile sapere come visualizzare le letture di temperatura su un display LCD.

Con l’esempio di codice qui sotto puoi visualizzare le letture di temperatura su un LCD I2C 16×2 caratteri.

Collegare l’LCD I2C è molto semplice come mostrato nello schema di collegamento qui sotto. Puoi consultare il mio tutorial dettagliato per maggiori informazioni. How to control a character I2C LCD with Arduino. Se vuoi usare un LCD standard non-I2C, dai un’occhiata a questo articolo: How to use a 16×2 character LCD with Arduino

I collegamenti sono anche riportati nella tabella qui sotto:

Collegamenti LCD I2C

LCD caratteri I2C	Arduino
GND	GND
VCC	5 V
SDA	A4
SCL	A5

Per usare un LCD I2C, devi installare la libreria LiquidCrystal_I2C per Arduino.

Apri il library manager nell’IDE Arduino e cerca ‘liquidcrystal_i2c’. Scorri fino a trovare la libreria di Frank de Brabander. Seleziona l’ultima versione e clicca su Install.

Esempio di codice DS18B20 con 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);
}

Dovresti vedere il seguente output sul display LCD:

Conclusione

In questo tutorial ti ho mostrato come usare i sensori di temperatura digitali DS18B20 1-Wire con Arduino. Spero che ti sia stato utile e informativo.

Se vuoi saperne di più su altri sensori di temperatura, dai un’occhiata agli articoli qui sotto.

• How to use DHT11 and DHT22 sensors with Arduino
• LM35 analog temperature sensor with Arduino tutorial
• TMP36 analog temperature sensor with Arduino tutorial

Se hai domande, lascia un commento qui sotto.