NTC Termistör Arduino: Sıcaklık Ölçme, Beta ve Steinhart-Hart

NTC termistör, sıcaklık arttıkça direnci azalan, iki bacaklı ve çok ucuz bir sıcaklık sensörüdür. NTC termistörü Arduino ile kullanmak için onu sabit bir 10 kΩ dirençle gerilim bölücü olarak bağlar, orta noktayı bir analog pinden (A0) okur, bu değerden termistörün direncini bulur ve Beta denklemiyle santigrat dereceye çevirirsin. Kütüphane gerekmez, tek bir analog pin yeter ve doğru kurulduğunda oda sıcaklığında 0,1 °C çözünürlüğe ulaşır. 3D yazıcıların tablası ve nozulu, telefon ve dizüstü bilgisayar bataryaları, klimalar, buzdolapları ve dijital ateş ölçerler de sıcaklığı çoğunlukla NTC termistörlerle ölçer.

Bu yazıda 10 kΩ'luk NTC termistörün direnç-sıcaklık ilişkisini, gerilim bölücü bağlantısını ve sabit direnç seçimini, B = 3950 değeriyle Beta denklemini, daha hassas Steinhart-Hart denklemini ve üç noktalı kalibrasyonu adım adım öğreneceksin. Ardından I2C LCD ekranlı bir termometre yapacak, aynı ölçümü ESP32 ve Raspberry Pi Pico'nun ADC'siyle tekrarlayacak, NTC ile PTC arasındaki farkı, 3D yazıcı ve batarya uygulamalarını ve en sık yapılan hataları göreceksin.

NTC termistör nedir, nasıl çalışır?

Termistör adı, İngilizcedeki "thermal" (ısıl) ve "resistor" (direnç) kelimelerinin birleşiminden gelir: direnci sıcaklıkla belirgin biçimde değişen bir dirençtir. NTC, Negative Temperature Coefficient yani negatif sıcaklık katsayısı demektir. Mangan, nikel ve kobalt gibi metal oksitlerin yüksek sıcaklıkta pişirilmesiyle (sinterleme) elde edilen yarı iletken bir seramikten üretilir. Isındıkça malzemede iletime katılan yük taşıyıcılarının sayısı artar, bu yüzden direnç düşer. Değişim çok büyüktür: B = 3950 olan bir NTC'nin direnci 25 °C civarında her derecede yaklaşık %4,4 azalır. Karşılaştırma için sıradan bir metal film direncin değeri derece başına yalnızca 50–100 ppm, yani on binde yarım ile bir arasında değişir. Bu yüksek hassasiyet NTC'yi ucuz ama çok duyarlı bir sensör yapar; bedeli ise ilişkinin doğrusal olmamasıdır.

Direnç-sıcaklık ilişkisi: neden doğrusal değil?

NTC'nin direnci sıcaklıkla üstel olarak değişir: soğukta çok hızlı, sıcakta daha yavaş azalır. Aşağıdaki tablo, 10 kΩ ve B = 3950 bir NTC'nin Beta denklemiyle hesaplanan direncini ve bu NTC'yi 5 V ile beslenen, 10 kΩ'luk bir gerilim bölücünün üst koluna bağladığında (bir sonraki bölümdeki bağlantı) Arduino Uno'nun A0 pininde göreceğin gerilimi ve analogRead değerini gösterir. Son sütun, ADC'deki bir basamaklık değişimin kaç dereceye karşılık geldiğini, yani ölçümün çözünürlüğünü verir. Gerçek NTC'lerin üretici tabloları bu değerlerden özellikle aralığın uçlarında birkaç yüzde sapabilir.

