NTC Thermistor am Arduino: Temperatur messen mit Beta-Formel

Ein NTC-Thermistor (auch Heißleiter oder NTC-Widerstand genannt) ist ein sehr günstiger Temperatursensor mit zwei Beinchen, dessen Widerstand bei steigender Temperatur sinkt. Um einen NTC am Arduino zu verwenden, schaltest du ihn mit einem festen 10-kΩ-Widerstand als Spannungsteiler, liest den Mittelpunkt an einem Analogpin (A0) ein, berechnest daraus den Widerstand des Thermistors und rechnest ihn mit der Beta-Gleichung in Grad Celsius um. Du brauchst keine Bibliothek, ein einziger Analogpin genügt, und richtig aufgebaut erreichst du bei Zimmertemperatur eine Auflösung von 0,1 °C. Auch Heizbett und Hotend von 3D-Druckern, Akkus von Handys und Laptops, Klimaanlagen, Kühlschränke und digitale Fieberthermometer messen die Temperatur meist mit NTC-Thermistoren.

In diesem Artikel lernst du Schritt für Schritt, wie sich der Widerstand eines 10-kΩ-NTC mit der Temperatur ändert, wie du den Spannungsteiler anschließt und den Festwiderstand auswählst, die Beta-Gleichung mit B = 3950, die genauere Steinhart-Hart-Gleichung und die Drei-Punkt-Kalibrierung. Danach baust du ein Thermometer mit I2C-LCD, wiederholst die Messung mit dem ADC von ESP32 und Raspberry Pi Pico und siehst dir den Unterschied zwischen NTC und PTC, Anwendungen in 3D-Druckern und Akkus sowie die häufigsten Fehler an.

Was ist ein NTC-Thermistor und wie funktioniert er?

Der Name Thermistor setzt sich aus den englischen Wörtern "thermal" und "resistor" zusammen: Es ist ein Widerstand, dessen Wert sich deutlich mit der Temperatur ändert. NTC steht für Negative Temperature Coefficient, also negativer Temperaturkoeffizient. Er besteht aus einer halbleitenden Keramik, die durch Brennen (Sintern) von Metalloxiden wie Mangan, Nickel und Kobalt bei hoher Temperatur entsteht. Wird das Material wärmer, nehmen mehr Ladungsträger an der Leitung teil, deshalb sinkt der Widerstand. Die Änderung ist groß: Ein NTC mit B = 3950 verliert um 25 °C herum pro Grad etwa 4,4 % seines Widerstands. Zum Vergleich: Ein gewöhnlicher Metallschichtwiderstand ändert sich pro Grad nur um 50–100 ppm, also 0,005–0,01 %. Diese hohe Empfindlichkeit macht den NTC zu einem billigen, aber sehr feinfühligen Sensor; der Preis dafür ist, dass der Zusammenhang nicht linear ist.

Widerstand und Temperatur: Warum ist die Kennlinie nicht linear?

Der Widerstand eines NTC ändert sich exponentiell mit der Temperatur: In der Kälte fällt er sehr schnell, bei Wärme langsamer. Die Tabelle unten zeigt den mit der Beta-Gleichung berechneten Widerstand eines NTC mit 10 kΩ und B = 3950 sowie die Spannung und den analogRead-Wert, die du am Pin A0 des Arduino Uno siehst, wenn dieser NTC im oberen Zweig eines 10-kΩ-Spannungsteilers an 5 V sitzt (die Schaltung aus dem nächsten Abschnitt). Die letzte Spalte gibt an, wie vielen Grad ein ADC-Schritt entspricht, also die Auflösung der Messung. Die Tabellen der Hersteller können vor allem an den Bereichsenden um einige Prozent von diesen Werten abweichen.

