Termistore NTC Arduino: schema, formula Beta e Steinhart-Hart

Un termistore NTC è un sensore di temperatura economicissimo, a due piedini, la cui resistenza diminuisce quando la temperatura aumenta. Per usare un termistore NTC con Arduino lo colleghi a una resistenza fissa da 10 kΩ formando un partitore di tensione, leggi il punto centrale con un pin analogico (A0), ricavi da questa lettura la resistenza del termistore e la converti in gradi Celsius con l'equazione Beta. Non serve nessuna libreria, basta un solo pin analogico e, se il circuito è fatto bene, a temperatura ambiente arrivi a una risoluzione di 0,1 °C. Anche il piatto e l'hotend delle stampanti 3D, le batterie di smartphone e portatili, i condizionatori, i frigoriferi e i termometri digitali per la febbre misurano la temperatura quasi sempre con termistori NTC.

In questo articolo imparerai passo dopo passo come varia la resistenza di un termistore NTC da 10 kΩ con la temperatura, come collegare il partitore di tensione e scegliere la resistenza fissa, l'equazione Beta con B = 3950, la più precisa equazione di Steinhart-Hart e la calibrazione a tre punti. Poi costruirai un termometro con display LCD I2C, ripeterai la misura con l'ADC di ESP32 e Raspberry Pi Pico e vedrai la differenza tra NTC e PTC, le applicazioni nelle stampanti 3D e nelle batterie e gli errori più comuni.

Che cos'è un termistore NTC e come funziona?

Il nome termistore nasce dall'unione delle parole inglesi "thermal" (termico) e "resistor" (resistore): è un resistore il cui valore cambia in modo marcato con la temperatura. NTC significa Negative Temperature Coefficient, cioè coefficiente di temperatura negativo. È realizzato in una ceramica semiconduttrice ottenuta cuocendo (sinterizzando) ad alta temperatura ossidi metallici come manganese, nichel e cobalto. Quando il materiale si scalda, più portatori di carica partecipano alla conduzione, perciò la resistenza scende. La variazione è grande: un NTC con B = 3950 perde circa il 4,4% della sua resistenza per ogni grado intorno a 25 °C. Per confronto, un normale resistore a film metallico varia solo di 50–100 ppm per grado, cioè dello 0,005–0,01%. Questa elevata sensibilità rende l'NTC un sensore economico ma molto reattivo; il prezzo da pagare è che la relazione non è lineare.

Relazione resistenza-temperatura: perché non è lineare?

La resistenza di un NTC varia in modo esponenziale con la temperatura: al freddo scende molto in fretta, al caldo più lentamente. La tabella qui sotto mostra la resistenza di un NTC da 10 kΩ con B = 3950 calcolata con l'equazione Beta, insieme alla tensione e al valore di analogRead che leggerai sul pin A0 di Arduino Uno quando questo NTC si trova nel ramo superiore di un partitore da 10 kΩ alimentato a 5 V (il collegamento della sezione successiva). L'ultima colonna indica a quanti gradi corrisponde un passo dell'ADC, cioè la risoluzione della misura. Le tabelle reali dei produttori possono scostarsi da questi valori di qualche punto percentuale, soprattutto agli estremi del campo.

Dalla tabella emergono due conclusioni importanti. La prima: il partitore è più sensibile quando la resistenza dell'NTC è uguale a quella fissa, cioè in questo esempio intorno a 25 °C; lì la tensione su A0 cambia di circa 55 mV per grado e perfino Arduino Uno, con il suo ADC a 10 bit, misura a passi di 0,09 °C. È cinque volte meglio dell'LM35, che con il riferimento a 5 V offre solo 0,49 °C di risoluzione. La seconda: più ti allontani da quel punto, più la risoluzione peggiora; a 100 °C un passo vale 0,57 °C e a 125 °C 1,2 °C. Per questo conviene scegliere la resistenza fissa vicina al valore dell'NTC alla temperatura che misurerai più spesso. Per ottenere la massima escursione della tensione su A0 in un certo campo, la resistenza fissa deve essere la media geometrica delle resistenze dell'NTC ai due estremi: per 0–100 °C √(33,6 kΩ × 0,70 kΩ) ≈ 4,8 kΩ, quindi lo standard 4,7 kΩ; per 60–100 °C circa 1,3 kΩ, quindi 1,2 kΩ o 1,5 kΩ.

Collegamento del termistore NTC: partitore di tensione (Uno, ESP32, Pico)