Tablodan iki önemli sonuç çıkar. Birincisi, gerilim bölücü en duyarlı hâlini NTC'nin direnci sabit dirence eşit olduğunda, yani bu örnekte 25 °C civarında gösterir: orada sıcaklık her derece arttığında A0 gerilimi yaklaşık 55 mV değişir ve 10 bitlik Uno bile 0,09 °C'lik adımlarla ölçer. Bu, 5 V referansla yalnızca 0,49 °C çözünürlük veren LM35'ten beş kat iyidir. İkincisi, bu noktadan uzaklaştıkça çözünürlük bozulur; 100 °C'de bir basamak 0,57 °C'ye, 125 °C'de 1,2 °C'ye çıkar. Bu yüzden sabit direnci, en çok ölçeceğin sıcaklıktaki NTC direncine yakın seçmelisin. Belirli bir aralıkta A0 geriliminin en geniş salınımı yapması için sabit direnç, aralığın iki ucundaki NTC dirençlerinin geometrik ortalaması olmalıdır: 0–100 °C için √(33,6 kΩ × 0,70 kΩ) ≈ 4,8 kΩ, yani standart 4,7 kΩ; 60–100 °C için yaklaşık 1,3 kΩ, yani 1,2 kΩ ya da 1,5 kΩ.

NTC termistör bağlantısı: gerilim bölücü (Uno, ESP32, Pico)

Arduino'nun analog girişleri direnci değil gerilimi ölçer. Bu yüzden NTC'yi sabit bir dirençle seri bağlayıp bir gerilim bölücü kurarsın: iki direncin birleştiği noktadaki gerilim, NTC'nin direncine, dolayısıyla sıcaklığa göre değişir. LDR ile kullandığın devrenin aynısıdır; tek fark, ışık yerine sıcaklığa duyarlı bir direnç kullanmandır. Bu yazıdaki kodlarda NTC üst kolda (beslemeye bağlı), 10 kΩ direnç alt kolda (GND'ye bağlı) durur; böylece ısındıkça okunan değer artar ve sonuç sezgisel olur. Farklı direnç değerleriyle çıkış gerilimini Gerilim bölücü aracında hesaplayabilir, sabit direncin renk kodunu Direnç renk kodu aracıyla kontrol edebilirsin.

Bu devrenin güzel bir özelliği vardır: oranlı (ratiometric) ölçüm yapar. Uno'nun ADC'si varsayılan olarak 5 V beslemeyi referans alır ve bölücü de aynı 5 V'tan beslenir. USB'den gelen gerilim 5,0 yerine 4,8 V olsa bile hem bölücünün çıkışı hem de ADC'nin referansı aynı oranda düşer ve analogRead değeri değişmez. Bu yüzden NTC ölçümünde besleme gerilimini bilmen gerekmez; LM35'teki gibi referans gerilimiyle uğraşmazsın. Aynı sebeple NTC devresinde analogReference(INTERNAL) kullanma: referans 1,1 V olunca oran bozulur ve hesap hatalı çıkar. Ölçümün doğruluğunu belirleyen asıl şey sabit direncin değeridir; %5'lik bir direnç tek başına yaklaşık 1 °C hata getirebilir. Bu yüzden %1'lik metal film direnç kullan ya da direncin gerçek değerini multimetreyle ölçüp koda yaz.

Beta denklemi (B = 3950) ile sıcaklık hesaplama

Üreticiler NTC'yi iki sayıyla tanımlar: 25 °C'deki direnç (R0 = 10 kΩ) ve B değeri (Beta). Beta denklemi bu iki sayıyla herhangi bir dirence karşılık gelen sıcaklığı verir: 1/T = 1/T0 + (1/B) × ln(R/R0). Burada T ve T0 kelvin cinsindendir (T0 = 25 + 273,15 = 298,15 K) ve ln doğal logaritmadır; sonucu santigrata çevirmek için 273,15 çıkarırsın. Örnek: NTC'nin direnci 5300 Ω ölçüldüyse ln(5300/10000) = −0,635; 1/T = 0,003354 − 0,000161 = 0,003193 ve T = 313,2 K, yani yaklaşık 40 °C olur. B değerinin yanındaki küçük sayılar, değerin hangi iki sıcaklık arasında ölçüldüğünü gösterir: B25/50 = 3950, B'nin 25 °C ve 50 °C'deki dirençlerden hesaplandığını söyler. Veri sayfan yoksa B'yi kendin de bulabilirsin: iki sıcaklıkta direnci ölç ve B = ln(R1/R2) / (1/T1 − 1/T2) formülünü kullan. Örneğin 25 °C'de 10 000 Ω, 50 °C'de 3588 Ω ölçersen B ≈ 3950 çıkar.

