Termistor NTC Arduino: conexión, fórmula Beta y Steinhart-Hart

Un termistor NTC es un sensor de temperatura muy barato, de dos patas, cuya resistencia disminuye a medida que aumenta la temperatura. Para usar un termistor NTC con Arduino lo conectas con una resistencia fija de 10 kΩ formando un divisor de tensión, lees el punto medio con un pin analógico (A0), calculas a partir de esa lectura la resistencia del termistor y la conviertes a grados Celsius con la ecuación Beta. No necesitas ninguna librería, basta con un pin analógico y, bien montado, alcanzas una resolución de 0,1 °C a temperatura ambiente. La cama y el hotend de las impresoras 3D, las baterías de móviles y portátiles, los aires acondicionados, las neveras y los termómetros digitales de fiebre también miden la temperatura casi siempre con termistores NTC.

En este artículo aprenderás paso a paso cómo cambia la resistencia de un termistor NTC de 10 kΩ con la temperatura, cómo conectar el divisor de tensión y elegir la resistencia fija, la ecuación Beta con B = 3950, la ecuación más precisa de Steinhart-Hart y la calibración en tres puntos. Después montarás un termómetro con un LCD I2C, repetirás la medida con el ADC del ESP32 y de la Raspberry Pi Pico, y verás la diferencia entre NTC y PTC, las aplicaciones en impresoras 3D y baterías, y los errores más habituales.

¿Qué es un termistor NTC y cómo funciona?

La palabra termistor viene de unir los términos ingleses "thermal" (térmico) y "resistor" (resistencia): es una resistencia cuyo valor cambia de forma notable con la temperatura. NTC significa Negative Temperature Coefficient, es decir, coeficiente de temperatura negativo. Se fabrica con una cerámica semiconductora que se obtiene cociendo (sinterizando) óxidos metálicos como manganeso, níquel y cobalto a alta temperatura. Al calentarse, más portadores de carga participan en la conducción, por eso la resistencia baja. El cambio es grande: un NTC con B = 3950 pierde alrededor del 4,4 % de su resistencia por cada grado en torno a 25 °C. En comparación, una resistencia de película metálica normal varía solo entre 50 y 100 ppm por grado, es decir, entre el 0,005 % y el 0,01 %. Esta gran sensibilidad convierte al NTC en un sensor barato pero muy sensible; el precio a pagar es que la relación no es lineal.

Relación resistencia-temperatura: ¿por qué no es lineal?

La resistencia de un NTC varía de forma exponencial con la temperatura: baja muy deprisa con frío y más despacio con calor. La tabla siguiente muestra la resistencia de un NTC de 10 kΩ y B = 3950 calculada con la ecuación Beta, junto con la tensión y el valor de analogRead que verás en el pin A0 del Arduino Uno cuando este NTC está en la rama superior de un divisor de 10 kΩ alimentado a 5 V (el montaje de la siguiente sección). La última columna indica a cuántos grados equivale un paso del ADC, es decir, la resolución de la medida. Las tablas reales de los fabricantes pueden diferir de estos valores en un pequeño porcentaje, sobre todo en los extremos del rango.

De la tabla se sacan dos conclusiones importantes. La primera: el divisor es más sensible cuando la resistencia del NTC es igual a la resistencia fija, que en este ejemplo ocurre en torno a 25 °C; allí la tensión en A0 cambia unos 55 mV por grado y hasta el Uno, con su ADC de 10 bits, mide en pasos de 0,09 °C. Es cinco veces mejor que el LM35, que con la referencia de 5 V solo da 0,49 °C de resolución. La segunda: cuanto más te alejas de ese punto, peor es la resolución; a 100 °C un paso equivale a 0,57 °C y a 125 °C a 1,2 °C. Por eso conviene elegir la resistencia fija cerca del valor del NTC a la temperatura que más vas a medir. Para que la tensión en A0 tenga la mayor excursión posible en un rango concreto, la resistencia fija debe ser la media geométrica de las resistencias del NTC en los dos extremos: para 0–100 °C, √(33,6 kΩ × 0,70 kΩ) ≈ 4,8 kΩ, es decir, una estándar de 4,7 kΩ; para 60–100 °C, unos 1,3 kΩ, o sea 1,2 kΩ o 1,5 kΩ.