Gli ingressi analogici di Arduino misurano una tensione, non una resistenza. Per questo metti l'NTC in serie a una resistenza fissa e formi un partitore di tensione: la tensione nel punto in cui le due resistenze si uniscono dipende dalla resistenza dell'NTC e quindi dalla temperatura. È lo stesso circuito che usi con una fotoresistenza (LDR); l'unica differenza è che la resistenza reagisce alla temperatura invece che alla luce. Nei codici di questo articolo l'NTC sta nel ramo superiore (collegato all'alimentazione) e la resistenza da 10 kΩ in quello inferiore (collegata a GND); così la lettura sale quando si scalda, ed è più intuitivo. Puoi calcolare la tensione di uscita con altri valori nello strumento Partitore di tensione e controllare il codice colori della resistenza fissa con lo strumento Codice colori dei resistori.

Questo circuito ha una proprietà molto comoda: esegue una misura raziometrica. Per impostazione predefinita l'ADC di Arduino Uno usa come riferimento l'alimentazione a 5 V, e il partitore è alimentato dagli stessi 5 V. Anche se l'USB fornisce 4,8 V invece di 5,0 V, l'uscita del partitore e il riferimento dell'ADC scendono nella stessa proporzione e il valore di analogRead non cambia. Quindi per misurare con un NTC non serve conoscere la tensione di alimentazione né combattere con la tensione di riferimento come con l'LM35. Per lo stesso motivo non usare analogReference(INTERNAL) in un circuito con NTC: con un riferimento di 1,1 V il rapporto salta e il calcolo è sbagliato. Ciò che decide davvero la precisione è il valore della resistenza fissa; una resistenza al 5% da sola può causare circa 1 °C di errore. Usa quindi un resistore a film metallico all'1% oppure misura il valore reale del tuo con un multimetro e inseriscilo nel codice.

Calcolare la temperatura con l'equazione Beta (B = 3950)

I produttori descrivono un NTC con due numeri: la resistenza a 25 °C (R0 = 10 kΩ) e il valore B (Beta). Con questi due numeri l'equazione Beta fornisce la temperatura corrispondente a qualsiasi resistenza: 1/T = 1/T0 + (1/B) × ln(R/R0). Qui T e T0 sono in kelvin (T0 = 25 + 273,15 = 298,15 K) e ln è il logaritmo naturale; per passare ai gradi Celsius sottrai 273,15. Esempio: se l'NTC misura 5300 Ω, ln(5300/10000) = −0,635; 1/T = 0,003354 − 0,000161 = 0,003193 e T = 313,2 K, cioè circa 40 °C. I numeri piccoli accanto al valore B indicano tra quali due temperature è stato misurato: B25/50 = 3950 significa che B è stato calcolato dalle resistenze a 25 °C e a 50 °C. Se non hai il datasheet puoi ricavare B da solo: misura la resistenza a due temperature e usa B = ln(R1/R2) / (1/T1 − 1/T2). Per esempio, se misuri 10.000 Ω a 25 °C e 3588 Ω a 50 °C, ottieni B ≈ 3950.

Prima misura con Arduino passo dopo passo

1. Inserisci l'NTC e la resistenza da 10 kΩ nella breadboard; collega un piedino dell'NTC a 5V e l'altro a un capo della resistenza.
2. Collega l'altro capo della resistenza a GND e porta un cavetto jumper dal punto di unione tra NTC e resistenza fino ad A0.
3. Carica il codice qui sotto e apri il Monitor seriale a 9600 baud.
4. A temperatura ambiente dovresti vedere un valore intorno a 20–25 °C. Stringi l'NTC tra due dita; in pochi secondi il valore dovrebbe salire verso i 30 °C.
5. Se il valore scende quando si scalda, NTC e resistenza sono scambiati: correggi il collegamento oppure sostituisci la formula nel codice con quella dello schema "NTC in basso".

1const int NTC_PIN = A0;            // NTC ile 10k direncin birleştiği nokta / junction of the NTC and the 10k resistor
2const float SERIES_R = 10000.0;    // sabit direnç, ölçtüğün değeri yaz / fixed resistor, write your measured value
3const float R_NOMINAL = 10000.0;   // NTC'nin 25 °C'deki direnci / NTC resistance at 25 °C
4const float T_NOMINAL_K = 298.15;  // 25 °C kelvin cinsinden / 25 °C in kelvin
5const float BETA_K = 3950.0;       // B25/50 değeri (veri sayfası) / B25/50 value (datasheet)
6const int SAMPLES = 16;            // ortalama için ölçüm sayısı / number of 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;                      // ortalama ham değer / average raw value
19
20  if (adc < 1.0 || adc > 1022.0) {                       // kablo kopuk ya da kısa devre / open or shorted wire
21    Serial.println(F("Sensor hatasi / Sensor error"));
22    delay(1000);
23    return;
24  }
25
26  float rNtc = SERIES_R * (1023.0 - adc) / adc;          // NTC üstte bağlantı / NTC on the high side
27  float tempK = 1.0 / (1.0 / T_NOMINAL_K + log(rNtc / R_NOMINAL) / BETA_K);   // Beta denklemi / Beta equation
28  float tempC = tempK - 273.15;                          // kelvin -> santigrat / kelvin -> Celsius
29
30  Serial.print(F("ADC: "));
31  Serial.print(adc, 1);
32  Serial.print(F("  R: "));
33  Serial.print(rNtc, 0);
34  Serial.print(F(" ohm  Sicaklik / Temp: "));
35  Serial.print(tempC, 2);
36  Serial.println(F(" C"));
37  delay(1000);
38}