Arduino ile ilk ölçüm adım adım

1. NTC'yi ve 10 kΩ direnci breadboard'a tak; NTC'nin bir bacağını 5V'a, diğer bacağını direncin bir ucuna bağla.
2. Direncin diğer ucunu GND'ye, NTC ile direncin birleştiği noktayı bir jumper kabloyla A0'a bağla.
3. Aşağıdaki kodu yükle ve Seri Monitör'ü 9600 baud hızında aç.
4. Oda sıcaklığında 20–25 °C civarında bir değer görmelisin. NTC'yi iki parmağının arasında tut; değer birkaç saniye içinde 30 °C'ye doğru yükselmeli.
5. Değer ısındıkça azalıyorsa NTC ile direnç yer değiştirmiştir: ya bağlantıyı düzelt ya da koddaki formülü "NTC altta" formülüyle değiştir.

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}

Kod her ölçümde A0'ı 16 kez okuyup ortalamasını alır; bu, ADC'nin bir iki basamaklık titremesini bastırır. Ortalama değer 1'in altında ya da 1022'nin üstündeyse NTC'nin kablosu kopmuş ya da kısa devre olmuştur; kod bu durumda saçma bir sıcaklık yerine hata mesajı yazar. Ardından ortalama değerden NTC'nin direnci, oradan da Beta denklemiyle sıcaklık hesaplanır. Arduino'da log() fonksiyonu doğal logaritmayı (ln) verir; on tabanlı logaritma için log10() kullanılır ve ikisini karıştırmak, 25 °C'den uzaklaştıkça sonucun tamamen yanlış çıkmasına yol açar. Seri Monitör'de "ADC: 512.3 R: 9969 ohm Sicaklik / Temp: 25.07 C" gibi satırlar görürsün.

Steinhart-Hart denklemi: daha hassas sonuç

Beta denklemi, B değerinin ölçüldüğü aralıkta (çoğunlukla 25–50 °C) çok iyidir, ama bu aralıktan uzaklaştıkça sapar, çünkü gerçek bir NTC'nin B değeri sıcaklıkla biraz değişir. 0–100 °C gibi geniş bir aralıkta hata 1 °C'yi geçebilir. Daha hassas sonuç için üç katsayılı Steinhart-Hart denklemi kullanılır: 1/T = A + B × ln(R) + C × (ln R)³. Beta denklemi aslında bu denklemin C = 0 olan özel hâlidir. Katsayılar, üç farklı sıcaklıkta ölçülen üç direnç değerinden hesaplanır; iyi seçilmiş üç noktayla denklem, kalibre edildiği aralıkta tipik olarak 0,1 °C'den daha iyi sonuç verir. A, B ve C'yi elle çözmek yerine aşağıdaki kod, kendi ölçtüğün üç noktadan katsayıları setup() içinde kendisi hesaplar.

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}

