Termistor NTC dengan Arduino: Pengkabelan, Persamaan Beta, dan Steinhart-Hart

Termistor NTC adalah sensor suhu murah berkaki dua yang hambatannya turun ketika makin panas. Untuk memakai termistor NTC dengan Arduino, kamu menyambungkannya dengan resistor tetap 10 kΩ sebagai pembagi tegangan, membaca titik tengahnya di pin analog (A0), menghitung hambatan termistor dari pembacaan itu, lalu mengubahnya ke derajat Celsius dengan persamaan Beta. Tidak perlu library, satu pin analog sudah cukup, dan kalau dirakit dengan benar kamu mendapat resolusi 0,1 °C di suhu ruang. Bed dan hotend printer 3D, baterai ponsel dan laptop, AC, kulkas, serta termometer demam digital juga kebanyakan mengukur suhu dengan termistor NTC.

Di artikel ini kamu akan belajar langkah demi langkah bagaimana hambatan termistor NTC 10 kΩ berubah terhadap suhu, cara memasang pembagi tegangan dan memilih resistor tetap, persamaan Beta dengan B = 3950, persamaan Steinhart-Hart yang lebih akurat, dan kalibrasi tiga titik. Setelah itu kamu akan membuat termometer dengan LCD I2C, mengulang pengukuran dengan ADC ESP32 dan Raspberry Pi Pico, lalu melihat perbedaan NTC dan PTC, aplikasi di printer 3D dan baterai, serta kesalahan yang paling sering terjadi.

Apa itu termistor NTC dan bagaimana cara kerjanya?

Nama termistor berasal dari gabungan “thermal” dan “resistor”: resistor yang nilainya berubah cukup besar terhadap suhu. NTC adalah singkatan dari Negative Temperature Coefficient, yaitu koefisien suhu negatif. Bahannya keramik semikonduktor yang dibuat dengan membakar (sintering) oksida logam seperti mangan, nikel, dan kobalt pada suhu tinggi. Ketika bahan memanas, makin banyak pembawa muatan yang ikut menghantarkan arus, sehingga hambatannya turun. Perubahannya besar: NTC dengan B = 3950 kehilangan sekitar 4,4% hambatannya setiap derajat di sekitar 25 °C. Sebagai perbandingan, resistor metal film biasa hanya berubah 50–100 ppm per derajat, yaitu 0,005–0,01%. Sensitivitas tinggi ini membuat NTC menjadi sensor yang murah tetapi sangat responsif; harganya, hubungannya tidak linear.

Hambatan vs suhu: kenapa tidak linear?

Hambatan NTC berubah secara eksponensial terhadap suhu: turun sangat cepat di suhu dingin dan lebih lambat di suhu panas. Tabel di bawah menunjukkan hambatan NTC 10 kΩ, B = 3950 yang dihitung dengan persamaan Beta, ditambah tegangan dan nilai analogRead yang akan kamu lihat di pin A0 Arduino Uno ketika NTC ini dipasang di lengan atas pembagi tegangan 10 kΩ yang dicatu 5 V (pengkabelan di bagian berikutnya). Kolom terakhir menunjukkan berapa derajat yang diwakili satu langkah ADC, yaitu resolusi pengukurannya. Tabel dari pabrikan untuk NTC sungguhan bisa berbeda beberapa persen dari nilai ini, terutama di ujung-ujung rentang.

Dari tabel ini ada dua kesimpulan penting. Pertama, pembagi tegangan paling sensitif ketika hambatan NTC sama dengan resistor tetap, yang di contoh ini terjadi di sekitar 25 °C: di sana A0 berubah sekitar 55 mV per derajat dan Uno yang 10-bit pun mengukur dengan langkah 0,09 °C. Itu lima kali lebih baik daripada LM35, yang hanya memberi resolusi 0,49 °C dengan referensi 5 V. Kedua, resolusinya makin buruk ketika kamu menjauh dari titik itu; satu langkah menjadi 0,57 °C pada 100 °C dan 1,2 °C pada 125 °C. Jadi pilih resistor tetap yang dekat dengan hambatan NTC pada suhu yang paling sering kamu ukur. Agar ayunan tegangan A0 paling lebar dalam rentang tertentu, resistor tetap sebaiknya bernilai rata-rata geometris dari hambatan NTC di kedua ujung rentang: untuk 0–100 °C hasilnya √(33,6 kΩ × 0,70 kΩ) ≈ 4,8 kΩ, jadi pakai nilai standar 4,7 kΩ; untuk 60–100 °C sekitar 1,3 kΩ, jadi 1,2 kΩ atau 1,5 kΩ.

