Sensori di temperatura per Arduino: confronto tra 8 modelli

Scegliere bene tra i vari sensori di temperatura per Arduino conta più di quanto sembri: un DHT11 e un DS18B20 nella stessa stanza possono differire di 2 °C, ed è del tutto possibile fondere un sensore cercando di misurare un forno a 300 °C con il modello sbagliato. Nell'elettronica hobbistica dominano otto sensori di temperatura: DHT11, DHT22, DS18B20, LM35, il termistore NTC, BME280, MAX6675 (termocoppia tipo K) e MLX90614 (a infrarossi, senza contatto). Ognuno ha un intervallo di misura, una precisione, un tipo di collegamento e un prezzo diversi. Quale sia quello giusto dipende da cosa devi misurare: l'aria di una stanza, l'acqua, un forno o un motore in rotazione che non puoi toccare?

In questa guida mettiamo gli otto sensori uno accanto all'altro in due grandi tabelle: intervallo di misura, precisione, risoluzione, velocità di lettura, interfaccia, tensione di alimentazione, lunghezza del cavo e prezzo relativo. Poi vedrai come funziona ciascuno, i suoi punti di forza e di debolezza, i collegamenti per Arduino Uno, ESP32 e Raspberry Pi Pico, codice di esempio per NTC, MAX6675 e MLX90614, un banco di prova che mette tre sensori in gara tra loro e quale scegliere per quale progetto. Per la maggior parte di questi sensori abbiamo anche tutorial dettagliati; trovi i link nelle sezioni corrispondenti.

Cosa guardare quando scegli un sensore di temperatura?

Prima di confrontare i sensori devi leggere correttamente i termini dei datasheet. La coppia che si confonde più spesso è precisione e risoluzione. La precisione indica quanto la tua lettura si avvicina alla temperatura reale; la risoluzione è il passo più piccolo che il sensore riesce a distinguere. Il BME280 fornisce la temperatura a passi di 0,01 °C, ma la sua precisione è di circa ±1 °C: le ultime due cifre dei 23,47 °C sul display servono quindi a seguire piccole variazioni, non a conoscere la temperatura reale con quella finezza. Per scegliere, guarda questi sette criteri:

• Intervallo di misura: il sensore deve coprire comodamente la temperatura più bassa e quella più alta che vuoi misurare. Il DHT11 non vede sotto lo zero; per un frigorifero serve un DS18B20, per un forno una termocoppia.
• Precisione: per un termometro da stanza ±2 °C va bene, ma un acquario o un'incubatrice richiedono ±0,5 °C.
• Interfaccia: i sensori analogici richiedono un pin dell'ADC, quelli digitali uno o più pin digitali e quasi sempre una libreria. Il numero di pin liberi sulla tua scheda decide quanti sensori puoi collegare.
• Lunghezza del cavo: se il sensore starà a 5 metri dalla scheda, in giardino o sul fondo di un serbatoio, i sensori analogici e I2C vanno in difficoltà; l'1-Wire e il protocollo a filo singolo dei DHT reggono molto meglio le lunghe distanze.
• Tempo di risposta: una sonda in una guaina d'acciaio o un DHT nel suo involucro di plastica colgono un cambio brusco di temperatura solo dopo secondi o addirittura minuti; un piccolo NTC nudo è molto più rapido.
• Misure aggiuntive: se ti serve anche l'umidità, basta un DHT22 o un BME280; se ti servono anche pressione e altitudine, il BME280 fa tutto in un solo modulo.
• Tensione di alimentazione: su ESP32 e Pico, che lavorano a 3,3 V, fai attenzione a sensori come l'LM35 che richiedono almeno 4 V, e assicurati che all'ingresso dell'ADC non arrivino mai più di 3,3 V.

Tabella di confronto di 8 sensori di temperatura