Koddaki üç nokta örnektir; kendi NTC'ni ölçüp yerlerine yazmalısın. Bu örnek değerlerle Steinhart-Hart 0 °C, 25 °C ve 98,5 °C'de tam doğru sonuç verir. Aynı dirençleri Beta denklemine (B = 3950) verdiğinde ise 0 °C noktası 0,4 °C, 98,5 °C noktası 100,4 °C olarak hesaplanır; yani yüksek sıcaklıkta yaklaşık 2 °C hata oluşur. Noktaları ölçeceğin aralığın iki ucundan ve ortasından seç; kalibre ettiğin aralığın dışına çıktıkça (örneğin bu katsayılarla −20 °C'de) hata yeniden büyür. Uno'da float yalnızca 32 bittir, ama bu hesap için yeterlidir: sonuçlar çift hassasiyetli hesapla 0,01 °C içinde aynı çıkar.

Kalibrasyon: NTC'ni güvenilir bir termometreye dönüştür

1. Sabit direnci ölç: 10 kΩ direncin gerçek değerini multimetreyle ölç ve koddaki SERIES_R'ye yaz; %1'lik bir sapma tek başına yaklaşık 0,2 °C hata demektir.
2. NTC'yi su geçirmez yap: Çıplak epoksi NTC'yi suya sokma; bacaklarını ısıyla daralan makaron ve silikonla yalıt ya da hazır paslanmaz çelik problu NTC kullan.
3. 0 °C noktası: Bir bardağı ağzına kadar kırılmış buzla doldur, üzerine biraz soğuk su ekle ve karıştır. NTC'yi bardağın ortasında 2–3 dakika beklet, değer sabitlenince Seri Monitör'deki R değerini kaydet.
4. Oda sıcaklığı noktası: NTC'yi güvenilir bir dijital termometreyle yan yana, hava akımı olmayan bir yerde 10 dakika beklet; termometrenin gösterdiği değeri ve NTC direncini kaydet.
5. Yüksek sıcaklık noktası: Su deniz seviyesinde 100 °C'de kaynar, ama her 300 metre yükseklikte kaynama noktası yaklaşık 1 °C düşer (1000 m'de yaklaşık 96,7 °C). NTC'yi kabın tabanına değdirmeden kaynayan suya daldır ve direnci kaydet.
6. Değerleri koda yaz: Üç noktayı Steinhart-Hart koduna gir. Yalnızca oda sıcaklığı civarında ölçeceksen tek noktalı ofset düzeltmesi (aradaki sabit farkı çıkarmak) de çoğu zaman yeterlidir.

LCD ekranda NTC termometre

Ölçümü bilgisayardan bağımsız göstermek için 16x2 bir I2C LCD ekran ekleyelim. Ekranın SDA pinini A4'e, SCL pinini A5'e, VCC'yi 5V'a ve GND'yi GND'ye bağla; NTC devresi aynen kalır. Kod, Kütüphane Yöneticisi'nden kurabileceğin LiquidCrystal I2C kütüphanesini kullanır. Ekranın adresi çoğunlukla 0x27, bazı modüllerde 0x3F'tir. Derece işareti için LCD'nin karakter tablosundaki 223 numaralı karakteri yazdırırız. Ekran ayrıca, Arduino açıldığından beri ölçülen en düşük ve en yüksek sıcaklığı alt satırda gösterir.

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}

ESP32 ile NTC termistör

ESP32'nin ADC'si 12 bittir (0–4095) ve yonga 3,3 V ile çalışır, bu yüzden bölücüyü 3V3 pininden besle. NTC'yi mutlaka bir ADC1 pinine (GPIO 32–39) bağla; ADC2 pinleri Wi-Fi açıkken okunamaz. Kartının pin haritasını Pinout aracında görebilirsin. Burada önemli bir fark vardır: ESP32'nin ADC'si besleme gerilimini değil, yonganın içindeki yaklaşık 1,1 V'luk referansı ve seçilen zayıflatmayı (attenuation) kullanır. Yani Uno'daki oranlı ölçüm burada kendiliğinden gerçekleşmez ve 3V3 hattının gerçek değerini bilmen gerekir. Bu yüzden kod, ham değer yerine üretimde yongaya yazılmış kalibrasyon verisini kullanan analogReadMilliVolts() ile milivolt okur ve direnci, multimetreyle ölçtüğün 3V3 değerine göre hesaplar. Espressif'in belgelerine göre klasik ESP32, varsayılan 11 dB zayıflatmada 150–3100 mV arasını ölçebilir; ancak önerilen ve en doğrusal bölge 150–2450 mV'tur. Bu sınırlar, bağlantı şekline göre ölçebileceğin sıcaklık aralığını belirler:

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}