Aus der Tabelle ergeben sich zwei wichtige Erkenntnisse. Erstens ist der Spannungsteiler am empfindlichsten, wenn der NTC-Widerstand gleich dem Festwiderstand ist, in diesem Beispiel also um 25 °C: Dort ändert sich die Spannung an A0 pro Grad um etwa 55 mV, und selbst der 10-Bit-Uno misst in Schritten von 0,09 °C. Das ist fünfmal besser als beim LM35, der mit der 5-V-Referenz nur 0,49 °C Auflösung liefert. Zweitens wird die Auflösung schlechter, je weiter du dich von diesem Punkt entfernst; bei 100 °C entspricht ein Schritt 0,57 °C, bei 125 °C schon 1,2 °C. Wähle den Festwiderstand deshalb nahe am NTC-Widerstand bei der Temperatur, die du am häufigsten misst. Damit die Spannung an A0 in einem bestimmten Bereich den größten Hub macht, sollte der Festwiderstand das geometrische Mittel der NTC-Widerstände an beiden Bereichsenden sein: Für 0–100 °C ergibt √(33,6 kΩ × 0,70 kΩ) ≈ 4,8 kΩ, also standardmäßig 4,7 kΩ; für 60–100 °C etwa 1,3 kΩ, also 1,2 kΩ oder 1,5 kΩ.

NTC am Arduino anschließen: Spannungsteiler (Uno, ESP32, Pico)

Die Analogeingänge des Arduino messen Spannung, keinen Widerstand. Deshalb schaltest du den NTC mit einem Festwiderstand in Reihe und baust einen Spannungsteiler: Die Spannung am Verbindungspunkt der beiden Widerstände hängt vom NTC-Widerstand und damit von der Temperatur ab. Es ist genau dieselbe Schaltung wie beim LDR; der einzige Unterschied ist, dass der Widerstand auf Temperatur statt auf Licht reagiert. In den Codes dieses Artikels liegt der NTC im oberen Zweig (an der Versorgung) und der 10-kΩ-Widerstand im unteren Zweig (an GND); so steigt der Messwert bei Erwärmung, was intuitiv ist. Die Ausgangsspannung für andere Widerstandswerte kannst du im Tool Spannungsteiler berechnen und den Farbcode des Festwiderstands mit dem Tool Widerstands-Farbcode prüfen.

Diese Schaltung hat eine schöne Eigenschaft: Sie misst ratiometrisch. Der ADC des Uno nutzt standardmäßig die 5-V-Versorgung als Referenz, und der Teiler hängt an denselben 5 V. Selbst wenn der USB-Anschluss 4,8 V statt 5,0 V liefert, sinken der Ausgang des Teilers und die ADC-Referenz im gleichen Verhältnis, und der analogRead-Wert bleibt gleich. Für die NTC-Messung musst du die Versorgungsspannung also nicht kennen und dich nicht wie beim LM35 mit der Referenzspannung herumschlagen. Aus demselben Grund solltest du in einer NTC-Schaltung kein analogReference(INTERNAL) verwenden: Mit 1,1 V Referenz stimmt das Verhältnis nicht mehr und die Rechnung wird falsch. Was die Genauigkeit wirklich bestimmt, ist der Wert des Festwiderstands; ein 5-%-Widerstand allein kann etwa 1 °C Fehler verursachen. Nimm daher einen 1-%-Metallschichtwiderstand oder miss den echten Wert deines Widerstands mit einem Multimeter und trage ihn in den Code ein.

Temperatur berechnen mit der Beta-Gleichung (B = 3950)

Hersteller beschreiben einen NTC mit zwei Zahlen: seinem Widerstand bei 25 °C (R0 = 10 kΩ) und seinem B-Wert (Beta). Mit diesen beiden Zahlen liefert die Beta-Gleichung die Temperatur zu jedem Widerstand: 1/T = 1/T0 + (1/B) × ln(R/R0). T und T0 sind dabei in Kelvin angegeben (T0 = 25 + 273,15 = 298,15 K), und ln ist der natürliche Logarithmus; um das Ergebnis in Celsius umzurechnen, ziehst du 273,15 ab. Beispiel: Misst der NTC 5300 Ω, ist ln(5300/10000) = −0,635; 1/T = 0,003354 − 0,000161 = 0,003193 und T = 313,2 K, also etwa 40 °C. Die kleinen Zahlen neben dem B-Wert verraten, zwischen welchen zwei Temperaturen er bestimmt wurde: B25/50 = 3950 bedeutet, dass B aus den Widerständen bei 25 °C und 50 °C berechnet wurde. Hast du kein Datenblatt, kannst du B selbst bestimmen: Miss den Widerstand bei zwei Temperaturen und nutze B = ln(R1/R2) / (1/T1 − 1/T2). Misst du zum Beispiel 10.000 Ω bei 25 °C und 3588 Ω bei 50 °C, erhältst du B ≈ 3950.