La prima tabella riassume le prestazioni di misura, la seconda collegamento e costi. I valori provengono dai datasheet; salvo diversa indicazione, la precisione vale intorno alla temperatura ambiente e peggiora verso gli estremi dell'intervallo.

DHT11 e DHT22: temperatura e umidità insieme

Dentro la griglia di plastica di un sensore DHT ci sono un elemento per l'umidità (resistivo nel DHT11, capacitivo nel DHT22), un termistore e un piccolo controller che digitalizza le misure. Il sensore invia il risultato su un'unica linea dati come pacchetto di 40 bit: 16 bit di umidità, 16 bit di temperatura e 8 bit di checksum. Questo protocollo non è 1-Wire ma un protocollo a filo singolo proprio del produttore; per questo ogni DHT richiede un pin dedicato. Il DHT11 è economico e basta per la temperatura di una stanza, ma l'intervallo di 0–50 °C e l'errore di ±2 °C lo rendono debole per l'esterno e per i lavori di precisione. Con gli stessi collegamenti, il DHT22 (AM2302) misura da −40 a +80 °C con ±0,5 °C di precisione e fornisce l'umidità dallo 0 al 100 %; in cambio fa solo una lettura ogni due secondi. Entrambi hanno un difetto comune, la lentezza: mostrano le variazioni in ritardo perché l'aria nella griglia deve prima mettersi in equilibrio con l'ambiente. Per collegamenti, installazione della libreria e codice, consulta Sensore di temperatura e umidità DHT11; lo stesso codice funziona con il DHT22 cambiando una sola parola.

DS18B20: impermeabile, robusto e molti sensori su un pin

Il DS18B20 misura la temperatura all'interno del chip e la invia come numero digitale con una risoluzione selezionabile da 9 a 12 bit. Misura da −55 a +125 °C, offre ±0,5 °C di precisione tra −10 e +85 °C e, grazie al protocollo 1-Wire, puoi collegare decine di sensori a un unico pin dati; ognuno ha un indirizzo univoco a 64 bit scritto in fabbrica. La versione a sonda impermeabile con guaina in acciaio inox è imbattibile per acquari, serbatoi d'acqua, tubi del riscaldamento, terreno e congelatori. L'unico requisito è una resistenza di pull-up da 4,7 kΩ tra linea dati e alimentazione; senza, la libreria restituisce −127 °C. In modalità 12 bit una conversione dura 750 ms, quindi per seguire una temperatura che cambia in fretta potresti dover ridurre la risoluzione. Il codice per più sensori e la lettura non bloccante su ESP32 sono in Sensore di temperatura DS18B20.

LM35: il sensore analogico più semplice, senza librerie

L'LM35 converte la temperatura direttamente in tensione: la sua uscita sale di 10 mV per grado e dà 250 mV a 25 °C. Non serve alcuna libreria; ottieni il risultato con la formula temperatura = analogRead × 5,0 / 1024 × 100. Questa semplicità ne fa un primo passo perfetto per imparare l'ADC. I suoi punti deboli nascono dallo stesso punto: con riferimento a 5 V, l'ADC a 10 bit di Arduino Uno dà solo passi di circa 0,49 °C, ogni scostamento dei 5 V della USB finisce direttamente nella temperatura e, più il cavo è lungo, più disturbi raccoglie l'uscita. La maggior parte degli LM35 in commercio sono LM35DZ, garantiti solo per 0–100 °C. Inoltre richiede almeno 4 V, quindi su ESP32 e Pico va alimentato dal pin a 5 V. Sulle schede a 3,3 V un'alternativa analogica più pratica è il TMP36: funziona da 2,7 a 5,5 V, misura da −40 a +125 °C e fornisce anch'esso 10 mV/°C, ma poiché dà 500 mV a 0 °C la formula diventa temperatura = (V − 0,5) × 100. La sua precisione tipica è di ±1 °C a 25 °C e di ±2 °C su tutto l'intervallo. Spieghiamo passo per passo come ridurre il passo a 0,11 °C con il riferimento interno da 1,1 V in Sensore di temperatura LM35, e come funziona l'ADC in conversione analogico-digitale.