Pengkabelan termistor NTC: pembagi tegangan (Uno, ESP32, Pico)

Input analog Arduino mengukur tegangan, bukan hambatan. Karena itu NTC dipasang seri dengan resistor tetap sehingga membentuk pembagi tegangan: tegangan di titik pertemuan kedua resistor berubah mengikuti hambatan NTC, dan dengan begitu mengikuti suhu. Rangkaiannya persis sama dengan yang kamu pakai untuk LDR; bedanya hanya resistornya bereaksi terhadap suhu, bukan cahaya. Di kode artikel ini NTC berada di lengan atas (tersambung ke catu daya) dan resistor 10 kΩ di lengan bawah (tersambung ke GND), jadi pembacaan naik ketika makin panas, dan itu terasa intuitif. Kamu bisa menghitung tegangan keluaran untuk berbagai nilai resistor di alat Pembagi tegangan dan mengecek kode warna resistor tetap dengan alat Kode warna.

Rangkaian ini punya sifat yang menyenangkan: pengukurannya rasiometrik. Secara default ADC Uno memakai catu 5 V sebagai referensinya, dan pembagi juga dicatu dari 5 V yang sama. Meskipun USB memberi 4,8 V, bukan 5,0 V, keluaran pembagi dan referensi ADC turun dengan proporsi yang sama sehingga nilai analogRead tidak berubah. Jadi kamu tidak perlu tahu tegangan catu untuk membaca NTC, dan tidak perlu repot dengan tegangan referensi seperti di LM35. Dengan alasan yang sama, jangan pakai analogReference(INTERNAL) di rangkaian NTC: dengan referensi 1,1 V rasionya rusak dan perhitungannya jadi salah. Yang benar-benar menentukan akurasi adalah nilai resistor tetap; resistor 5% saja bisa menyebabkan error sekitar 1 °C. Jadi pakai resistor metal film 1%, atau ukur nilai asli resistormu dengan multimeter lalu masukkan ke kode.

Menghitung suhu dengan persamaan Beta (B = 3950)

Pabrikan menjelaskan NTC dengan dua angka: hambatannya pada 25 °C (R0 = 10 kΩ) dan nilai B-nya (Beta). Dengan dua angka ini persamaan Beta memberi suhu untuk hambatan berapa pun: 1/T = 1/T0 + (1/B) × ln(R/R0). Di sini T dan T0 dalam kelvin (T0 = 25 + 273,15 = 298,15 K) dan ln adalah logaritma natural; kurangi 273,15 untuk mengubah hasilnya ke Celsius. Contoh: kalau NTC terukur 5300 Ω, ln(5300/10000) = −0,635; 1/T = 0,003354 − 0,000161 = 0,003193 dan T = 313,2 K, yaitu sekitar 40 °C. Angka kecil di samping nilai B menunjukkan di antara dua suhu mana nilai itu diukur: B25/50 = 3950 berarti B dihitung dari hambatan pada 25 °C dan 50 °C. Kalau kamu tidak punya datasheet, kamu bisa mencari B sendiri: ukur hambatan pada dua suhu lalu pakai B = ln(R1/R2) / (1/T1 − 1/T2). Misalnya, kalau kamu mengukur 10.000 Ω pada 25 °C dan 3588 Ω pada 50 °C, hasilnya B ≈ 3950.

Pengukuran pertama dengan Arduino, langkah demi langkah

1. Pasang NTC dan resistor 10 kΩ di breadboard; sambungkan satu kaki NTC ke 5V dan kaki lainnya ke salah satu ujung resistor.
2. Sambungkan ujung lain resistor ke GND, lalu tarik kabel jumper dari titik pertemuan NTC dan resistor ke A0.
3. Upload kode di bawah dan buka Serial Monitor di 9600 baud.
4. Di suhu ruang kamu seharusnya melihat nilai sekitar 20–25 °C. Jepit NTC di antara dua jari; dalam beberapa detik nilainya seharusnya naik mendekati 30 °C.
5. Kalau nilainya turun ketika memanas, posisi NTC dan resistor tertukar: perbaiki pengkabelannya atau ganti rumus di kode dengan rumus “NTC di bawah”.

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}

Setiap kali mengukur, kode membaca A0 enam belas kali lalu merata-ratakannya; ini meredam goyangan ADC yang satu atau dua langkah. Kalau rata-ratanya di bawah 1 atau di atas 1022, kabel NTC putus atau korsleting, dan kode mencetak pesan error alih-alih suhu yang tidak bermakna. Setelah itu kode menghitung hambatan NTC dari rata-rata tadi, lalu suhu dari hambatan itu dengan persamaan Beta. Di Arduino, fungsi log() menghasilkan logaritma natural (ln); log10() adalah logaritma basis 10, dan kalau keduanya tertukar, hasilnya akan benar-benar salah begitu kamu menjauh dari 25 °C. Di Serial Monitor kamu akan melihat baris seperti “ADC: 512.3 R: 9969 ohm Sicaklik / Temp: 25.07 C” (Sicaklik adalah bahasa Turki untuk “suhu”).