Erste Messung mit dem Arduino Schritt für Schritt

1. Stecke den NTC und den 10-kΩ-Widerstand ins Breadboard; verbinde ein Beinchen des NTC mit 5V und das andere mit einem Ende des Widerstands.
2. Verbinde das andere Ende des Widerstands mit GND und führe vom Verbindungspunkt zwischen NTC und Widerstand ein Jumperkabel zu A0.
3. Lade den Code unten hoch und öffne den Seriellen Monitor mit 9600 Baud.
4. Bei Zimmertemperatur solltest du einen Wert um 20–25 °C sehen. Halte den NTC zwischen zwei Fingern; innerhalb weniger Sekunden sollte der Wert Richtung 30 °C steigen.
5. Sinkt der Wert bei Erwärmung, sind NTC und Widerstand vertauscht: Korrigiere entweder die Verdrahtung oder ersetze die Formel im Code durch die Formel für "NTC unten".

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}

Bei jeder Messung liest der Code A0 sechzehnmal und bildet den Mittelwert; das glättet das Zittern des ADC um ein bis zwei Schritte. Liegt der Mittelwert unter 1 oder über 1022, ist das Kabel des NTC unterbrochen oder kurzgeschlossen, und der Code gibt statt einer unsinnigen Temperatur eine Fehlermeldung aus. Danach berechnet er aus dem Mittelwert den Widerstand des NTC und daraus mit der Beta-Gleichung die Temperatur. Beim Arduino liefert die Funktion log() den natürlichen Logarithmus (ln); log10() ist der Zehnerlogarithmus, und wer beide verwechselt, bekommt abseits von 25 °C völlig falsche Ergebnisse. Im Seriellen Monitor siehst du Zeilen wie "ADC: 512.3 R: 9969 ohm Sicaklik / Temp: 25.07 C".

Die Steinhart-Hart-Gleichung: genauere Ergebnisse

Die Beta-Gleichung ist in dem Bereich, in dem B gemessen wurde (meist 25–50 °C), sehr gut, weicht aber außerhalb davon ab, weil sich der B-Wert eines echten NTC leicht mit der Temperatur ändert. Über einen weiten Bereich wie 0–100 °C kann der Fehler 1 °C überschreiten. Für genauere Ergebnisse nutzt man die Steinhart-Hart-Gleichung mit drei Koeffizienten: 1/T = A + B × ln(R) + C × (ln R)³. Die Beta-Gleichung ist eigentlich der Sonderfall dieser Gleichung mit C = 0. Die Koeffizienten werden aus drei Widerstandswerten berechnet, die bei drei verschiedenen Temperaturen gemessen wurden; mit drei gut gewählten Punkten ist die Gleichung im kalibrierten Bereich typischerweise genauer als 0,1 °C. Statt A, B und C von Hand zu lösen, berechnet der folgende Code die Koeffizienten aus deinen drei Messpunkten selbst, und zwar in 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}

Die drei Punkte im Code sind Beispiele; miss deinen eigenen NTC und trage deine Werte ein. Mit diesen Beispielwerten liefert Steinhart-Hart bei 0 °C, 25 °C und 98,5 °C exakt das richtige Ergebnis. Gibst du dieselben Widerstände dagegen in die Beta-Gleichung (B = 3950) ein, wird der 0-°C-Punkt zu 0,4 °C und der 98,5-°C-Punkt zu 100,4 °C, bei hoher Temperatur also ein Fehler von rund 2 °C. Wähle die Punkte an beiden Enden und in der Mitte deines Messbereichs; außerhalb des kalibrierten Bereichs (mit diesen Koeffizienten zum Beispiel bei −20 °C) wächst der Fehler wieder. Beim Uno hat float nur 32 Bit, für diese Rechnung reicht das aber: Die Ergebnisse stimmen auf 0,01 °C mit einer Rechnung in doppelter Genauigkeit überein.