A ogni misura il codice legge A0 sedici volte e ne fa la media; così si attenua l'oscillazione di uno o due passi dell'ADC. Se la media è inferiore a 1 o superiore a 1022, il filo dell'NTC è interrotto o in cortocircuito, e il codice stampa un messaggio di errore invece di una temperatura assurda. Poi calcola dalla media la resistenza dell'NTC e da questa, con l'equazione Beta, la temperatura. In Arduino la funzione log() restituisce il logaritmo naturale (ln); log10() è il logaritmo in base 10, e confonderli rende il risultato completamente sbagliato appena ci si allontana da 25 °C. Nel Monitor seriale vedrai righe come "ADC: 512.3 R: 9969 ohm Sicaklik / Temp: 25.07 C".

L'equazione di Steinhart-Hart: un risultato più preciso

L'equazione Beta funziona molto bene nel campo in cui è stato misurato B (di solito 25–50 °C), ma si discosta quando ci si allontana, perché il valore B di un NTC reale cambia leggermente con la temperatura. Su un campo ampio come 0–100 °C l'errore può superare 1 °C. Per una precisione maggiore si usa l'equazione di Steinhart-Hart a tre coefficienti: 1/T = A + B × ln(R) + C × (ln R)³. L'equazione Beta è in realtà il caso particolare di questa con C = 0. I coefficienti si calcolano da tre valori di resistenza misurati a tre temperature diverse; con tre punti ben scelti l'equazione offre di solito una precisione migliore di 0,1 °C nel campo calibrato. Invece di risolvere A, B e C a mano, il codice seguente calcola da solo i coefficienti dai tuoi tre punti misurati, dentro setup().

1const int NTC_PIN = A0;
2const float SERIES_R = 10000.0;    // ölçtüğün sabit direnç / your measured fixed resistor
3
4// Kalibrasyon noktaları: örnek değerler, kendi ölçümlerini yaz / calibration points: sample values, use your own
5const float CAL_T1 = 0.0,  CAL_R1 = 32900.0;   // buzlu su / ice water
6const float CAL_T2 = 25.0, CAL_R2 = 10000.0;   // oda, referans termometreyle / room, against a reference thermometer
7const float CAL_T3 = 98.5, CAL_R3 = 690.0;     // kaynayan su / boiling water
8
9float shA, shB, shC;               // Steinhart-Hart katsayıları / coefficients
10
11void computeCoefficients() {
12  float L1 = log(CAL_R1), L2 = log(CAL_R2), L3 = log(CAL_R3);
13  float Y1 = 1.0 / (CAL_T1 + 273.15);
14  float Y2 = 1.0 / (CAL_T2 + 273.15);
15  float Y3 = 1.0 / (CAL_T3 + 273.15);
16  float g2 = (Y2 - Y1) / (L2 - L1);
17  float g3 = (Y3 - Y1) / (L3 - L1);
18  shC = ((g3 - g2) / (L3 - L2)) / (L1 + L2 + L3);
19  shB = g2 - shC * (L1 * L1 + L1 * L2 + L2 * L2);
20  shA = Y1 - (shB + shC * L1 * L1) * L1;
21}
22
23float readResistance() {
24  long sum = 0;
25  for (int i = 0; i < 16; i++) {
26    sum += analogRead(NTC_PIN);
27    delay(2);
28  }
29  float adc = sum / 16.0;
30  if (adc < 1.0 || adc > 1022.0) return -1.0;            // sensör hatası / sensor error
31  return SERIES_R * (1023.0 - adc) / adc;                // NTC üstte / NTC on the high side
32}
33
34void setup() {
35  Serial.begin(9600);
36  computeCoefficients();           // katsayıları bir kez hesapla / compute the coefficients once
37}
38
39void loop() {
40  float r = readResistance();
41  if (r < 0) {
42    Serial.println(F("Sensor hatasi / Sensor error"));
43  } else {
44    float lnR = log(r);
45    float tempK = 1.0 / (shA + shB * lnR + shC * lnR * lnR * lnR);   // Steinhart-Hart
46    Serial.print(F("R: "));
47    Serial.print(r, 0);
48    Serial.print(F(" ohm  Sicaklik / Temp: "));
49    Serial.print(tempK - 273.15, 2);
50    Serial.println(F(" C"));
51  }
52  delay(1000);
53}