Persamaan Steinhart-Hart: hasil yang lebih akurat

Persamaan Beta sangat bagus di dalam rentang tempat B diukur (biasanya 25–50 °C), tetapi makin melenceng ketika kamu keluar dari rentang itu, karena nilai B NTC sungguhan sedikit berubah terhadap suhu. Di rentang lebar seperti 0–100 °C, error-nya bisa lebih dari 1 °C. Untuk hasil yang lebih akurat dipakai persamaan Steinhart-Hart dengan tiga koefisien: 1/T = A + B × ln(R) + C × (ln R)³. Persamaan Beta sebenarnya adalah kasus khusus dari persamaan ini dengan C = 0. Koefisiennya dihitung dari tiga nilai hambatan yang diukur pada tiga suhu berbeda; dengan tiga titik yang dipilih dengan baik, persamaan ini biasanya lebih baik dari 0,1 °C di dalam rentang yang dikalibrasi. Daripada menyelesaikan A, B, dan C dengan tangan, kode di bawah menghitung sendiri koefisiennya dari tiga titik hasil ukuranmu, di dalam 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}

Tiga titik di kode hanyalah contoh; ukur NTC milikmu sendiri lalu ganti nilainya. Dengan nilai contoh ini Steinhart-Hart memberi hasil yang tepat pada 0 °C, 25 °C, dan 98,5 °C. Namun kalau hambatan yang sama dimasukkan ke persamaan Beta (B = 3950), titik 0 °C terhitung 0,4 °C dan titik 98,5 °C menjadi 100,4 °C, jadi error-nya sekitar 2 °C di suhu tinggi. Pilih titik di kedua ujung dan di tengah rentang yang akan kamu ukur; di luar rentang yang dikalibrasi (misalnya pada −20 °C dengan koefisien ini) error-nya membesar lagi. Di Uno, float hanya 32 bit, tetapi itu cukup untuk perhitungan ini: hasilnya sama dengan perhitungan presisi ganda (double) dalam selisih 0,01 °C.

Kalibrasi: jadikan NTC-mu termometer yang bisa diandalkan

1. Ukur resistor tetap: ukur nilai asli resistor 10 kΩ dengan multimeter dan masukkan sebagai SERIES_R di kode; penyimpangan 1% saja berarti error sekitar 0,2 °C.
2. Buat NTC tahan air: jangan celupkan NTC epoksi telanjang ke air; isolasi kakinya dengan selongsong bakar (heat shrink) dan silikon, atau pakai NTC siap pakai di dalam probe baja tahan karat.
3. Titik 0 °C: isi gelas sampai penuh dengan es serut, tambahkan sedikit air dingin, lalu aduk. Tahan NTC di tengah gelas selama 2–3 menit dan, begitu nilainya stabil, catat nilai R dari Serial Monitor.
4. Titik suhu ruang: letakkan NTC di samping termometer digital yang bisa dipercaya selama 10 menit di tempat tanpa embusan angin; catat angka di termometer dan hambatan NTC.
5. Titik suhu tinggi: di permukaan laut air mendidih pada 100 °C, tetapi titik didihnya turun sekitar 1 °C setiap kenaikan ketinggian 300 m (sekitar 96,7 °C pada 1000 m). Celupkan NTC ke air mendidih tanpa menyentuh dasar panci dan catat hambatannya.
6. Masukkan nilainya ke kode: isi ketiga titik ke kode Steinhart-Hart. Kalau kamu hanya akan mengukur di sekitar suhu ruang, koreksi offset satu titik (mengurangkan selisih yang tetap) sering kali sudah cukup.

Termometer NTC dengan LCD

Supaya hasil ukur bisa tampil tanpa komputer, mari tambahkan LCD I2C 16x2. Sambungkan pin SDA layar ke A4, SCL ke A5, VCC ke 5V, dan GND ke GND; rangkaian NTC tetap sama. Kodenya memakai library LiquidCrystal I2C yang bisa kamu instal dari Library Manager. Alamat layar biasanya 0x27, di beberapa modul 0x3F. Untuk simbol derajat, kita mencetak karakter 223 dari tabel karakter LCD. Di baris bawah, layar juga menampilkan suhu terendah dan tertinggi yang terukur sejak Arduino dinyalakan.

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

