Termistor NTC com Arduino: ligação, Beta e Steinhart-Hart

O termistor NTC é um sensor de temperatura barato, de dois terminais, cuja resistência diminui conforme ele esquenta. Para usar um termistor NTC com Arduino, você o liga com um resistor fixo de 10 kΩ formando um divisor de tensão, lê o ponto central em um pino analógico (A0), calcula a resistência do termistor a partir dessa leitura e converte o valor em graus Celsius com a equação Beta. Não precisa de biblioteca, um pino analógico basta e, com tudo bem montado, você chega a 0,1 °C de resolução na temperatura ambiente. A mesa e o hotend das impressoras 3D, as baterias de celulares e notebooks, os aparelhos de ar-condicionado, as geladeiras e os termômetros clínicos digitais também medem a temperatura, na maioria das vezes, com termistores NTC.

Neste artigo você vai aprender, passo a passo, como a resistência de um termistor NTC de 10 kΩ varia com a temperatura, como ligar o divisor de tensão e escolher o resistor fixo, a equação Beta com B = 3950, a equação de Steinhart-Hart, mais precisa, e a calibração em três pontos. Depois você vai montar um termômetro com LCD I2C, repetir a medição com o ADC do ESP32 e do Raspberry Pi Pico e ver a diferença entre NTC e PTC, aplicações em impressoras 3D e baterias e os erros mais comuns.

O que é um termistor NTC e como ele funciona?

O nome termistor junta “thermal” (térmico) e “resistor”: é um resistor cujo valor muda bastante com a temperatura. NTC significa Negative Temperature Coefficient, ou coeficiente de temperatura negativo. Ele é feito de uma cerâmica semicondutora obtida pela queima (sinterização) de óxidos metálicos como manganês, níquel e cobalto em alta temperatura. À medida que o material esquenta, mais portadores de carga participam da condução, e a resistência cai. A variação é grande: um NTC com B = 3950 perde cerca de 4,4% da resistência a cada grau em torno de 25 °C. Para comparar, um resistor de filme metálico comum varia apenas 50–100 ppm por grau, ou seja, 0,005–0,01%. Essa alta sensibilidade faz do NTC um sensor barato, mas muito sensível; o preço a pagar é que a relação não é linear.

Resistência x temperatura: por que não é linear?

A resistência do NTC varia de forma exponencial com a temperatura: cai muito rápido no frio e mais devagar no calor. A tabela abaixo mostra a resistência de um NTC de 10 kΩ e B = 3950 calculada com a equação Beta, além da tensão e do valor de analogRead que você verá no pino A0 do Arduino Uno quando esse NTC estiver no braço superior de um divisor de tensão de 10 kΩ alimentado por 5 V (a ligação da próxima seção). A última coluna mostra quantos graus correspondem a um degrau do ADC, ou seja, a resolução da medição. As tabelas reais dos fabricantes podem diferir desses valores em alguns por cento, principalmente nas extremidades da faixa.

A tabela leva a duas conclusões importantes. Primeiro, o divisor de tensão é mais sensível quando a resistência do NTC é igual à do resistor fixo, o que neste exemplo acontece por volta de 25 °C: ali, A0 varia cerca de 55 mV por grau e até o Uno de 10 bits mede em degraus de 0,09 °C. Isso é cinco vezes melhor que o LM35, que dá só 0,49 °C de resolução com a referência de 5 V. Segundo, a resolução piora à medida que você se afasta desse ponto; um degrau passa a valer 0,57 °C a 100 °C e 1,2 °C a 125 °C. Por isso, escolha o resistor fixo perto da resistência do NTC na temperatura que você mais vai medir. Para obter a maior excursão de A0 em uma faixa específica, o resistor fixo deve ser a média geométrica das resistências do NTC nas duas extremidades da faixa: para 0–100 °C, √(33,6 kΩ × 0,70 kΩ) ≈ 4,8 kΩ, ou seja, um 4,7 kΩ padrão; para 60–100 °C, cerca de 1,3 kΩ, ou seja, 1,2 kΩ ou 1,5 kΩ.

Ligação do termistor NTC: divisor de tensão (Uno, ESP32, Pico)