I tre punti nel codice sono d'esempio; misura il tuo NTC e sostituiscili. Con questi valori d'esempio Steinhart-Hart dà il risultato esatto a 0 °C, 25 °C e 98,5 °C. Se invece fornisci le stesse resistenze all'equazione Beta (B = 3950), il punto a 0 °C risulta 0,4 °C e quello a 98,5 °C risulta 100,4 °C, cioè circa 2 °C di errore ad alta temperatura. Scegli i punti ai due estremi e al centro del campo che misurerai; fuori dal campo calibrato (per esempio a −20 °C con questi coefficienti) l'errore torna a crescere. Su Arduino Uno un float è di soli 32 bit, ma per questo calcolo basta: i risultati coincidono entro 0,01 °C con un calcolo in doppia precisione.

Calibrazione: trasforma il tuo NTC in un termometro affidabile

1. Misura la resistenza fissa: misura con il multimetro il valore reale della resistenza da 10 kΩ e inseriscilo in SERIES_R; uno scostamento dell'1% da solo vale circa 0,2 °C di errore.
2. Rendi l'NTC impermeabile: non immergere in acqua un NTC epossidico nudo; isola i piedini con guaina termorestringente e silicone, oppure usa un NTC già montato in una sonda d'acciaio inox.
3. Punto a 0 °C: riempi un bicchiere fino all'orlo di ghiaccio tritato, aggiungi un po' d'acqua fredda e mescola. Tieni l'NTC al centro del bicchiere per 2–3 minuti e, quando il valore si stabilizza, annota il valore R mostrato nel Monitor seriale.
4. Punto a temperatura ambiente: lascia l'NTC per 10 minuti accanto a un termometro digitale affidabile, in un punto senza correnti d'aria; annota la lettura del termometro e la resistenza dell'NTC.
5. Punto ad alta temperatura: a livello del mare l'acqua bolle a 100 °C, ma il punto di ebollizione scende di circa 1 °C ogni 300 m di altitudine (circa 96,7 °C a 1000 m). Immergi l'NTC nell'acqua bollente senza toccare il fondo della pentola e annota la resistenza.
6. Inserisci i valori nel codice: inserisci i tre punti nel codice Steinhart-Hart. Se misurerai solo intorno alla temperatura ambiente, spesso basta una correzione di offset a un punto (sottrarre la differenza costante).

Termometro NTC con display LCD

Per mostrare la misura senza computer aggiungiamo un display LCD I2C 16x2. Collega il pin SDA del display ad A4, SCL ad A5, VCC a 5V e GND a GND; il circuito dell'NTC resta invariato. Il codice usa la libreria LiquidCrystal I2C, che puoi installare dal Gestore librerie. L'indirizzo del display è di solito 0x27, su alcuni moduli 0x3F. Per il simbolo dei gradi stampiamo il carattere 223 della tabella caratteri dell'LCD. Il display mostra inoltre nella riga inferiore la temperatura minima e massima misurate da quando Arduino è stato acceso.