ADC ESP32 punya resolusi 12-bit (0–4095) dan chip-nya bekerja di 3,3 V, jadi catu pembagi dari pin 3V3. Selalu sambungkan NTC ke pin ADC1 (GPIO 32–39); pin ADC2 tidak bisa dibaca ketika Wi-Fi menyala. Peta pin board-mu bisa kamu lihat di alat Pinout. Ada perbedaan penting di sini: ADC ESP32 tidak memakai tegangan catu sebagai referensi, melainkan referensi internal sekitar 1,1 V ditambah atenuasi (attenuation) yang dipilih. Jadi pengukuran rasiometrik yang kamu dapat di Uno tidak terjadi dengan sendirinya, dan kamu perlu tahu nilai asli jalur 3V3. Karena itu kode membaca milivolt dengan analogReadMilliVolts(), yang memakai data kalibrasi yang ditulis ke chip di pabrik, dan menghitung hambatan dari nilai 3V3 yang kamu ukur dengan multimeter. Menurut dokumentasi Espressif, ESP32 klasik bisa mengukur 150–3100 mV pada atenuasi default 11 dB, tetapi daerah yang disarankan dan paling linear adalah 150–2450 mV. Batas ini menentukan rentang suhu yang bisa kamu ukur, tergantung pengkabelannya:

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}

Untuk termometer dalam atau luar ruangan, pengkabelan NTC di atas paling ideal. Kalau kamu akan mengukur di atas 50 °C, misalnya ketel listrik, mesin kopi, atau bed printer 3D, pindahkan NTC ke lengan bawah dan ganti rumusnya menjadi Rntc = Rs × mV / (Vcc − mV). Ketika Wi-Fi menyala, lonjakan arus ESP32 menimbulkan riak kecil di jalur 3V3; merata-ratakan 64 pembacaan dan menambahkan kapasitor 100 nF di antara GPIO 34 dan GND memperbaiki hasilnya dengan jelas. Kalau kamu baru mengenal ESP32, baca artikel Apa Itu ESP32? untuk pengaturannya.

NTC dengan Raspberry Pi Pico dan MicroPython

ADC 12-bit Pico ada di pin GP26, GP27, dan GP28; di MicroPython read_u16() mengembalikan hasil yang sudah diskalakan ke 0–65535. Referensi ADC Pico (ADC_VREF) diambil di board dari jalur 3,3 V melalui filter RC kecil. Kalau pembagi juga dicatu dari pin 3V3(OUT), pengukurannya kurang lebih rasiometrik seperti di Uno dan rumusnya tetap sama; kamu cukup memakai 65535 alih-alih 1023. ADC Pico sedikit berderau dan agak meloncat di kode-kode tertentu, jadi merata-ratakan pembacaan juga wajib di sini. Memakai AGND (pin 33) sebagai ground analog sedikit mengurangi derau. Kalau ini pertama kalinya kamu memakai Pico, cara instal MicroPython ada di artikel Apa Itu 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)

Di MicroPython, math.log() juga logaritma natural, jadi kamu memakai rumus yang sama dengan kode Arduino. Pico juga punya sensor suhu bawaan (ADC(4)), tetapi sensor itu mengukur suhu chip-nya sendiri, bukan sekelilingnya, dan biasanya terbaca beberapa derajat lebih tinggi ketika sedang bekerja. Untuk suhu lingkungan, NTC eksternal jauh lebih akurat. Kalau kamu ingin memakai koefisien Steinhart-Hart, fungsi computeCoefficients() dari kode Arduino bisa kamu terjemahkan ke Python dalam beberapa baris.

NTC vs PTC: apa bedanya?

Pada termistor PTC (Positive Temperature Coefficient), hambatannya naik ketika suhu naik. Jenis PTC yang paling umum dipakai untuk proteksi, bukan pengukuran: PTC switching dari keramik barium titanat tetap berhambatan rendah sampai suhu tertentu (titik Curie), lalu di atasnya hambatannya tiba-tiba melonjak ratusan sampai ribuan kali. Proteksi panas berlebih di lilitan motor dan pemanas PTC yang membatasi suhunya sendiri bekerja dengan prinsip ini. Sekring yang bisa pulih sendiri berbahan polimer (polyfuse) berperilaku mirip; sekring 500 mA di jalur USB Arduino Uno adalah salah satunya. Sebaliknya, sensor PTC silikon seperti KTY81 berubah hampir linear sekitar 0,7–0,8%/°C. RTD platina seperti PT100 dan PT1000 juga punya koefisien positif, tetapi itu sensor logam, bukan termistor; nilainya 100 Ω atau 1000 Ω pada 0 °C, bisa dipakai di atas 500 °C, dan perlu penguat seperti MAX31865 untuk dibaca.