As entradas analógicas do Arduino medem tensão, não resistência. Por isso você coloca o NTC em série com um resistor fixo, formando um divisor de tensão: a tensão no ponto onde os dois resistores se encontram varia com a resistência do NTC e, portanto, com a temperatura. É exatamente o mesmo circuito usado com um LDR; a única diferença é que o resistor reage à temperatura em vez da luz. Nos códigos deste artigo, o NTC fica no braço superior (ligado à alimentação) e o resistor de 10 kΩ no braço inferior (ligado ao GND), então a leitura sobe conforme esquenta, o que é intuitivo. Você pode calcular a tensão de saída para diferentes valores de resistor na ferramenta Divisor de tensão e conferir o código de cores do resistor fixo com a ferramenta Código de cores.

Esse circuito tem uma propriedade interessante: ele faz uma medição raciométrica. Por padrão, o ADC do Uno usa a alimentação de 5 V como referência, e o divisor é alimentado pelos mesmos 5 V. Mesmo que o USB entregue 4,8 V em vez de 5,0 V, a saída do divisor e a referência do ADC caem na mesma proporção e o valor de analogRead não muda. Por isso, você não precisa saber a tensão de alimentação para ler um NTC, nem brigar com a tensão de referência como no LM35. Pelo mesmo motivo, não use analogReference(INTERNAL) em um circuito com NTC: com referência de 1,1 V, a proporção se perde e o cálculo dá errado. O que realmente define a precisão é o valor do resistor fixo; um resistor de 5% sozinho pode causar cerca de 1 °C de erro. Então use um resistor de filme metálico de 1%, ou meça o valor real do seu resistor com um multímetro e coloque esse valor no código.

Cálculo da temperatura com a equação Beta (B = 3950)

Os fabricantes descrevem um NTC com dois números: a resistência a 25 °C (R0 = 10 kΩ) e o valor B (Beta). Com esses dois números, a equação Beta dá a temperatura para qualquer resistência: 1/T = 1/T0 + (1/B) × ln(R/R0). Aqui T e T0 estão em kelvin (T0 = 25 + 273,15 = 298,15 K) e ln é o logaritmo natural; para converter o resultado em Celsius, subtraia 273,15. Exemplo: se o NTC medir 5300 Ω, ln(5300/10000) = −0,635; 1/T = 0,003354 − 0,000161 = 0,003193 e T = 313,2 K, ou seja, cerca de 40 °C. Os números pequenos ao lado do valor B indicam entre quais duas temperaturas ele foi medido: B25/50 = 3950 significa que B foi calculado a partir das resistências a 25 °C e 50 °C. Se você não tiver o datasheet, pode descobrir o B por conta própria: meça a resistência em duas temperaturas e use B = ln(R1/R2) / (1/T1 − 1/T2). Por exemplo, se medir 10.000 Ω a 25 °C e 3588 Ω a 50 °C, você obtém B ≈ 3950.

Primeira medição com Arduino, passo a passo

1. Encaixe o NTC e o resistor de 10 kΩ na protoboard; ligue um terminal do NTC ao 5V e o outro a uma ponta do resistor.
2. Ligue a outra ponta do resistor ao GND e passe um jumper do ponto onde o NTC e o resistor se encontram até o A0.
3. Carregue o código abaixo e abra o Monitor Serial a 9600 baud.
4. Na temperatura ambiente, você deve ver um valor em torno de 20–25 °C. Segure o NTC entre dois dedos; em poucos segundos o valor deve subir em direção a 30 °C.
5. Se o valor cair quando esquenta, o NTC e o resistor estão trocados: corrija a ligação ou substitua a fórmula do código pela fórmula “NTC embaixo”.

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 cada medição, o código lê o A0 dezesseis vezes e tira a média; isso suaviza a oscilação de um ou dois degraus do ADC. Se a média ficar abaixo de 1 ou acima de 1022, o fio do NTC está rompido ou em curto, e o código mostra uma mensagem de erro em vez de uma temperatura sem sentido. Em seguida, ele calcula a resistência do NTC a partir da média e, com ela, a temperatura pela equação Beta. No Arduino, a função log() retorna o logaritmo natural (ln); log10() é o logaritmo na base 10, e confundir os dois deixa o resultado completamente errado à medida que você se afasta de 25 °C. No Monitor Serial você verá linhas como “ADC: 512.3 R: 9969 ohm Sicaklik / Temp: 25.07 C”.