1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3
4LiquidCrystal_I2C lcd(0x27, 16, 2);   // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
5
6const int NTC_PIN = A0;
7const float SERIES_R = 10000.0;
8const float R_NOMINAL = 10000.0;
9const float T_NOMINAL_K = 298.15;
10const float BETA_K = 3950.0;
11
12float minC = 999.0;                   // en düşük değer / lowest value
13float maxC = -999.0;                  // en yüksek değer / highest value
14
15float readTempC() {
16  long sum = 0;
17  for (int i = 0; i < 16; i++) {
18    sum += analogRead(NTC_PIN);
19  }
20  float adc = sum / 16.0;
21  if (adc < 1.0 || adc > 1022.0) return NAN;             // sensör hatası / sensor error
22  float r = SERIES_R * (1023.0 - adc) / adc;
23  return 1.0 / (1.0 / T_NOMINAL_K + log(r / R_NOMINAL) / BETA_K) - 273.15;
24}
25
26void setup() {
27  lcd.init();
28  lcd.backlight();
29}
30
31void loop() {
32  float t = readTempC();
33  lcd.clear();
34  if (isnan(t)) {
35    lcd.print(F("Sensor hatasi"));
36  } else {
37    if (t < minC) minC = t;
38    if (t > maxC) maxC = t;
39    lcd.print(F("Sicaklik "));
40    lcd.print(t, 1);
41    lcd.print((char)223);             // derece işareti / degree symbol
42    lcd.print('C');
43    lcd.setCursor(0, 1);              // ikinci satır / second row
44    lcd.print(F("Min"));
45    lcd.print(minC, 1);
46    lcd.print(F(" Max"));
47    lcd.print(maxC, 1);
48  }
49  delay(1000);
50}

Termistore NTC con ESP32

L'ADC dell'ESP32 è a 12 bit (0–4095) e il chip funziona a 3,3 V, quindi alimenta il partitore dal pin 3V3. Collega sempre l'NTC a un pin ADC1 (GPIO 32–39); i pin ADC2 non si possono leggere quando il Wi-Fi è attivo. Puoi vedere la piedinatura della tua scheda nello strumento Pinout. Qui c'è una differenza importante: l'ADC dell'ESP32 non usa come riferimento la tensione di alimentazione, ma un riferimento interno di circa 1,1 V insieme all'attenuazione scelta. La misura raziometrica di Arduino Uno quindi non avviene da sola, e devi conoscere il valore reale della linea 3V3. Per questo il codice legge i millivolt con analogReadMilliVolts(), che usa i dati di calibrazione scritti nel chip in fabbrica, e calcola la resistenza con il valore di 3V3 che hai misurato con il multimetro. Secondo la documentazione di Espressif, l'ESP32 classico misura 150–3100 mV con l'attenuazione predefinita di 11 dB, ma la zona consigliata e più lineare è 150–2450 mV. Questi limiti stabiliscono il campo di temperatura misurabile in base allo schema:

1const int NTC_PIN = 34;            // ADC1_CH6, Wi-Fi açıkken de çalışır / works while Wi-Fi is on
2const float VCC_MV = 3300.0;       // 3V3 pinini multimetreyle ölçüp yaz / measure the 3V3 pin and write it here
3const float SERIES_R = 10000.0;
4const float R_NOMINAL = 10000.0;
5const float T_NOMINAL_K = 298.15;
6const float BETA_K = 3950.0;
7const int SAMPLES = 64;            // ortalama için ölçüm sayısı / number of samples to average
8
9void setup() {
10  Serial.begin(115200);
11  analogReadResolution(12);                     // 0–4095
12  analogSetPinAttenuation(NTC_PIN, ADC_11db);   // varsayılan zayıflatma / default attenuation
13}
14
15void loop() {
16  uint32_t sum = 0;
17  for (int i = 0; i < SAMPLES; i++) {
18    sum += analogReadMilliVolts(NTC_PIN);       // kalibre edilmiş mV / calibrated millivolts
19    delay(1);
20  }
21  float mv = sum / (float)SAMPLES;
22
23  if (mv < 150.0 || mv > 3100.0) {              // ADC aralığı dışında / outside the ADC range
24    Serial.println("Aralik disi / Out of range");
25    delay(1000);
26    return;
27  }
28
29  float rNtc = SERIES_R * (VCC_MV - mv) / mv;   // NTC üstte / NTC on the high side
30  float tempC = 1.0 / (1.0 / T_NOMINAL_K + log(rNtc / R_NOMINAL) / BETA_K) - 273.15;
31  Serial.printf("Gerilim / Voltage: %.0f mV  R: %.0f ohm  Sicaklik / Temp: %.2f C\n", mv, rNtc, tempC);
32  delay(1000);
33}