Conexión del termistor NTC: divisor de tensión (Uno, ESP32, Pico)

Las entradas analógicas de Arduino miden tensión, no resistencia. Por eso pones el NTC en serie con una resistencia fija y formas un divisor de tensión: la tensión en el punto de unión de las dos resistencias depende de la resistencia del NTC y, por tanto, de la temperatura. Es el mismo circuito que usas con una LDR; la única diferencia es que la resistencia reacciona a la temperatura en lugar de a la luz. En los códigos de este artículo el NTC va en la rama superior (conectado a la alimentación) y la resistencia de 10 kΩ en la inferior (conectada a GND); así la lectura sube cuando se calienta, lo que resulta intuitivo. Puedes calcular la tensión de salida con otros valores en la herramienta Divisor de tensión y comprobar el código de colores de la resistencia fija con la herramienta Código de colores de resistencias.

Este circuito tiene una propiedad muy útil: hace una medida ratiométrica. Por defecto, el ADC del Uno usa la alimentación de 5 V como referencia, y el divisor se alimenta de esos mismos 5 V. Aunque el USB dé 4,8 V en lugar de 5,0 V, la salida del divisor y la referencia del ADC bajan en la misma proporción y el valor de analogRead no cambia. Así que no necesitas conocer la tensión de alimentación para medir con un NTC ni pelearte con la tensión de referencia como con el LM35. Por la misma razón, no uses analogReference(INTERNAL) en un circuito con NTC: con una referencia de 1,1 V la proporción se rompe y el cálculo sale mal. Lo que de verdad decide la precisión es el valor de la resistencia fija; una resistencia del 5 % por sí sola puede causar alrededor de 1 °C de error. Usa una resistencia de película metálica del 1 % o mide el valor real de la tuya con un multímetro y escríbelo en el código.

Calcular la temperatura con la ecuación Beta (B = 3950)

Los fabricantes describen un NTC con dos números: su resistencia a 25 °C (R0 = 10 kΩ) y su valor B (Beta). Con esos dos números, la ecuación Beta da la temperatura que corresponde a cualquier resistencia: 1/T = 1/T0 + (1/B) × ln(R/R0). Aquí T y T0 están en kelvin (T0 = 25 + 273,15 = 298,15 K) y ln es el logaritmo natural; para pasar el resultado a Celsius restas 273,15. Ejemplo: si el NTC mide 5300 Ω, ln(5300/10000) = −0,635; 1/T = 0,003354 − 0,000161 = 0,003193 y T = 313,2 K, es decir, unos 40 °C. Los números pequeños junto al valor B indican entre qué dos temperaturas se midió: B25/50 = 3950 significa que B se calculó con las resistencias a 25 °C y a 50 °C. Si no tienes la hoja de datos, puedes hallar B tú mismo: mide la resistencia a dos temperaturas y usa B = ln(R1/R2) / (1/T1 − 1/T2). Por ejemplo, si mides 10 000 Ω a 25 °C y 3588 Ω a 50 °C, obtienes B ≈ 3950.

Primera medida con Arduino paso a paso

1. Coloca el NTC y la resistencia de 10 kΩ en la protoboard; conecta una pata del NTC a 5V y la otra a un extremo de la resistencia.
2. Conecta el otro extremo de la resistencia a GND y lleva un cable puente desde el punto de unión del NTC y la resistencia hasta A0.
3. Sube el código de abajo y abre el Monitor Serie a 9600 baudios.
4. A temperatura ambiente deberías ver un valor de unos 20–25 °C. Sujeta el NTC entre dos dedos; en pocos segundos el valor debería subir hacia los 30 °C.
5. Si el valor baja al calentarse, el NTC y la resistencia están intercambiados: corrige el montaje o sustituye la fórmula del código por la de "NTC abajo".

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}