Termistore NTC: il sensore più economico e più veloce

Un termistore NTC (Negative Temperature Coefficient, a coefficiente di temperatura negativo) è una resistenza il cui valore diminuisce all'aumentare della temperatura. Il più comune nei progetti hobbistici è quello da 10 kΩ a 25 °C con coefficiente B di 3950 K. Poiché Arduino non può misurare direttamente una resistenza, l'NTC si collega formando un partitore di tensione con una resistenza fissa e si legge la tensione del punto centrale su un pin analogico. Questo circuito ha un bel vantaggio: quando il partitore è alimentato dagli stessi 5 V usati come riferimento dall'ADC, la misura è raziometrica; il risultato non cambia anche se l'alimentazione è di 4,8 o 5,1 V. Puoi calcolare facilmente le tensioni del partitore con lo strumento partitore di tensione.

La resistenza di un NTC varia con la temperatura in modo esponenziale, non lineare, quindi non basta un semplice fattore come per l'LM35. In pratica si usa l'equazione Beta: 1/T = 1/T0 + (1/B) × ln(R/R0). Qui T è la temperatura in kelvin, T0 = 298,15 K (25 °C), R0 = 10 kΩ e B = 3950. A temperatura ambiente la sensibilità è molto alta: secondo la formula B/T², la resistenza cambia di circa il 4,4 % per grado. Per questo un NTC con tolleranza dell'1 % sbaglia solo di circa ±0,25 °C a 25 °C; verso gli estremi dell'intervallo, però, entra in gioco la tolleranza del coefficiente B e l'errore cresce. Per una precisione maggiore su un intervallo ampio si usa l'equazione di Steinhart-Hart a tre punti; i dettagli sono in termistore NTC.

1const int NTC_PIN = A1;          // bölücünün orta noktası / divider midpoint
2const float R_FIXED = 10000.0;   // 5V ile A1 arasındaki direnç / resistor between 5V and A1
3const float R0 = 10000.0;        // NTC'nin 25 °C'deki direnci / NTC resistance at 25 °C
4const float BETA = 3950.0;       // B katsayısı (veri sayfası) / B coefficient (datasheet)
5const float T0 = 298.15;         // 25 °C Kelvin cinsinden / 25 °C in kelvin
6const int SAMPLES = 16;          // ortalama için ölçüm sayısı / samples to average
7
8void setup() {
9  Serial.begin(9600);
10}
11
12void loop() {
13  long sum = 0;
14  for (int i = 0; i < SAMPLES; i++) {
15    sum += analogRead(NTC_PIN);
16    delay(2);
17  }
18  float adc = sum / (float)SAMPLES;
19
20  if (adc < 1.0 || adc > 1022.0) {                    // kopuk ya da kısa devre / open or shorted
21    Serial.println(F("NTC baglantisini kontrol et / Check the NTC wiring"));
22    delay(1000);
23    return;
24  }
25
26  float r = R_FIXED * adc / (1023.0 - adc);           // NTC direnci (ohm) / NTC resistance (ohm)
27  float invT = 1.0 / T0 + log(r / R0) / BETA;         // Beta denklemi / Beta equation
28  float tempC = 1.0 / invT - 273.15;                  // Kelvin -> °C
29
30  Serial.print(F("R: "));
31  Serial.print(r, 0);
32  Serial.print(F(" ohm  Sicaklik / Temp: "));
33  Serial.print(tempC, 1);
34  Serial.println(F(" C"));
35  delay(1000);
36}