A equação de Steinhart-Hart: um resultado mais preciso

A equação Beta é muito boa dentro da faixa em que o B foi medido (geralmente 25–50 °C), mas se desvia à medida que você se afasta dela, porque o valor B de um NTC real varia um pouco com a temperatura. Em uma faixa ampla como 0–100 °C, o erro pode passar de 1 °C. Para um resultado mais preciso, usa-se a equação de Steinhart-Hart, com três coeficientes: 1/T = A + B × ln(R) + C × (ln R)³. A equação Beta é, na verdade, o caso particular dessa equação com C = 0. Os coeficientes são calculados a partir de três valores de resistência medidos em três temperaturas diferentes; com três pontos bem escolhidos, a equação fica tipicamente melhor que 0,1 °C dentro da faixa calibrada. Em vez de resolver A, B e C à mão, o código abaixo calcula os coeficientes a partir dos seus três pontos medidos, dentro do 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}

Os três pontos do código são exemplos; meça o seu próprio NTC e substitua os valores. Com esses valores de exemplo, Steinhart-Hart dá o resultado exato a 0 °C, 25 °C e 98,5 °C. Já se você colocar as mesmas resistências na equação Beta (B = 3950), o ponto de 0 °C sai como 0,4 °C e o de 98,5 °C como 100,4 °C, um erro de cerca de 2 °C em alta temperatura. Escolha pontos nas duas extremidades e no meio da faixa que você vai medir; fora da faixa calibrada (por exemplo, a −20 °C com esses coeficientes) o erro volta a crescer. No Uno, um float tem só 32 bits, mas isso basta para esse cálculo: os resultados coincidem com um cálculo de precisão dupla dentro de 0,01 °C.

Calibração: transforme seu NTC em um termômetro confiável

1. Meça o resistor fixo: meça o valor real do resistor de 10 kΩ com um multímetro e coloque-o em SERIES_R no código; um desvio de 1% sozinho significa cerca de 0,2 °C de erro.
2. Deixe o NTC à prova d'água: não mergulhe um NTC de epóxi desprotegido na água; isole os terminais com tubo termorretrátil e silicone, ou use um NTC pronto em sonda de aço inox.
3. Ponto de 0 °C: encha um copo até a borda com gelo picado, adicione um pouco de água gelada e mexa. Mantenha o NTC no meio do copo por 2–3 minutos e, quando o valor estabilizar, anote o valor de R no Monitor Serial.
4. Ponto de temperatura ambiente: deixe o NTC ao lado de um termômetro digital confiável por 10 minutos, em um lugar sem corrente de ar; anote a leitura do termômetro e a resistência do NTC.
5. Ponto de alta temperatura: ao nível do mar, a água ferve a 100 °C, mas o ponto de ebulição cai cerca de 1 °C a cada 300 m de altitude (cerca de 96,7 °C a 1000 m). Mergulhe o NTC na água fervendo sem encostar no fundo da panela e anote a resistência.
6. Coloque os valores no código: insira os três pontos no código de Steinhart-Hart. Se você só vai medir em torno da temperatura ambiente, uma correção de offset em um único ponto (subtrair a diferença constante) muitas vezes já basta.

Termômetro NTC com display LCD

Para mostrar a leitura sem computador, vamos adicionar um LCD I2C 16x2. Ligue o pino SDA do display ao A4, o SCL ao A5, o VCC ao 5V e o GND ao GND; o circuito do NTC continua igual. O código usa a biblioteca LiquidCrystal I2C, que você pode instalar pelo Gerenciador de Bibliotecas. O endereço do display costuma ser 0x27, e em alguns módulos 0x3F. Para o símbolo de grau, imprimimos o caractere 223 da tabela de caracteres do LCD. Na linha de baixo, o display também mostra a menor e a maior temperatura medidas desde que o Arduino foi ligado.

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 com ESP32