En cada medida el código lee A0 dieciséis veces y calcula la media; así se suaviza el temblor de uno o dos pasos del ADC. Si la media queda por debajo de 1 o por encima de 1022, el cable del NTC está cortado o en cortocircuito, y el código muestra un mensaje de error en lugar de una temperatura absurda. Después calcula la resistencia del NTC a partir de la media y, con ella, la temperatura mediante la ecuación Beta. En Arduino la función log() devuelve el logaritmo natural (ln); log10() es el logaritmo en base 10, y confundirlos hace que el resultado sea totalmente erróneo en cuanto te alejas de 25 °C. En el Monitor Serie verás líneas como "ADC: 512.3 R: 9969 ohm Sicaklik / Temp: 25.07 C".

La ecuación de Steinhart-Hart: un resultado más preciso

La ecuación Beta funciona muy bien en el rango donde se midió B (normalmente 25–50 °C), pero se desvía al alejarse de él, porque el valor B de un NTC real cambia ligeramente con la temperatura. En un rango amplio, como 0–100 °C, el error puede superar 1 °C. Para obtener más precisión se usa la ecuación de Steinhart-Hart, de tres coeficientes: 1/T = A + B × ln(R) + C × (ln R)³. La ecuación Beta es en realidad el caso particular de esta con C = 0. Los coeficientes se calculan a partir de tres resistencias medidas a tres temperaturas distintas; con tres puntos bien elegidos, la ecuación suele ofrecer una precisión mejor que 0,1 °C dentro del rango calibrado. En lugar de despejar A, B y C a mano, el código siguiente calcula los coeficientes a partir de tus tres puntos medidos dentro de 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}

Los tres puntos del código son de ejemplo; mide tu propio NTC y sustitúyelos. Con estos valores de ejemplo, Steinhart-Hart da el resultado exacto a 0 °C, 25 °C y 98,5 °C. En cambio, si introduces las mismas resistencias en la ecuación Beta (B = 3950), el punto de 0 °C sale como 0,4 °C y el de 98,5 °C como 100,4 °C, es decir, unos 2 °C de error a alta temperatura. Elige los puntos en los dos extremos y en el centro del rango que vas a medir; fuera del rango calibrado (por ejemplo, a −20 °C con estos coeficientes) el error vuelve a crecer. En el Uno un float tiene solo 32 bits, pero basta para este cálculo: los resultados coinciden con un cálculo en doble precisión con menos de 0,01 °C de diferencia.

Calibración: convierte tu NTC en un termómetro fiable

1. Mide la resistencia fija: mide con el multímetro el valor real de la resistencia de 10 kΩ y escríbelo en SERIES_R; una desviación del 1 % por sí sola supone unos 0,2 °C de error.
2. Haz el NTC impermeable: no metas en agua un NTC de epoxi desnudo; aísla sus patas con tubo termorretráctil y silicona o usa un NTC ya montado en sonda de acero inoxidable.
3. Punto de 0 °C: llena un vaso hasta arriba de hielo picado, añade un poco de agua fría y remueve. Deja el NTC en el centro del vaso 2–3 minutos y, cuando el valor se estabilice, apunta el valor R del Monitor Serie.
4. Punto a temperatura ambiente: deja el NTC 10 minutos junto a un termómetro digital fiable, en un sitio sin corrientes de aire; apunta la lectura del termómetro y la resistencia del NTC.
5. Punto a alta temperatura: a nivel del mar el agua hierve a 100 °C, pero el punto de ebullición baja alrededor de 1 °C por cada 300 m de altitud (unos 96,7 °C a 1000 m). Sumerge el NTC en agua hirviendo sin que toque el fondo del cazo y apunta la resistencia.
6. Escribe los valores en el código: introduce los tres puntos en el código de Steinhart-Hart. Si solo vas a medir cerca de la temperatura ambiente, muchas veces basta con una corrección de offset de un solo punto (restar la diferencia constante).

Termómetro con NTC en una pantalla LCD

Para mostrar la medida sin ordenador, añadimos una pantalla LCD I2C de 16x2. Conecta el SDA de la pantalla a A4, el SCL a A5, VCC a 5V y GND a GND; el circuito del NTC se queda igual. El código usa la librería LiquidCrystal I2C, que puedes instalar desde el Gestor de Librerías. La dirección de la pantalla suele ser 0x27 y en algunos módulos 0x3F. Para el símbolo de grado imprimimos el carácter 223 de la tabla de caracteres del LCD. Además, la pantalla muestra en la fila inferior la temperatura mínima y máxima medidas desde que se encendió el Arduino.

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}