Kalibrierung: So wird dein NTC zum zuverlässigen Thermometer

1. Festwiderstand messen: Miss den echten Wert des 10-kΩ-Widerstands mit dem Multimeter und trage ihn im Code als SERIES_R ein; schon 1 % Abweichung bedeutet etwa 0,2 °C Fehler.
2. NTC wasserdicht machen: Tauche keinen nackten Epoxid-NTC ins Wasser; isoliere die Beinchen mit Schrumpfschlauch und Silikon oder nimm einen fertigen NTC im Edelstahlfühler.
3. 0-°C-Punkt: Fülle ein Glas randvoll mit zerstoßenem Eis, gib etwas kaltes Wasser dazu und rühre um. Halte den NTC 2–3 Minuten in die Mitte des Glases und notiere den R-Wert aus dem Seriellen Monitor, sobald er sich nicht mehr ändert.
4. Punkt bei Zimmertemperatur: Lass den NTC 10 Minuten neben einem zuverlässigen Digitalthermometer an einem zugfreien Ort liegen; notiere die Anzeige des Thermometers und den NTC-Widerstand.
5. Punkt bei hoher Temperatur: Auf Meereshöhe kocht Wasser bei 100 °C, pro 300 Höhenmeter sinkt der Siedepunkt aber um etwa 1 °C (auf 1000 m etwa 96,7 °C). Tauche den NTC in kochendes Wasser, ohne den Topfboden zu berühren, und notiere den Widerstand.
6. Werte in den Code eintragen: Trage die drei Punkte in den Steinhart-Hart-Code ein. Misst du nur um Zimmertemperatur herum, reicht oft auch eine Ein-Punkt-Offsetkorrektur (den konstanten Unterschied abziehen).

NTC-Thermometer mit LCD

Damit die Messung auch ohne Computer angezeigt wird, ergänzen wir ein 16x2-I2C-LCD. Verbinde SDA des Displays mit A4, SCL mit A5, VCC mit 5V und GND mit GND; die NTC-Schaltung bleibt unverändert. Der Code nutzt die Bibliothek LiquidCrystal I2C, die du über den Bibliotheksverwalter installieren kannst. Die Adresse des Displays ist meist 0x27, bei manchen Modulen 0x3F. Für das Gradzeichen geben wir das Zeichen 223 aus der Zeichentabelle des LCD aus. Außerdem zeigt das Display in der unteren Zeile die niedrigste und höchste Temperatur seit dem Einschalten des 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}

NTC-Thermistor am ESP32

Der ADC des ESP32 hat 12 Bit (0–4095) und der Chip läuft mit 3,3 V, also versorgst du den Teiler aus dem Pin 3V3. Schließe den NTC unbedingt an einen ADC1-Pin an (GPIO 32–39); ADC2-Pins lassen sich bei aktivem WLAN nicht auslesen. Die Pinbelegung deines Boards findest du im Tool Pinout. Hier gibt es einen wichtigen Unterschied: Der ADC des ESP32 nutzt nicht die Versorgungsspannung als Referenz, sondern eine interne Referenz von etwa 1,1 V samt der gewählten Dämpfung (Attenuation). Die ratiometrische Messung wie beim Uno ergibt sich hier also nicht von selbst, und du musst den echten Wert der 3V3-Schiene kennen. Deshalb liest der Code mit analogReadMilliVolts() Millivolt ein, wobei die ab Werk im Chip gespeicherten Kalibrierdaten genutzt werden, und berechnet den Widerstand aus dem 3V3-Wert, den du mit dem Multimeter gemessen hast. Laut Espressif-Dokumentation misst der klassische ESP32 bei der Standarddämpfung von 11 dB 150–3100 mV, empfohlen und am linearsten ist aber der Bereich 150–2450 mV. Diese Grenzen bestimmen je nach Schaltung den messbaren Temperaturbereich:

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}