In questo circuito la resistenza fissa da 10 kΩ sta tra 5V e A1, l'NTC tra A1 e GND. Quando la temperatura sale, la resistenza dell'NTC, e con essa la tensione su A1, scende. Il codice calcola prima la resistenza dell'NTC dal valore grezzo, poi la temperatura in kelvin con l'equazione Beta, e la converte in gradi Celsius; la media di 16 letture riduce il rumore dell'ADC a un quarto. A temperatura ambiente un passo dell'ADC di Uno corrisponde a circa 0,09 °C, quindi la risoluzione è cinque volte migliore di quella dell'LM35 con riferimento a 5 V. Nei moduli NTC già pronti (per esempio il KY-013) il lato in cui si trova la resistenza fissa cambia da scheda a scheda; se la lettura scende quando tocchi l'NTC con qualcosa di caldo, inverti la formula della resistenza: r = R_FIXED × (1023 − adc) / adc.

BME280: temperatura, umidità e pressione in un unico modulo

Il BME280 di Bosch misura temperatura, umidità relativa e pressione atmosferica su un chip di soli 2,5 × 2,5 mm e comunica via I2C (indirizzo 0x76 o 0x77) o SPI. Per la temperatura offre una risoluzione di 0,01 °C e una precisione di ±0,5 °C a 25 °C e di ±1 °C tra 0 e 65 °C; può fare decine di letture al secondo e in sospensione consuma molto meno di 1 µA. Per questo è ideale per le stazioni meteo a batteria. Il chip di per sé non sopporta più di 3,6 V: i moduli viola a 6 pin di solito sono solo a 3,3 V, mentre quelli a 4 pin con regolatore si possono collegare a 5 V. Quando misura di continuo, il chip si scalda un po' e può segnare qualche decimo di grado in più; per misure meteo basta la modalità forzata (forced) con poche letture al minuto. Spieghiamo come funziona il bus I2C in Cos'è l'I2C?.

MAX6675 e termocoppia tipo K: fino a 1000 °C

Una termocoppia è formata da due fili di metalli diversi saldati a un'estremità. La differenza di temperatura tra la saldatura (giunto caldo) e il punto in cui i fili si collegano allo strumento (giunto freddo) genera nei fili una tensione minuscola; in una termocoppia tipo K è di circa 41 µV per grado. L'ADC di Arduino non riesce a leggere una tensione così piccola, e inoltre bisogna conoscere la temperatura del giunto freddo. Il MAX6675 fa entrambe le cose: amplifica la tensione della termocoppia, applica la compensazione del giunto freddo misurando la propria temperatura e fornisce il risultato via SPI a 12 bit, con risoluzione di 0,25 °C. L'intervallo va da 0 a +1023,75 °C: è l'unica scelta di questa lista per i posti in cui gli altri sensori non sopravvivono, come saldatore, forno per pizza, barbecue, forno per ceramica o scarico.

Conosci anche i limiti del MAX6675: non misura sotto 0 °C; l'errore del convertitore è di circa ±2 °C tra 0 e 700 °C, e a questo si sommano fino a ±3 °C di errore della compensazione del giunto freddo e la tolleranza del filo della termocoppia. Aspettati quindi una precisione complessiva di qualche grado; in un forno a 800 °C questa differenza non conta. Una conversione dura 0,17–0,22 secondi, quindi tra due letture bisogna aspettare almeno 250 ms. Se ti servono anche temperature negative, il più recente MAX31855 (da −200 a +1350 °C, 14 bit) è la scelta migliore. Come funziona il bus SPI lo trovi in Cos'è l'SPI?. Installa la libreria MAX6675 library di Adafruit dal Gestore librerie dell'Arduino IDE e carica questo codice:

1#include "max6675.h"
2
3const int thermoDO  = 4;    // SO: veri çıkışı / data out
4const int thermoCS  = 5;    // CS: çip seçimi / chip select
5const int thermoCLK = 6;    // SCK: saat / clock
6
7MAX6675 thermocouple(thermoCLK, thermoCS, thermoDO);
8
9void setup() {
10  Serial.begin(9600);
11  delay(500);                                   // ilk ölçümü bekle / wait for the first conversion
12}
13
14void loop() {
15  float c = thermocouple.readCelsius();
16  if (isnan(c)) {                               // D2 biti: termokupl açık / bit D2: thermocouple open
17    Serial.println(F("Termokupl takili degil / Thermocouple not connected"));
18  } else {
19    Serial.print(F("Sicaklik / Temp: "));
20    Serial.print(c, 2);
21    Serial.println(F(" C"));
22  }
23  delay(500);                                   // en az 250 ms bekle / wait at least 250 ms
24}