Oda ve dış ortam termometresi için NTC üstte bağlantı idealdir. Su ısıtıcısı, kahve makinesi ya da 3D yazıcı tablası gibi 50 °C'nin üzerinde ölçüm yapacaksan NTC'yi alt kola al ve formülü Rntc = Rs × mV / (Vcc − mV) olarak değiştir. Wi-Fi açıkken ESP32'nin akım çekişindeki sıçramalar 3V3 hattında küçük dalgalanmalara yol açar; 64 ölçümün ortalamasını almak ve GPIO 34 ile GND arasına 100 nF kondansatör takmak sonucu belirgin biçimde iyileştirir. ESP32'ye yeni başlıyorsan kurulum için ESP32 nedir yazısına göz at.

Raspberry Pi Pico ve MicroPython ile NTC

Pico'nun 12 bitlik ADC'si GP26, GP27 ve GP28 pinlerindedir; MicroPython'da read_u16() sonucu 0–65535 aralığına ölçekleyerek verir. Pico'nun ADC referansı (ADC_VREF), kart üzerinde 3,3 V hattından küçük bir RC süzgeçle elde edilir. Bölücüyü de 3V3(OUT) pininden beslersen ölçüm Uno'daki gibi yaklaşık oranlı olur ve formül aynı kalır; yalnızca 1023 yerine 65535 kullanırsın. Pico'nun ADC'si biraz gürültülüdür ve bazı kodlarda küçük sıçramalar yapar, bu yüzden burada da ortalama almak şarttır. Analog toprak olarak AGND (pin 33) kullanmak gürültüyü bir miktar azaltır. Pico'yu ilk kez kullanıyorsan MicroPython kurulumunu Raspberry Pi Pico nedir yazısında bulabilirsin.

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)

MicroPython'da math.log() da doğal logaritmadır, yani Arduino koduyla aynı formülü kullanırsın. Pico'nun içinde de bir sıcaklık sensörü vardır (ADC(4)), ama o ortamı değil yonganın kendi sıcaklığını ölçer ve çalışırken çoğu zaman birkaç derece yüksek gösterir. Ortam sıcaklığı için harici bir NTC çok daha doğrudur. Steinhart-Hart katsayılarını kullanmak istersen Arduino kodundaki computeCoefficients() fonksiyonunu birkaç satırda Python'a çevirebilirsin.

NTC ile PTC farkı

PTC (Positive Temperature Coefficient) termistörlerde direnç sıcaklıkla artar. En yaygın PTC türü ölçüm için değil koruma için kullanılır: baryum titanat seramikten yapılan anahtarlamalı PTC'ler belirli bir sıcaklığa (Curie noktası) kadar düşük dirençte kalır, o noktayı geçince dirençleri birden yüzlerce, binlerce kat artar. Motor sargılarındaki aşırı ısınma korumaları ve kendi sıcaklığını sınırlayan PTC ısıtıcılar bu ilkeyle çalışır. Polimer esaslı sıfırlanabilir sigortalar (polyfuse) da benzer şekilde davranır; Arduino Uno'nun USB hattındaki 500 mA'lik sigorta böyle bir parçadır. KTY81 gibi silisyum PTC sensörler ise yaklaşık %0,7–0,8/°C ile neredeyse doğrusal değişir. PT100 ve PT1000 gibi platin RTD'ler de pozitif katsayılıdır ama termistör değil metal sensördür; 0 °C'de 100 Ω ya da 1000 Ω değerindedir, 500 °C'nin üzerine çıkabilir ve okunmaları için MAX31865 gibi bir yükselteç gerekir.

3D yazıcı ve batarya uygulamaları