O ADC do ESP32 é de 12 bits (0–4095) e o chip funciona com 3,3 V, então alimente o divisor pelo pino 3V3. Ligue o NTC sempre em um pino ADC1 (GPIO 32–39); os pinos ADC2 não podem ser lidos com o Wi-Fi ligado. Você pode ver o mapa de pinos da sua placa na ferramenta Pinagem. Há uma diferença importante aqui: o ADC do ESP32 não usa a tensão de alimentação como referência, e sim uma referência interna de cerca de 1,1 V mais a atenuação selecionada. Então a medição raciométrica que você tem no Uno não acontece automaticamente, e você precisa saber o valor real da linha de 3V3. Por isso, o código lê milivolts com analogReadMilliVolts(), que usa os dados de calibração gravados no chip na fábrica, e calcula a resistência a partir do valor de 3V3 que você mediu com o multímetro. Segundo a documentação da Espressif, o ESP32 clássico consegue medir 150–3100 mV com a atenuação padrão de 11 dB, mas a região recomendada e mais linear é 150–2450 mV. Esses limites definem a faixa de temperatura que você pode medir, dependendo da ligação:

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 um termômetro interno ou externo, a ligação com o NTC em cima é a ideal. Se você vai medir acima de 50 °C, por exemplo uma chaleira elétrica, uma cafeteira ou a mesa de uma impressora 3D, passe o NTC para o braço inferior e mude a fórmula para Rntc = Rs × mV / (Vcc − mV). Com o Wi-Fi ligado, os picos de corrente do ESP32 causam pequenas oscilações na linha de 3V3; tirar a média de 64 leituras e colocar um capacitor de 100 nF entre o GPIO 34 e o GND melhora o resultado de forma visível. Se você está começando com o ESP32, leia o artigo O que é o ESP32 para fazer a configuração.

NTC com Raspberry Pi Pico e MicroPython

O ADC de 12 bits do Pico fica nos pinos GP26, GP27 e GP28; no MicroPython, read_u16() retorna o resultado em escala de 0–65535. A referência do ADC do Pico (ADC_VREF) é obtida na própria placa a partir da linha de 3,3 V, por meio de um pequeno filtro RC. Se você também alimentar o divisor pelo pino 3V3(OUT), a medição fica aproximadamente raciométrica, como no Uno, e a fórmula continua a mesma; basta usar 65535 no lugar de 1023. O ADC do Pico é um pouco ruidoso e dá pequenos saltos em certos códigos, então tirar a média é essencial aqui também. Usar o AGND (pino 33) como terra analógico reduz um pouco o ruído. Se é a primeira vez que você usa o Pico, a instalação do MicroPython está no artigo O que é o 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)

No MicroPython, math.log() também é o logaritmo natural, então você usa a mesma fórmula do código do Arduino. O Pico também tem um sensor de temperatura interno (ADC(4)), mas ele mede a temperatura do próprio chip, não do ambiente, e costuma marcar alguns graus a mais durante o funcionamento. Para a temperatura ambiente, um NTC externo é muito mais preciso. Se quiser usar os coeficientes de Steinhart-Hart, você pode traduzir a função computeCoefficients() do código do Arduino para Python em poucas linhas.

NTC x PTC: qual é a diferença?

Nos termistores PTC (Positive Temperature Coefficient), a resistência aumenta com a temperatura. O tipo mais comum de PTC é usado para proteção, não para medição: PTCs de chaveamento feitos de cerâmica de titanato de bário mantêm resistência baixa até certa temperatura (o ponto de Curie) e, acima dela, a resistência salta de repente centenas ou milhares de vezes. As proteções contra superaquecimento em enrolamentos de motores e os aquecedores PTC autolimitantes funcionam por esse princípio. Os fusíveis rearmáveis de polímero (polyfuses) se comportam de forma parecida; o fusível de 500 mA na linha USB do Arduino Uno é um deles. Já sensores PTC de silício como o KTY81 variam de forma quase linear, cerca de 0,7–0,8%/°C. RTDs de platina como o PT100 e o PT1000 também têm coeficiente positivo, mas são sensores metálicos, não termistores; eles medem 100 Ω ou 1000 Ω a 0 °C, podem passar de 500 °C e precisam de um amplificador como o MAX31865 para serem lidos.