MLX90614: misurare la temperatura senza contatto

L'MLX90614 è un sensore di temperatura senza contatto che rileva con una termopila la radiazione infrarossa emessa dagli oggetti. Fornisce due valori contemporaneamente: la temperatura ambiente, cioè quella del suo stesso corpo (da −40 a +125 °C), e la temperatura dell'oggetto, quella della superficie inquadrata (da −70 a +380 °C). Intorno alla temperatura ambiente offre ±0,5 °C di precisione e 0,02 °C di risoluzione; è calibrato in fabbrica, comunica via I2C (SMBus) all'indirizzo 0x5A e la velocità del bus non deve superare i 100 kHz. È ideale per misurare senza toccarli un motore in rotazione, un cuscinetto, un chip caldo su una scheda o una padella sul fuoco.

La misura senza contatto ha due accorgimenti. Il primo è il campo visivo: il sensore misura la media di tutto ciò che entra nel suo cono di visione. La versione più diffusa, l'MLX90614ESF-BAA, ha un campo visivo di 90°: a 5 cm di distanza fa quindi la media di un'area di circa 10 cm di diametro. Per misurare un oggetto piccolo avvicina il sensore o scegli una versione ad angolo stretto come 35° (BCC) o 5° (BCI). Il secondo è l'emissività: di fabbrica il sensore è impostato su 1,0. Per vernice opaca, plastica, legno, pelle e acqua questo coefficiente è tra 0,9 e 0,98, quindi il risultato è quasi corretto; le superfici metalliche lucide, invece, emettono pochissima radiazione e sembrano molto più fredde di quanto siano. Attaccarci un pezzo di nastro nero opaco è una soluzione semplice ed efficace. Installa la libreria Adafruit MLX90614 dal Gestore librerie e prova questo codice:

1#include <Wire.h>
2#include <Adafruit_MLX90614.h>
3
4Adafruit_MLX90614 mlx = Adafruit_MLX90614();
5
6void setup() {
7  Serial.begin(9600);
8  if (!mlx.begin()) {                           // varsayılan adres 0x5A / default address 0x5A
9    Serial.println(F("MLX90614 bulunamadi / not found"));
10    while (true) delay(10);
11  }
12  Serial.print(F("Emisivite / Emissivity: "));
13  Serial.println(mlx.readEmissivity(), 2);      // fabrika ayarı 1.00 / factory default 1.00
14}
15
16void loop() {
17  Serial.print(F("Ortam / Ambient: "));
18  Serial.print(mlx.readAmbientTempC(), 2);      // sensör gövdesi / sensor body
19  Serial.print(F(" C   Nesne / Object: "));
20  Serial.print(mlx.readObjectTempC(), 2);       // baktığı yüzey / surface in view
21  Serial.println(F(" C"));
22  delay(500);
23}

Riepilogo dei collegamenti: Arduino Uno, ESP32 e Raspberry Pi Pico

ESP32 e Pico lavorano a 3,3 V; se alimenti il partitore dell'NTC da 3V3, all'ingresso dell'ADC non può arrivare una tensione pericolosa. Sull'ESP32 collega i sensori analogici solo ai pin dell'ADC1 (GPIO 32–39), perché quelli dell'ADC2 non funzionano con il Wi-Fi attivo; per le linee dati bidirezionali come quelle di DHT e DS18B20 evita invece i GPIO 34–39, che sono solo ingressi. BME280 (0x76) e MLX90614 (0x5A) hanno indirizzi diversi e possono quindi condividere senza problemi gli stessi due fili I2C. Trovi tutti i pin della tua scheda nello strumento Pinout e il codice colori delle resistenze di pull-up nello strumento codice colori resistenze.