Für ein Raum- oder Außenthermometer ist die Schaltung mit dem NTC oben ideal. Willst du über 50 °C messen, etwa an einem Wasserkocher, einer Kaffeemaschine oder dem Heizbett eines 3D-Druckers, setze den NTC in den unteren Zweig und ändere die Formel zu Rntc = Rs × mV / (Vcc − mV). Bei aktivem WLAN verursachen die Stromspitzen des ESP32 kleine Schwankungen auf der 3V3-Schiene; der Mittelwert aus 64 Messungen und ein 100-nF-Kondensator zwischen GPIO 34 und GND verbessern das Ergebnis deutlich. Wenn du neu beim ESP32 bist, findest du die Einrichtung im Artikel Was ist der ESP32.

NTC mit dem Raspberry Pi Pico und MicroPython

Der 12-Bit-ADC des Pico liegt an den Pins GP26, GP27 und GP28; in MicroPython liefert read_u16() das Ergebnis auf 0–65535 skaliert. Die ADC-Referenz des Pico (ADC_VREF) wird auf der Platine über einen kleinen RC-Filter aus der 3,3-V-Schiene gewonnen. Versorgst du auch den Teiler aus dem Pin 3V3(OUT), ist die Messung wie beim Uno annähernd ratiometrisch und die Formel bleibt gleich; du verwendest lediglich 65535 statt 1023. Der ADC des Pico rauscht etwas und springt bei bestimmten Codes leicht, deshalb ist Mittelwertbildung auch hier Pflicht. AGND (Pin 33) als analoge Masse senkt das Rauschen ein wenig. Nutzt du den Pico zum ersten Mal, findest du die MicroPython-Installation im Artikel Was ist der 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)

Auch in MicroPython ist math.log() der natürliche Logarithmus, du verwendest also dieselbe Formel wie im Arduino-Code. Der Pico hat zwar einen eingebauten Temperatursensor (ADC(4)), der misst aber die Temperatur des Chips selbst und nicht die Umgebung und zeigt im Betrieb meist einige Grad zu viel an. Für die Umgebungstemperatur ist ein externer NTC deutlich genauer. Möchtest du Steinhart-Hart-Koeffizienten nutzen, lässt sich die Funktion computeCoefficients() aus dem Arduino-Code mit wenigen Zeilen nach Python übertragen.

Unterschied zwischen NTC und PTC

Bei PTC-Thermistoren (Positive Temperature Coefficient, Kaltleiter) steigt der Widerstand mit der Temperatur. Der häufigste PTC-Typ dient nicht zum Messen, sondern zum Schutz: Schalt-PTCs aus Bariumtitanat-Keramik bleiben bis zu einer bestimmten Temperatur (dem Curie-Punkt) niederohmig, darüber steigt ihr Widerstand schlagartig um das Hundert- bis Tausendfache. Übertemperaturschutz in Motorwicklungen und selbstregelnde PTC-Heizelemente arbeiten nach diesem Prinzip. Rückstellbare Sicherungen auf Polymerbasis (Polyfuse) verhalten sich ähnlich; die 500-mA-Sicherung in der USB-Leitung des Arduino Uno ist so ein Bauteil. Silizium-PTC-Sensoren wie der KTY81 ändern sich dagegen mit etwa 0,7–0,8 %/°C nahezu linear. Platin-RTDs wie PT100 und PT1000 haben ebenfalls einen positiven Koeffizienten, sind aber Metallsensoren und keine Thermistoren; sie haben bei 0 °C 100 Ω bzw. 1000 Ω, vertragen über 500 °C und brauchen zum Auslesen einen Verstärker wie den MAX31865.

Anwendungen in 3D-Druckern und Akkus