Per un termometro da interno o da esterno lo schema con l'NTC in alto è ideale. Se misurerai sopra i 50 °C, per esempio un bollitore, una macchina del caffè o il piatto di una stampante 3D, sposta l'NTC nel ramo inferiore e cambia la formula in Rntc = Rs × mV / (Vcc − mV). Con il Wi-Fi attivo, i picchi di assorbimento dell'ESP32 creano piccole oscillazioni sulla linea 3V3; fare la media di 64 letture e aggiungere un condensatore da 100 nF tra GPIO 34 e GND migliora nettamente il risultato. Se sei alle prime armi con l'ESP32, trovi la configurazione nell'articolo Cos'è l'ESP32.

NTC con Raspberry Pi Pico e MicroPython

L'ADC a 12 bit della Pico si trova sui pin GP26, GP27 e GP28; in MicroPython read_u16() restituisce il risultato scalato su 0–65535. Il riferimento dell'ADC della Pico (ADC_VREF) viene ricavato sulla scheda dalla linea a 3,3 V tramite un piccolo filtro RC. Se alimenti anche il partitore dal pin 3V3(OUT), la misura è all'incirca raziometrica come su Arduino Uno e la formula resta la stessa; usi semplicemente 65535 invece di 1023. L'ADC della Pico è un po' rumoroso e fa piccoli salti su alcuni codici, quindi anche qui la media è indispensabile. Usare AGND (pin 33) come massa analogica riduce un po' il rumore. Se usi la Pico per la prima volta, trovi l'installazione di MicroPython nell'articolo Cos'è il Raspberry Pi Pico.

1from machine import ADC
2import math
3import time
4
5ntc = ADC(26)                # GP26 = ADC0, fiziksel pin 31 / physical pin 31
6SERIES_R = 10000             # sabit direnç / fixed resistor
7R_NOMINAL = 10000            # NTC'nin 25 °C'deki direnci / NTC resistance at 25 °C
8T_NOMINAL_K = 298.15         # 25 °C kelvin cinsinden / 25 °C in kelvin
9BETA_K = 3950                # B25/50 değeri / B25/50 value
10SAMPLES = 64                 # ortalama için ölçüm sayısı / number of samples to average
11
12
13def read_temp_c():
14    total = 0
15    for _ in range(SAMPLES):
16        total += ntc.read_u16()          # 0–65535
17    raw = total / SAMPLES
18    if raw < 100 or raw > 65435:
19        return None                      # kopuk ya da kısa devre / open or shorted
20    r_ntc = SERIES_R * (65535 - raw) / raw          # NTC üstte / NTC on the high side
21    temp_k = 1 / (1 / T_NOMINAL_K + math.log(r_ntc / R_NOMINAL) / BETA_K)
22    return temp_k - 273.15
23
24
25while True:
26    t = read_temp_c()
27    if t is None:
28        print("Sensor hatasi / Sensor error")
29    else:
30        print("Sicaklik / Temp: {:.2f} C".format(t))
31    time.sleep(1)

Anche in MicroPython math.log() è il logaritmo naturale, quindi usi la stessa formula del codice Arduino. La Pico ha anche un sensore di temperatura interno (ADC(4)), ma misura la temperatura del chip stesso e non quella dell'ambiente, e durante il funzionamento segna spesso qualche grado in più. Per la temperatura ambiente un NTC esterno è molto più preciso. Se vuoi usare i coefficienti di Steinhart-Hart, puoi tradurre in Python la funzione computeCoefficients() del codice Arduino in poche righe.

Differenza tra NTC e PTC

Nei termistori PTC (Positive Temperature Coefficient) la resistenza aumenta con la temperatura. Il tipo di PTC più diffuso non serve a misurare ma a proteggere: i PTC di commutazione in ceramica di titanato di bario restano a bassa resistenza fino a una certa temperatura (il punto di Curie) e oltre quella la loro resistenza aumenta di colpo di centinaia o migliaia di volte. Le protezioni contro il surriscaldamento degli avvolgimenti dei motori e i riscaldatori PTC autoregolanti funzionano con questo principio. I fusibili ripristinabili a base polimerica (polyfuse) si comportano in modo simile; il fusibile da 500 mA sulla linea USB di Arduino Uno è uno di questi. I sensori PTC al silicio come il KTY81, invece, variano in modo quasi lineare, di circa lo 0,7–0,8%/°C. Le termoresistenze al platino come PT100 e PT1000 hanno anch'esse un coefficiente positivo, ma sono sensori metallici, non termistori; valgono 100 Ω o 1000 Ω a 0 °C, superano i 500 °C e per essere lette richiedono un amplificatore come il MAX31865.