Test di confronto con l'ESP32: tre sensori nello stesso punto

Il modo migliore per vedere le differenze tra i sensori è osservarle con i tuoi occhi. Il codice ESP32 qui sotto legge contemporaneamente un DS18B20, un DHT22 e un BME280 e mostra i risultati come tre linee separate nel Serial Plotter dell'Arduino IDE. Metti i sensori uno accanto all'altro sulla breadboard, ad almeno 10 cm dall'ESP32; l'ESP32 si scalda mentre lavora e influenza qualsiasi sensore vicino. Il codice richiede le librerie OneWire, DallasTemperature, DHT sensor library e Adafruit BME280.

1#include <OneWire.h>
2#include <DallasTemperature.h>
3#include <DHT.h>
4#include <Wire.h>
5#include <Adafruit_Sensor.h>
6#include <Adafruit_BME280.h>
7
8const int ONE_WIRE_PIN = 4;     // DS18B20 DQ (4,7 kΩ pull-up -> 3V3)
9const int DHT_PIN = 27;         // DHT22 DATA
10
11OneWire oneWire(ONE_WIRE_PIN);
12DallasTemperature ds(&oneWire);
13DHT dht(DHT_PIN, DHT22);
14Adafruit_BME280 bme;            // I2C: SDA GPIO 21, SCL GPIO 22
15bool bmeOk = false;
16
17void setup() {
18  Serial.begin(115200);
19  ds.begin();
20  dht.begin();
21  bmeOk = bme.begin(0x76) || bme.begin(0x77);   // iki adresi de dene / try both addresses
22  if (!bmeOk) Serial.println("BME280 bulunamadi / not found");
23}
24
25void loop() {
26  ds.requestTemperatures();                     // 12 bitte ~750 ms sürer / takes ~750 ms at 12-bit
27  float tDs  = ds.getTempCByIndex(0);           // sensör yoksa -127 / -127 if missing
28  float tDht = dht.readTemperature();           // hata olursa NAN / NAN on error
29  float tBme = bmeOk ? bme.readTemperature() : NAN;
30
31  // Seri Çizici için etiket:değer biçimi / label:value format for the Serial Plotter
32  Serial.printf("DS18B20:%.2f,DHT22:%.1f,BME280:%.2f\n", tDs, tDht, tBme);
33  delay(2000);                                  // DHT22 en fazla 2 sn'de bir / DHT22 at most every 2 s
34}

Per prima cosa aspetta qualche minuto e osserva quanto sono distanti le linee: differenze di 0,5–1 °C rientrano nei limiti di precisione di questi sensori. Poi metti accanto un bicchiere d'acqua tiepida o soffia delicatamente su tutti e tre. DS18B20 e BME280 reagiscono in pochi secondi, mentre la linea del DHT22 resta nettamente indietro a causa della sua griglia di plastica. Se il BME280 resta sempre qualche decimo sopra gli altri, è l'autoriscaldamento del chip. Questo piccolo esperimento ti mostra differenze che non trovi in nessun datasheet. Per registrare le misure a lungo puoi usare un modulo per scheda SD o inviare i dati a Google Sheets.

Misurare la temperatura con Raspberry Pi Pico e MicroPython

Il firmware MicroPython del Pico include già i moduli dht, onewire e ds18x20, quindi per DHT e DS18B20 non devi copiare file aggiuntivi sul Pico. Inoltre il chip RP2040 ha un sensore di temperatura interno collegato al canale 4 dell'ADC. Il codice seguente li legge tutti e tre insieme:

1from machine import Pin, ADC
2import dht, onewire, ds18x20, time
3
4dht22 = dht.DHT22(Pin(15))                          # DHT22 DATA -> GP15
5ds = ds18x20.DS18X20(onewire.OneWire(Pin(22)))      # DS18B20 DQ -> GP22 (4,7 kΩ pull-up)
6roms = ds.scan()                                    # hattaki sensörler / sensors on the bus
7cpu = ADC(4)                                        # RP2040 dahili sensörü / internal sensor
8
9def cpu_temp():
10    v = cpu.read_u16() * 3.3 / 65535                # ham değer -> volt / raw value -> volts
11    return 27 - (v - 0.706) / 0.001721              # RP2040 veri sayfası formülü / datasheet formula
12
13while True:
14    t_ds = None
15    if roms:
16        ds.convert_temp()                           # ölçümü başlat / start conversion
17        time.sleep_ms(750)                          # 12 bit dönüşüm süresi / 12-bit conversion time
18        t_ds = round(ds.read_temp(roms[0]), 2)
19    try:
20        dht22.measure()
21        t_dht, nem = dht22.temperature(), dht22.humidity()
22    except OSError:                                 # okuma hatası / read error
23        t_dht = nem = None
24    print("DS18B20:", t_ds, "DHT22:", t_dht, "Nem / RH:", nem,
25          "Pico:", round(cpu_temp(), 1))
26    time.sleep(2)

Il sensore interno misura la temperatura del chip, non quella della stanza, e piccoli scostamenti del riferimento dell'ADC possono spostare il risultato di qualche grado. Non serve quindi a misurare l'ambiente, ma è utile per controllare se la scheda si surriscalda. Non dimenticare la pull-up da 4,7 kΩ sulla linea dati del DS18B20; le pull-up interne del Pico sono troppo deboli per l'1-Wire. Se il Pico è una novità per te, comincia da Cos'è il Raspberry Pi Pico?.

Quale sensore di temperatura per quale progetto?

Idee di progetto con i sensori di temperatura

• Serra intelligente: misura temperatura e umidità dell'aria con un DHT22 e la temperatura del terreno con una sonda DS18B20; gestisci ventola e irrigazione con un modulo relè. Per il progetto completo, guarda il progetto della serra intelligente.
• Riscaldatore per acquario con termostato: mantieni l'acqua tra 25 e 26 °C con un DS18B20 impermeabile; usa un'isteresi di 0,5 °C perché il relè non scatti a ogni minima variazione.
• Stazione meteo a batteria: abbina un BME280 alla modalità deep sleep dell'ESP32 e misura ogni dieci minuti, così il sistema funziona per mesi a batteria.
• Termometro per forno da pizza o barbecue: mostra la temperatura del forno con cifre grandi su un display OLED usando un MAX6675 e una sonda tipo K.
• Allarme temperatura motore senza contatto: controlla con un MLX90614 la temperatura superficiale di un motore o del piano di una stampante 3D e fai suonare un buzzer quando supera una soglia.
• Domotica: invia la temperatura di ogni stanza a Home Assistant via MQTT con un ESP32 e gestisci il riscaldamento di conseguenza.
• Guardiano del congelatore: con un DS18B20 fai scattare un allarme se l'interno del congelatore sale sopra i −12 °C e mostra il valore su un display LCD I2C.

Errori comuni e come risolverli

In breve: DHT22 o BME280 per stanze e meteo, DS18B20 per acqua e freddo, LM35 o NTC per imparare la misura analogica e avere una risposta rapida, MAX6675 per le alte temperature e MLX90614 per le superfici che non puoi toccare sono i punti di partenza giusti. Se vuoi conoscere anche altri tipi di sensori, dai un'occhiata alla guida ai sensori per Arduino. Nell'app BlueGrays trovi progetti come la misura di temperatura e umidità con il DHT11, un termometro con NTC e LCD, un indicatore di temperatura con ESP32, DHT22 e LCD, un datalogger di temperatura con ESP32 e un'irrigazione intelligente, con schema elettrico e codice passo passo.