In 3D-Druckern werden sowohl die Hotend- als auch die Heizbetttemperatur meist mit NTC-Thermistoren gemessen. Dort kommen 100-kΩ-NTCs statt 10-kΩ-Typen zum Einsatz, weil ein 10-kΩ-NTC bei 250 °C auf rund 35 Ω absinkt und die Messung ihre Auflösung verliert; die Konfigurationsdatei der beliebten Firmware Marlin warnt beim generischen 10-kΩ-Thermistor sogar: "nicht für ein Hotend verwenden, schlechte Auflösung bei hoher Temperatur". Auf 8-Bit-Boards wie RAMPS hängen die Thermistoreingänge über einen 4,7-kΩ-Pull-up-Widerstand an 5 V, und Marlin rechnet den ADC-Wert über fertige Tabellen in Temperatur um; einer der Typen für 100-kΩ-Thermistoren mit B3950 ist die Nummer 11. Reißt das Kabel des Thermistors, liest der ADC seinen Höchstwert, die Firmware hält das für extreme Kälte und meldet Err: MINTEMP; bei einem Kurzschluss erscheint Err: MAXTEMP. Rutscht der Thermistor aus seiner Halterung, heizt die Heizung immer weiter, aber der Messwert steigt nicht; Marlin erkennt das mit dem Schutz THERMAL RUNAWAY und schaltet die Heizungen ab. Deaktiviere diesen Schutz niemals.

Lithium-Ionen-Zellen sollten nicht unter 0 °C oder über etwa 45 °C geladen werden; Laden in der Kälte führt zu Ablagerungen von metallischem Lithium in der Zelle und zu bleibenden Schäden. Deshalb ist in den meisten Akkus von Handys, Laptops und E-Bikes ein NTC auf die Zellen geklebt, und der dritte Kontakt am Akkustecker (mit T oder NTC beschriftet) führt meist zu diesem Thermistor. Pin 1 (TEMP) des beliebten Ladechips TP4056 ist genau dafür da: Laut Datenblatt wird der Ladevorgang unterbrochen, wenn die Spannung an diesem Pin länger als 0,15 Sekunden unter 45 % oder über 80 % der Eingangsspannung liegt. In deinem eigenen Akku-Projekt kannst du einen NTC auf die Zelle kleben, ihn mit dem Arduino auslesen und den Ladekreis mit einem MOSFET trennen, sobald die Temperatur die Grenzen verlässt. In Netzteilen begrenzen große Scheiben-NTCs den Einschaltstrom, der beim Einschalten in die Kondensatoren fließt; beim Erwärmen fällt ihr Widerstand von einigen Ohm auf unter ein Ohm, sodass sie im Normalbetrieb kaum Verluste verursachen.

Projektideen mit dem NTC-Thermistor

• Lüfter-Thermostat mit Hysterese: Schalte einen Lüfter über ein Relaismodul ein, wenn die Temperatur 30 °C überschreitet, und bei 28 °C wieder aus; die 2 Grad Abstand verhindern, dass das Relais ständig klackert.
• Aquarium-Thermometer mit wasserdichtem Fühler: Miss die Wassertemperatur mit einem NTC im Edelstahlfühler und lass einen Buzzer piepen, wenn der Heizstab ausfällt.
• Taschenthermometer mit OLED: Zeige die Temperatur und einen Verlauf der letzten Stunde auf einem OLED-Display an.
• Gehäusewächter für den 3D-Drucker: Miss die Temperatur im geschlossenen Gehäuse und starte über 45 °C einen Abluftlüfter.
• Akku-Temperaturwächter: Überwache die Zellentemperatur beim Laden, unterbrich das Laden außerhalb von 0–45 °C und warne mit einer LED.
• WLAN-Temperaturlogger: Schreibe mit dem ESP32 jede Minute einen Messwert auf eine SD-Karte oder zeige ihn auf einer Webseite an, die du auf dem Handy öffnest.

Häufige Fehler und Lösungen

Der NTC-Thermistor zeigt dir, wie du aus einem billigen Bauteil mit einem einzigen Widerstand und ein paar Zeilen Mathematik ein genaues Thermometer machst: Spannungsteiler, ADC, Logarithmus und Kalibrierung in einem. Dasselbe Vorgehen wirst du später bei anderen analogen Sensoren nutzen; um deine Messwerte noch ruhiger zu machen, wirf einen Blick auf Methoden zur Filterung von Sensordaten. In der BlueGrays-App findest du die Temperaturmessung mit NTC und 2x16-LCD, Temperatur und Luftfeuchte mit dem DHT11, eine ESP32-Temperaturstation mit LCD und einen Temperaturlogger, jeweils mit Schritt-für-Schritt-Schaltplänen und fertigem Code.