Applicazioni in stampanti 3D e batterie

Nelle stampanti 3D sia la temperatura dell'hotend sia quella del piatto vengono misurate quasi sempre con termistori NTC. Qui si usano NTC da 100 kΩ invece che da 10 kΩ, perché a 250 °C un NTC da 10 kΩ scende a circa 35 Ω e la misura perde risoluzione; il file di configurazione del diffuso firmware Marlin avverte infatti, per il termistore generico da 10 kΩ, di "non usarlo per un hotend, perché ad alta temperatura ha una cattiva risoluzione". Sulle schede a 8 bit come la RAMPS gli ingressi dei termistori hanno un resistore di pull-up da 4,7 kΩ verso i 5 V, e Marlin converte il valore dell'ADC in temperatura con tabelle già pronte; uno dei tipi definiti per i termistori da 100 kΩ B3950 è il numero 11. Se il filo del termistore si rompe, l'ADC legge il valore massimo, il firmware lo interpreta come un freddo estremo e mostra Err: MINTEMP; con un cortocircuito compare Err: MAXTEMP. Se il termistore esce dalla sua sede, la resistenza riscaldante continua a scaldare ma la lettura non sale; Marlin lo rileva con la protezione THERMAL RUNAWAY e spegne i riscaldatori. Non disattivare mai questa protezione.

Le celle agli ioni di litio non vanno caricate sotto 0 °C né sopra circa 45 °C; caricarle al freddo provoca depositi di litio metallico all'interno della cella e danni permanenti. Per questo la maggior parte delle batterie di smartphone, portatili ed e-bike ha un NTC incollato sulle celle, e il terzo contatto del connettore della batteria (indicato con T o NTC) di solito va a questo termistore. Il pin 1 (TEMP) del diffuso chip di ricarica TP4056 serve proprio a questo: secondo il datasheet, se la tensione su questo pin resta sotto il 45% o sopra l'80% della tensione d'ingresso per più di 0,15 secondi, la carica viene sospesa. Nel tuo progetto con batterie puoi incollare un NTC sulla cella, leggerlo con Arduino e interrompere il circuito di carica con un MOSFET quando la temperatura esce dai limiti. Negli alimentatori, invece, i grandi NTC a disco limitano la corrente di spunto che carica i condensatori all'accensione; scaldandosi, la loro resistenza passa da qualche ohm a meno di un ohm, così nel funzionamento normale causano perdite minime.

Idee di progetti con il termistore NTC

• Termostato per ventola con isteresi: accendi una ventola con un modulo relè quando la temperatura supera i 30 °C e spegnila quando scende a 28 °C; i 2 gradi di differenza evitano che il relè scatti di continuo.
• Termometro per acquario con sonda impermeabile: misura la temperatura dell'acqua con una sonda NTC in acciaio inox e fai suonare un buzzer se il riscaldatore si guasta.
• Termometro tascabile con display OLED: mostra la temperatura e il grafico dell'ultima ora su un display OLED.
• Monitor per la camera chiusa della stampante 3D: misura la temperatura all'interno della camera e avvia una ventola di aspirazione oltre i 45 °C.
• Guardiano della temperatura della batteria: sorveglia la temperatura della cella durante la carica, interrompi la carica fuori da 0–45 °C e avvisa con un LED.
• Registratore di temperatura Wi-Fi: con un ESP32 salva una lettura al minuto su una scheda SD o mostrala su una pagina web aperta dallo smartphone.

Errori comuni e soluzioni

Il termistore NTC ti insegna a trasformare un componente economico in un termometro preciso con una sola resistenza e poche righe di matematica: partitore di tensione, ADC, logaritmi e calibrazione tutti insieme. Userai lo stesso approccio più avanti con altri sensori analogici; per rendere le tue letture ancora più stabili, dai un'occhiata alle tecniche di filtraggio dei dati dei sensori. Nell'app BlueGrays trovi la misura della temperatura con NTC e LCD 2x16, temperatura e umidità con il DHT11, una stazione di temperatura ESP32 con LCD e un registratore di temperatura, ognuno con schemi passo passo e codice pronto all'uso.