Aplikasi di printer 3D dan baterai

Di printer 3D, suhu hotend dan bed kebanyakan diukur dengan termistor NTC. Di sini dipakai NTC 100 kΩ, bukan 10 kΩ, karena pada 250 °C NTC 10 kΩ turun ke sekitar 35 Ω dan pengukurannya kehilangan resolusi; file konfigurasi firmware Marlin yang populer bahkan memberi peringatan untuk termistor generik 10 kΩ: “do not use for a hotend, it gives bad resolution at high temp” (jangan dipakai untuk hotend, resolusinya buruk di suhu tinggi). Di board 8-bit seperti RAMPS, input termistor ditarik ke 5 V dengan resistor pull-up 4,7 kΩ, dan Marlin mengubah nilai ADC menjadi suhu dengan tabel siap pakai; salah satu tipe yang didefinisikan untuk termistor 100 kΩ B3950 adalah nomor 11. Kalau kabel termistor putus, ADC membaca nilai maksimumnya, firmware menganggapnya dingin ekstrem dan menampilkan Err: MINTEMP; kalau korsleting, muncul Err: MAXTEMP. Kalau termistor terlepas dari dudukannya, pemanas terus memanas tetapi nilai terukur tidak naik; Marlin menangkap ini dengan proteksi THERMAL RUNAWAY dan mematikan pemanas. Jangan pernah menonaktifkan proteksi ini.

Sel lithium-ion tidak boleh diisi di bawah 0 °C atau di atas sekitar 45 °C; mengisi daya dalam suhu dingin membuat lithium logam menumpuk di dalam sel dan menyebabkan kerusakan permanen. Karena itu kebanyakan baterai ponsel, laptop, dan sepeda listrik punya NTC yang ditempel ke selnya, dan terminal ketiga di konektor baterai (bertanda T atau NTC) biasanya menuju termistor ini. Pin 1 (TEMP) pada chip charger TP4056 yang populer memang ada untuk tugas ini: menurut datasheet-nya, kalau tegangan di pin ini berada di bawah 45% atau di atas 80% tegangan input lebih dari 0,15 detik, pengisian dihentikan sementara. Di proyek baterai buatanmu sendiri, kamu bisa menempelkan NTC ke sel, membacanya dengan Arduino, dan memutus rangkaian pengisian dengan MOSFET ketika suhunya keluar dari batas. Di catu daya, NTC cakram yang besar membatasi arus lonjakan awal yang mengalir ke kapasitor ketika perangkat dinyalakan; begitu memanas, hambatannya turun dari beberapa ohm ke di bawah satu ohm, jadi rugi dayanya sangat kecil dalam operasi normal.

Ide proyek dengan termistor NTC

• Termostat kipas dengan histeresis: nyalakan kipas dengan modul relay ketika suhu melewati 30 °C dan matikan ketika turun ke 28 °C; selisih 2 derajat itu mencegah relay terus berbunyi klik nyala-mati.
• Termometer akuarium dengan probe tahan air: ukur suhu air dengan probe NTC baja tahan karat dan bunyikan buzzer kalau pemanasnya rusak.
• Termometer saku dengan layar OLED: tampilkan suhu dan grafik satu jam terakhir di layar OLED.
• Pemantau enclosure printer 3D: ukur suhu di dalam enclosure yang tertutup dan nyalakan kipas pembuangan di atas 45 °C.
• Penjaga suhu baterai: pantau suhu sel selama pengisian, putus pengisian di luar 0–45 °C, dan beri peringatan dengan LED.
• Pencatat suhu Wi-Fi: dengan ESP32, tulis satu pembacaan setiap menit ke kartu SD atau tampilkan di halaman web yang kamu buka di ponsel.

Kesalahan umum dan cara memperbaikinya

Termistor NTC mengajarimu mengubah komponen murah menjadi termometer yang akurat hanya dengan satu resistor dan beberapa baris matematika: pembagi tegangan, ADC, logaritma, dan kalibrasi sekaligus. Pendekatan yang sama nanti akan kamu pakai untuk sensor analog lain; supaya pembacaanmu makin halus, lihat juga teknik menyaring data sensor. Di aplikasi BlueGrays kamu bisa menemukan proyek Mengukur Suhu dengan NTC dan Layar LCD 2x16, Suhu dan Kelembapan dengan DHT11, stasiun suhu ESP32 dengan LCD, dan pencatat data suhu, masing-masing dengan skema rangkaian langkah demi langkah dan kode siap pakai.