Aplicações em impressoras 3D e baterias

Nas impressoras 3D, tanto a temperatura do hotend quanto a da mesa são medidas, na maioria das vezes, com termistores NTC. Aqui se usam NTCs de 100 kΩ em vez de 10 kΩ, porque a 250 °C um NTC de 10 kΩ cai para cerca de 35 Ω e a medição perde a resolução; o arquivo de configuração do popular firmware Marlin chega a avisar, sobre o termistor genérico de 10 kΩ: “do not use for a hotend, it gives bad resolution at high temp” (não use no hotend, a resolução é ruim em alta temperatura). Em placas de 8 bits como a RAMPS, as entradas de termistor têm pull-up de 4,7 kΩ para 5 V, e o Marlin converte o valor do ADC em temperatura usando tabelas prontas; um dos tipos definidos para termistores de 100 kΩ B3950 é o número 11. Se o fio do termistor romper, o ADC lê o valor máximo, o firmware interpreta isso como frio extremo e mostra Err: MINTEMP; com um curto-circuito, aparece Err: MAXTEMP. Se o termistor escapar do encaixe, o aquecedor continua aquecendo, mas o valor medido não sobe; o Marlin detecta isso com a proteção THERMAL RUNAWAY e desliga os aquecedores. Nunca desative essa proteção.

Células de íon-lítio não devem ser carregadas abaixo de 0 °C nem acima de cerca de 45 °C; carregar no frio faz lítio metálico se acumular dentro da célula e causa danos permanentes. Por isso, a maioria das baterias de celulares, notebooks e bicicletas elétricas tem um NTC colado nas células, e o terceiro terminal do conector da bateria (marcado T ou NTC) geralmente vai para esse termistor. O pino 1 (TEMP) do popular CI carregador TP4056 serve exatamente para isso: segundo o datasheet, se a tensão nesse pino ficar abaixo de 45% ou acima de 80% da tensão de entrada por mais de 0,15 segundo, a carga é suspensa. No seu próprio projeto com bateria, você pode colar um NTC na célula, lê-lo com um Arduino e cortar o circuito de carga com um MOSFET quando a temperatura sair dos limites. Nas fontes de alimentação, NTCs grandes tipo disco limitam a corrente de partida que flui para os capacitores quando o aparelho é ligado; conforme esquentam, a resistência cai de alguns ohms para menos de um ohm, então eles causam pouquíssima perda no funcionamento normal.

Ideias de projetos com termistor NTC

• Termostato de ventoinha com histerese: ligue uma ventoinha com um módulo relé quando a temperatura passar de 30 °C e desligue quando cair para 28 °C; a diferença de 2 graus impede que o relé fique ligando e desligando o tempo todo.
• Termômetro de aquário com sonda à prova d'água: meça a temperatura da água com uma sonda NTC de aço inox e acione um buzzer se o aquecedor falhar.
• Termômetro de bolso com display OLED: mostre a temperatura e um gráfico da última hora em um display OLED.
• Monitor do gabinete da impressora 3D: meça a temperatura dentro do gabinete fechado e ligue uma ventoinha de exaustão acima de 45 °C.
• Guarda de temperatura da bateria: acompanhe a temperatura da célula durante a carga, corte a carga fora da faixa de 0–45 °C e avise com um LED.
• Registrador de temperatura com Wi-Fi: com um ESP32, grave uma leitura por minuto em um cartão SD ou mostre-a em uma página web que você abre no celular.

Erros comuns e como corrigir

O termistor NTC ensina a transformar uma peça barata em um termômetro preciso com um único resistor e algumas linhas de matemática: divisor de tensão, ADC, logaritmos e calibração, tudo junto. Você vai usar a mesma abordagem com outros sensores analógicos mais adiante; para deixar suas leituras ainda mais suaves, dê uma olhada nas técnicas de filtragem de dados de sensores. No app BlueGrays você encontra medição de temperatura com NTC e LCD 2x16, temperatura e umidade com o DHT11, uma estação de temperatura com ESP32 e LCD e um registrador de temperatura, cada um com esquemas do circuito passo a passo e código pronto para usar.