Termistor NTC con ESP32

El ADC del ESP32 es de 12 bits (0–4095) y el chip funciona a 3,3 V, así que alimenta el divisor desde el pin 3V3. Conecta siempre el NTC a un pin ADC1 (GPIO 32–39); los pines ADC2 no se pueden leer con el Wi-Fi activado. Puedes ver el mapa de pines de tu placa en la herramienta Pinout. Aquí hay una diferencia importante: el ADC del ESP32 no usa la tensión de alimentación como referencia, sino una referencia interna de aproximadamente 1,1 V junto con la atenuación elegida. Por tanto, la medida ratiométrica del Uno no se produce sola y necesitas conocer el valor real de la línea de 3V3. Por eso el código lee milivoltios con analogReadMilliVolts(), que usa los datos de calibración grabados en el chip de fábrica, y calcula la resistencia con el valor de 3V3 que hayas medido con el multímetro. Según la documentación de Espressif, el ESP32 clásico mide 150–3100 mV con la atenuación por defecto de 11 dB, pero la zona recomendada y más lineal es 150–2450 mV. Estos límites fijan el rango de temperatura que puedes medir según el montaje:

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}

Para un termómetro de interior o exterior, el montaje con el NTC arriba es ideal. Si vas a medir por encima de 50 °C, por ejemplo un hervidor, una cafetera o la cama de una impresora 3D, pasa el NTC a la rama inferior y cambia la fórmula a Rntc = Rs × mV / (Vcc − mV). Con el Wi-Fi activo, los picos de consumo del ESP32 provocan pequeñas oscilaciones en la línea de 3V3; promediar 64 lecturas y poner un condensador de 100 nF entre GPIO 34 y GND mejora claramente el resultado. Si empiezas con el ESP32, consulta la configuración en el artículo Qué es el ESP32.

NTC con Raspberry Pi Pico y MicroPython

El ADC de 12 bits de la Pico está en los pines GP26, GP27 y GP28; en MicroPython read_u16() devuelve el resultado escalado a 0–65535. La referencia del ADC de la Pico (ADC_VREF) se obtiene en la placa a partir de la línea de 3,3 V mediante un pequeño filtro RC. Si alimentas también el divisor desde el pin 3V3(OUT), la medida es aproximadamente ratiométrica, como en el Uno, y la fórmula no cambia; solo usas 65535 en lugar de 1023. El ADC de la Pico tiene algo de ruido y da pequeños saltos en ciertos códigos, así que aquí también es imprescindible promediar. Usar AGND (pin 33) como masa analógica reduce un poco el ruido. Si es la primera vez que usas la Pico, encontrarás la instalación de MicroPython en el artículo Qué es la 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)

En MicroPython math.log() también es el logaritmo natural, así que usas la misma fórmula que en el código de Arduino. La Pico tiene además un sensor de temperatura interno (ADC(4)), pero mide la temperatura del propio chip y no la del ambiente, y en funcionamiento suele marcar unos grados de más. Para la temperatura ambiente, un NTC externo es mucho más preciso. Si quieres usar coeficientes de Steinhart-Hart, puedes pasar la función computeCoefficients() del código de Arduino a Python en pocas líneas.

Diferencia entre NTC y PTC

En los termistores PTC (Positive Temperature Coefficient) la resistencia sube con la temperatura. El tipo de PTC más común no se usa para medir sino para proteger: los PTC de conmutación, hechos de cerámica de titanato de bario, mantienen una resistencia baja hasta cierta temperatura (el punto de Curie) y, al superarla, su resistencia aumenta de golpe cientos o miles de veces. Las protecciones contra sobrecalentamiento de los bobinados de motores y los calefactores PTC autorregulados funcionan con este principio. Los fusibles rearmables de polímero (polyfuse) se comportan de forma parecida; el fusible de 500 mA de la línea USB del Arduino Uno es uno de ellos. Los sensores PTC de silicio, como el KTY81, cambian en cambio de forma casi lineal, alrededor del 0,7–0,8 %/°C. Las RTD de platino como la PT100 y la PT1000 también tienen coeficiente positivo, pero son sensores metálicos, no termistores; valen 100 Ω o 1000 Ω a 0 °C, superan los 500 °C y necesitan un amplificador como el MAX31865 para leerse.