3D yazıcılarda hem nozul (hotend) hem de tabla sıcaklığı çoğunlukla NTC termistörle ölçülür. Burada 10 kΩ yerine 100 kΩ'luk NTC'ler kullanılır, çünkü 250 °C'de 10 kΩ'luk bir NTC'nin direnci 35 Ω civarına iner ve ölçüm çözünürlüğü kaybolur; popüler Marlin yazılımının ayar dosyası da 10 kΩ'luk genel termistör için "nozulda kullanma, yüksek sıcaklıkta çözünürlüğü kötü" uyarısını yazar. RAMPS gibi 8 bitlik kartlarda termistör girişleri 4,7 kΩ'luk bir pull-up direnciyle 5 V'a bağlıdır ve Marlin, ADC değerini hazır tablolarla sıcaklığa çevirir; 100 kΩ B3950 termistörler için tanımlı tiplerden biri 11 numaradır. Termistörün kablosu koparsa ADC en yüksek değeri okur ve yazılım bunu aşırı soğuk sanarak Err: MINTEMP hatası verir; kısa devrede ise Err: MAXTEMP görülür. Termistör yuvasından kayarsa ısıtıcı durmadan ısıtır ama ölçülen değer yükselmez; Marlin bunu THERMAL RUNAWAY korumasıyla yakalayıp ısıtıcıları kapatır. Bu korumayı asla kapatma.

Lityum iyon piller 0 °C'nin altında ya da yaklaşık 45 °C'nin üzerinde şarj edilmemelidir; soğukta şarj, hücrenin içinde metalik lityum birikmesine ve kalıcı hasara yol açar. Bu yüzden telefon, dizüstü ve elektrikli bisiklet bataryalarının çoğunda hücrelere yapıştırılmış bir NTC bulunur ve batarya konnektöründeki üçüncü uç (T ya da NTC diye işaretlenir) çoğunlukla bu termistöre gider. Popüler TP4056 şarj entegresinin 1 numaralı TEMP pini de bu iş içindir: veri sayfasına göre bu pindeki gerilim 0,15 saniyeden uzun süre giriş geriliminin %45'inin altına iner ya da %80'inin üzerine çıkarsa şarj durdurulur. Kendi batarya projende NTC'yi hücreye yapıştırıp Arduino ile okuyabilir, sıcaklık sınırların dışına çıktığında şarj devresini bir MOSFET ile kesebilirsin. Güç kaynaklarında ise büyük disk NTC'ler, cihaz açılırken kondansatörlere akan ani akımı sınırlar; ısındıkça dirençleri birkaç ohmdan bir ohmun altına düşer ve normal çalışmada çok az kayıp oluştururlar.

NTC termistör ile proje fikirleri

• Histerezisli fan termostatı: Sıcaklık 30 °C'yi geçince fanı bir röle modülüyle aç, 28 °C'ye düşünce kapat; aradaki 2 derecelik fark rölenin sürekli açılıp kapanmasını önler.
• Su geçirmez problu akvaryum termometresi: Paslanmaz çelik problu NTC ile su sıcaklığını ölç, ısıtıcı arızalanınca buzzer ile uyar.
• OLED ekranlı cep termometresi: Sıcaklığı ve son bir saatin grafiğini bir OLED ekranda göster.
• 3D yazıcı kabin izleyici: Kapalı kabinin sıcaklığını ölç, 45 °C'yi geçince havalandırma fanını çalıştır.
• Batarya sıcaklık bekçisi: Şarj sırasında pil sıcaklığını izle, 0–45 °C dışında şarjı kes ve LED ile uyar.
• Wi-Fi'li sıcaklık kaydedici: ESP32 ile ölçümleri dakikada bir SD karta yaz ya da telefonundan açılan bir web sayfasında göster.

Sık yapılan hatalar ve çözümleri

NTC termistör, tek bir direnç ve birkaç satır matematikle ucuz bir parçayı hassas bir termometreye dönüştürmeyi öğretir: gerilim bölücü, ADC, logaritma ve kalibrasyon bir arada. Aynı yaklaşımı ileride başka analog sensörlerde de kullanacaksın; ölçümlerini daha da pürüzsüz hale getirmek için sensör verisi filtreleme yöntemlerine de bakabilirsin. BlueGrays uygulamasında NTC ve 2x16 LCD ekranla sıcaklık ölçümü, DHT11 ile sıcaklık ve nem, ESP32 ile LCD ekranlı sıcaklık istasyonu ve sıcaklık kaydedici projelerini adım adım devre şemaları ve hazır kodlarıyla bulabilirsin.