Aplicaciones en impresoras 3D y baterías

En las impresoras 3D, tanto la temperatura del hotend como la de la cama se miden casi siempre con termistores NTC. Ahí se usan NTC de 100 kΩ en lugar de 10 kΩ, porque a 250 °C un NTC de 10 kΩ baja hasta unos 35 Ω y la medida pierde resolución; el archivo de configuración del popular firmware Marlin incluso advierte, para el termistor genérico de 10 kΩ, que "no se use en un hotend, ya que da mala resolución a alta temperatura". En placas de 8 bits como RAMPS, las entradas de termistor tienen una resistencia pull-up de 4,7 kΩ a 5 V, y Marlin convierte el valor del ADC en temperatura con tablas predefinidas; uno de los tipos definidos para termistores de 100 kΩ y B3950 es el número 11. Si se rompe el cable del termistor, el ADC lee su valor máximo, el firmware lo interpreta como un frío extremo y muestra Err: MINTEMP; con un cortocircuito aparece Err: MAXTEMP. Si el termistor se sale de su alojamiento, el calentador sigue calentando pero la lectura no sube; Marlin lo detecta con su protección THERMAL RUNAWAY y apaga los calentadores. Nunca desactives esta protección.

Las celdas de iones de litio no deben cargarse por debajo de 0 °C ni por encima de unos 45 °C; cargarlas con frío provoca depósitos de litio metálico dentro de la celda y daños permanentes. Por eso la mayoría de las baterías de móviles, portátiles y bicicletas eléctricas llevan un NTC pegado a las celdas, y el tercer terminal del conector de la batería (marcado como T o NTC) suele ir a ese termistor. El pin 1 (TEMP) del popular chip cargador TP4056 sirve precisamente para esto: según su hoja de datos, si la tensión en este pin está por debajo del 45 % o por encima del 80 % de la tensión de entrada durante más de 0,15 segundos, la carga se detiene. En tu propio proyecto con baterías puedes pegar un NTC a la celda, leerlo con Arduino y cortar el circuito de carga con un MOSFET cuando la temperatura salga de los límites. En las fuentes de alimentación, los NTC grandes de disco limitan la corriente de arranque que entra en los condensadores al encender el aparato; al calentarse, su resistencia baja de unos pocos ohmios a menos de un ohmio, de modo que en funcionamiento normal apenas generan pérdidas.

Ideas de proyectos con termistor NTC

• Termostato de ventilador con histéresis: enciende un ventilador con un módulo de relé cuando la temperatura supere los 30 °C y apágalo al bajar a 28 °C; esos 2 grados de margen evitan que el relé se active y desactive sin parar.
• Termómetro de acuario con sonda impermeable: mide la temperatura del agua con una sonda NTC de acero inoxidable y haz sonar un zumbador si falla el calentador.
• Termómetro de bolsillo con pantalla OLED: muestra la temperatura y una gráfica de la última hora en una pantalla OLED.
• Monitor del cerramiento de la impresora 3D: mide la temperatura dentro del cerramiento y pon en marcha un extractor por encima de 45 °C.
• Vigilante de temperatura de la batería: controla la temperatura de la celda durante la carga, corta la carga fuera de 0–45 °C y avisa con un LED.
• Registrador de temperatura con Wi-Fi: con un ESP32, guarda una lectura cada minuto en una tarjeta SD o muéstrala en una página web que abras desde el móvil.

Errores frecuentes y soluciones

El termistor NTC te enseña a convertir una pieza barata en un termómetro preciso con una sola resistencia y unas pocas líneas de matemáticas: divisor de tensión, ADC, logaritmos y calibración en un mismo proyecto. Usarás el mismo enfoque más adelante con otros sensores analógicos; para suavizar aún más tus lecturas, echa un vistazo a las técnicas de filtrado de datos de sensores. En la app BlueGrays encontrarás la medida de temperatura con NTC y LCD 2x16, temperatura y humedad con el DHT11, una estación de temperatura con ESP32 y LCD y un registrador de temperatura, cada uno con esquemas paso a paso y código listo para usar.