NTC-thermistor met Arduino: gids voor bedrading, Beta en Steinhart-Hart
Een NTC-thermistor gebruiken met Arduino: bedrading als spanningsdeler, Beta (B3950) en Steinhart-Hart-formules, kalibratie, lcd-thermometer, code voor ESP32 en Pico.
Een NTC-thermistor is een goedkope temperatuursensor met twee pootjes waarvan de weerstand daalt naarmate het warmer wordt. Om een NTC-thermistor met Arduino te gebruiken, sluit je hem samen met een vaste weerstand van 10 kΩ aan als spanningsdeler, lees je het middelpunt uit op een analoge pin (A0), bereken je daaruit de weerstand van de thermistor en reken je die met de Beta-vergelijking om naar graden Celsius. Je hebt geen bibliotheek nodig, één analoge pin is genoeg en met een goede opzet haal je een resolutie van 0,1 °C bij kamertemperatuur. Ook het bed en de hotend van 3D-printers, accu's van telefoons en laptops, airco's, koelkasten en digitale koortsthermometers meten de temperatuur meestal met NTC-thermistoren.
In dit artikel leer je stap voor stap hoe de weerstand van een NTC-thermistor van 10 kΩ verandert met de temperatuur, hoe je de spanningsdeler bedraadt en de vaste weerstand kiest, de Beta-vergelijking met B = 3950, de nauwkeurigere Steinhart-Hart-vergelijking en kalibratie met drie punten. Daarna bouw je een thermometer met een I2C-lcd, herhaal je de meting met de ADC van de ESP32 en de Raspberry Pi Pico en bekijk je het verschil tussen NTC en PTC, toepassingen in 3D-printers en batterijen en de meest gemaakte fouten.

Wat is een NTC-thermistor en hoe werkt hij?
De naam thermistor is een samenstelling van "thermisch" en "resistor" (weerstand): het is een weerstand waarvan de waarde sterk verandert met de temperatuur. NTC staat voor Negative Temperature Coefficient (negatieve temperatuurcoëfficiënt). Hij is gemaakt van halfgeleidende keramiek die ontstaat door metaaloxiden zoals mangaan, nikkel en kobalt bij hoge temperatuur te bakken (sinteren). Naarmate het materiaal warmer wordt, nemen meer ladingdragers deel aan de geleiding, waardoor de weerstand daalt. De verandering is groot: een NTC met B = 3950 verliest rond 25 °C ongeveer 4,4% van zijn weerstand per graad. Ter vergelijking: een gewone metaalfilmweerstand verandert slechts 50–100 ppm per graad, oftewel 0,005–0,01%. Door die hoge gevoeligheid is de NTC een goedkope maar zeer responsieve sensor; de prijs daarvoor is dat het verband niet lineair is.
| Eigenschap | Typische NTC van 10 kΩ (B3950) |
|---|---|
| Nominale weerstand (R25) | 10 kΩ bij 25 °C; tolerantie meestal ±1%, ±3% of ±5% |
| B-waarde | B25/50 = 3950 K (±1%); modellen met 3435 K en 3380 K zijn ook gangbaar |
| Gevoeligheid | Ongeveer −4,4%/°C bij 25 °C, ongeveer −2,8%/°C bij 100 °C |
| Werkbereik | Epoxydruppel ongeveer −40 … +125 °C; typen in glas tot 250–300 °C |
| Zelfopwarming (dissipatieconstante) | Meestal 1,5–2 mW/°C in stilstaande lucht |
| Thermische tijdconstante | Ongeveer 10–20 s voor een epoxydruppel in stilstaande lucht |
| Polariteit | Geen; de pootjes kunnen worden omgewisseld |
| Behuizingen | Epoxydruppel, glas (DO-35), waterdichte sonde van roestvrij staal, SMD (0402, 0603), schijf |
Weerstand versus temperatuur: waarom is het niet lineair?
De weerstand van een NTC verandert exponentieel met de temperatuur: hij daalt heel snel in de kou en langzamer bij warmte. De tabel hieronder toont de weerstand van een NTC van 10 kΩ met B = 3950, berekend met de Beta-vergelijking, plus de spanning en de analogRead-waarde die je op pin A0 van de Arduino Uno ziet wanneer deze NTC in het bovenste deel van een spanningsdeler van 10 kΩ zit die op 5 V werkt (de bedrading in de volgende paragraaf). De laatste kolom toont hoeveel graden één ADC-stap vertegenwoordigt, oftewel de resolutie van de meting. Echte tabellen van fabrikanten kunnen een paar procent van deze waarden afwijken, vooral aan de uiteinden van het bereik.
| Temperatuur | NTC-weerstand | Spanning A0 (5 V) | analogRead | Eén stap ≈ |
|---|---|---|---|---|
| −20 °C | 105,4 kΩ | 0,433 V | 89 | 0,20 °C |
| 0 °C | 33,6 kΩ | 1,146 V | 235 | 0,10 °C |
| 10 °C | 20,2 kΩ | 1,657 V | 339 | 0,09 °C |
| 20 °C | 12,5 kΩ | 2,219 V | 454 | 0,09 °C |
| 25 °C | 10,0 kΩ | 2,500 V | 512 | 0,09 °C |
| 30 °C | 8,04 kΩ | 2,772 V | 567 | 0,09 °C |
| 40 °C | 5,30 kΩ | 3,268 V | 669 | 0,11 °C |
| 50 °C | 3,59 kΩ | 3,680 V | 753 | 0,13 °C |
| 60 °C | 2,49 kΩ | 4,004 V | 819 | 0,17 °C |
| 80 °C | 1,27 kΩ | 4,436 V | 908 | 0,31 °C |
| 100 °C | 698 Ω | 4,674 V | 956 | 0,57 °C |
| 125 °C | 359 Ω | 4,827 V | 988 | 1,17 °C |
Uit de tabel volgen twee belangrijke conclusies. Ten eerste is de spanningsdeler het gevoeligst wanneer de weerstand van de NTC gelijk is aan de vaste weerstand, in dit voorbeeld rond 25 °C: daar verandert A0 ongeveer 55 mV per graad en meet zelfs de 10-bits Uno in stappen van 0,09 °C. Dat is vijf keer beter dan de LM35, die met de 5 V-referentie maar een resolutie van 0,49 °C haalt. Ten tweede wordt de resolutie slechter naarmate je verder van dat punt af zit; één stap wordt 0,57 °C bij 100 °C en 1,2 °C bij 125 °C. Kies de vaste weerstand dus dicht bij de weerstand van de NTC bij de temperatuur die je het meest meet. Voor de grootste uitslag van A0 over een bepaald bereik moet de vaste weerstand het meetkundig gemiddelde zijn van de NTC-weerstanden aan de twee uiteinden van het bereik: voor 0–100 °C is dat √(33,6 kΩ × 0,70 kΩ) ≈ 4,8 kΩ, dus een standaard 4,7 kΩ; voor 60–100 °C ongeveer 1,3 kΩ, dus 1,2 kΩ of 1,5 kΩ.
Bedrading van de NTC-thermistor: spanningsdeler (Uno, ESP32, Pico)
De analoge ingangen van Arduino meten spanning, geen weerstand. Daarom zet je de NTC in serie met een vaste weerstand tot een spanningsdeler: de spanning op het punt waar de twee weerstanden samenkomen verandert met de weerstand van de NTC en dus met de temperatuur. Het is precies de schakeling die je met een LDR gebruikt; het enige verschil is dat de weerstand op temperatuur reageert in plaats van op licht. In de code in dit artikel zit de NTC in het bovenste deel (verbonden met de voeding) en de weerstand van 10 kΩ in het onderste deel (verbonden met GND), zodat de meetwaarde stijgt als het warmer wordt, wat intuïtief aanvoelt. Je kunt de uitgangsspanning voor verschillende weerstandswaarden berekenen met de tool Spanningsdeler en de kleurcode van de vaste weerstand controleren met de tool Weerstandskleurcode.
| Aansluiting | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Pootje 1 van de NTC | 5V | 3V3 | 3V3(OUT), pin 36 |
| Pootje 2 van de NTC + één kant van de weerstand van 10 kΩ | A0 | GPIO 34 (ADC1) | GP26 / ADC0, pin 31 |
| Andere kant van de weerstand van 10 kΩ | GND | GND | AGND, pin 33 |
| Condensator van 100 nF (optioneel) | Tussen A0 en GND | Tussen GPIO 34 en GND | Tussen GP26 en AGND |
| Bedrading | Spanning A0 | NTC-weerstand (10-bits) | analogRead bij hogere temperatuur |
|---|---|---|---|
| NTC boven: 5V – NTC – A0 – 10 kΩ – GND | Vcc × Rs / (Rs + Rntc) | Rntc = Rs × (1023 − adc) / adc | Stijgt |
| NTC onder: 5V – 10 kΩ – A0 – NTC – GND | Vcc × Rntc / (Rs + Rntc) | Rntc = Rs × adc / (1023 − adc) | Daalt |
Deze schakeling heeft een mooie eigenschap: ze doet een ratiometrische meting. Standaard gebruikt de ADC van de Uno de 5 V-voeding als referentie en de deler wordt met dezelfde 5 V gevoed. Zelfs als USB 4,8 V levert in plaats van 5,0 V, dalen de uitgang van de deler en de ADC-referentie met dezelfde verhouding en verandert de analogRead-waarde niet. Je hoeft de voedingsspanning dus niet te kennen voor een NTC-meting en hoeft niet te worstelen met de referentiespanning zoals bij de LM35. Gebruik om dezelfde reden analogReference(INTERNAL) niet in een NTC-schakeling: met een referentie van 1,1 V klopt de verhouding niet meer en gaat de berekening fout. Wat de nauwkeurigheid echt bepaalt is de waarde van de vaste weerstand; een weerstand van 5% kan alleen al ongeveer 1 °C fout veroorzaken. Gebruik dus een metaalfilmweerstand van 1%, of meet de echte waarde van je weerstand met een multimeter en zet die in de code.
De temperatuur berekenen met de Beta-vergelijking (B = 3950)
Fabrikanten beschrijven een NTC met twee getallen: de weerstand bij 25 °C (R0 = 10 kΩ) en de B-waarde (Beta). Met deze twee getallen geeft de Beta-vergelijking de temperatuur bij elke weerstand: 1/T = 1/T0 + (1/B) × ln(R/R0). Hierin zijn T en T0 in kelvin (T0 = 25 + 273,15 = 298,15 K) en is ln de natuurlijke logaritme; trek 273,15 af om het resultaat naar Celsius om te rekenen. Voorbeeld: als de NTC 5300 Ω meet, is ln(5300/10000) = −0,635; 1/T = 0,003354 − 0,000161 = 0,003193 en T = 313,2 K, ongeveer 40 °C. De kleine getallen naast de B-waarde geven aan tussen welke twee temperaturen hij is gemeten: B25/50 = 3950 betekent dat B is berekend uit de weerstanden bij 25 °C en 50 °C. Heb je geen datasheet, dan kun je B zelf bepalen: meet de weerstand bij twee temperaturen en gebruik B = ln(R1/R2) / (1/T1 − 1/T2). Meet je bijvoorbeeld 10.000 Ω bij 25 °C en 3588 Ω bij 50 °C, dan krijg je B ≈ 3950.
Eerste meting met Arduino, stap voor stap
- Steek de NTC en de weerstand van 10 kΩ in het breadboard; verbind één pootje van de NTC met 5V en het andere pootje met één kant van de weerstand.
- Verbind de andere kant van de weerstand met GND en leg een jumperdraad van het punt waar de NTC en de weerstand samenkomen naar A0.
- Upload de onderstaande code en open de Serial Monitor op 9600 baud.
- Bij kamertemperatuur zie je een waarde rond 20–25 °C. Houd de NTC tussen twee vingers; binnen een paar seconden moet de waarde richting 30 °C stijgen.
- Daalt de waarde terwijl het warmer wordt, dan zijn de NTC en de weerstand omgewisseld: herstel de bedrading of vervang de formule in de code door de formule voor "NTC onder".
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}Bij elke meting leest de code A0 zestien keer uit en middelt het resultaat; dat dempt de jitter van één of twee stappen van de ADC. Is het gemiddelde lager dan 1 of hoger dan 1022, dan is de draad van de NTC gebroken of kortgesloten en toont de code een foutmelding in plaats van een betekenisloze temperatuur. Daarna berekent hij uit het gemiddelde de weerstand van de NTC en daaruit met de Beta-vergelijking de temperatuur. In Arduino geeft de functie log() de natuurlijke logaritme (ln); log10() is de logaritme met grondtal 10 en als je die door elkaar haalt, wordt het resultaat compleet fout naarmate je verder van 25 °C komt. In de Serial Monitor zie je regels zoals "ADC: 512.3 R: 9969 ohm Sicaklik / Temp: 25.07 C".
De Steinhart-Hart-vergelijking: een nauwkeuriger resultaat
De Beta-vergelijking is heel goed binnen het bereik waarin B is gemeten (meestal 25–50 °C), maar wijkt af naarmate je er verder vandaan komt, omdat de B-waarde van een echte NTC licht verandert met de temperatuur. Over een breed bereik zoals 0–100 °C kan de fout groter zijn dan 1 °C. Voor een nauwkeuriger resultaat gebruik je de Steinhart-Hart-vergelijking met drie coëfficiënten: 1/T = A + B × ln(R) + C × (ln R)³. De Beta-vergelijking is eigenlijk het speciale geval van deze vergelijking met C = 0. De coëfficiënten worden berekend uit drie weerstandswaarden die bij drie verschillende temperaturen zijn gemeten; met drie goed gekozen punten is de vergelijking binnen het gekalibreerde bereik doorgaans beter dan 0,1 °C. In plaats van A, B en C met de hand op te lossen, berekent de onderstaande code de coëfficiënten zelf uit je drie gemeten punten, 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}De drie punten in de code zijn voorbeelden; meet je eigen NTC en vervang ze. Met deze voorbeeldwaarden geeft Steinhart-Hart precies het juiste resultaat bij 0 °C, 25 °C en 98,5 °C. Voer je dezelfde weerstanden echter aan de Beta-vergelijking (B = 3950), dan komt het punt van 0 °C uit op 0,4 °C en het punt van 98,5 °C op 100,4 °C, een fout van ongeveer 2 °C bij hoge temperatuur. Kies punten aan beide uiteinden en in het midden van het bereik dat je gaat meten; buiten het gekalibreerde bereik (bijvoorbeeld bij −20 °C met deze coëfficiënten) groeit de fout weer. Op de Uno is een float maar 32 bits, maar dat is genoeg voor deze berekening: de resultaten komen tot op 0,01 °C overeen met een berekening met dubbele precisie.
Kalibratie: maak van je NTC een betrouwbare thermometer
- Meet de vaste weerstand: meet de echte waarde van de weerstand van 10 kΩ met een multimeter en vul die in als SERIES_R in de code; een afwijking van 1% betekent alleen al ongeveer 0,2 °C fout.
- Maak de NTC waterdicht: dompel een blote epoxy-NTC niet onder in water; isoleer zijn pootjes met krimpkous en siliconen, of gebruik een kant-en-klare NTC in een sonde van roestvrij staal.
- Punt van 0 °C: vul een glas tot de rand met gemalen ijs, voeg een beetje koud water toe en roer. Houd de NTC 2–3 minuten in het midden van het glas en noteer, zodra de waarde stabiel is, de R-waarde uit de Serial Monitor.
- Punt bij kamertemperatuur: laat de NTC 10 minuten naast een betrouwbare digitale thermometer liggen op een plek zonder tocht; noteer de waarde van de thermometer en de weerstand van de NTC.
- Punt bij hoge temperatuur: op zeeniveau kookt water bij 100 °C, maar het kookpunt daalt ongeveer 1 °C per 300 m hoogte (ongeveer 96,7 °C op 1000 m). Dompel de NTC in kokend water zonder de bodem van de pan aan te raken en noteer de weerstand.
- Zet de waarden in de code: vul de drie punten in de Steinhart-Hart-code in. Meet je alleen rond kamertemperatuur, dan is een correctie met één punt (de constante afwijking aftrekken) vaak genoeg.
NTC-thermometer op een lcd
Om de meetwaarde zonder computer te tonen, voegen we een 16x2 I2C-lcd toe. Verbind de SDA-pin van het display met A4, SCL met A5, VCC met 5V en GND met GND; de NTC-schakeling blijft hetzelfde. De code gebruikt de bibliotheek LiquidCrystal I2C, die je via de Library Manager kunt installeren. Het adres van het display is meestal 0x27, bij sommige modules 0x3F. Voor het graadteken printen we teken 223 uit de tekentabel van de lcd. Op de onderste regel toont het display ook de laagste en de hoogste temperatuur die is gemeten sinds de Arduino is ingeschakeld.

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 met de ESP32
De ADC van de ESP32 is 12-bits (0–4095) en de chip werkt op 3,3 V, dus voed de deler met de pin 3V3. Sluit de NTC altijd aan op een ADC1-pin (GPIO 32–39); ADC2-pins kunnen niet worden gelezen als Wi-Fi aan staat. De pinindeling van je board zie je in de tool Pinout. Er is hier een belangrijk verschil: de ADC van de ESP32 gebruikt niet de voedingsspanning als referentie, maar een interne referentie van ongeveer 1,1 V plus de gekozen demping. De ratiometrische meting die je op de Uno krijgt, ontstaat hier dus niet vanzelf en je moet de echte waarde van de 3V3-rail kennen. Daarom leest de code millivolts met analogReadMilliVolts(), dat de kalibratiegegevens gebruikt die in de fabriek in de chip zijn geschreven, en berekent hij de weerstand uit de 3V3-waarde die je met een multimeter hebt gemeten. Volgens de documentatie van Espressif kan de klassieke ESP32 bij de standaarddemping van 11 dB 150–3100 mV meten, maar het aanbevolen en meest lineaire gebied is 150–2450 mV. Die grenzen bepalen, afhankelijk van de bedrading, het temperatuurbereik dat je kunt meten:
| Bedrading (3,3 V, 10 kΩ) | 150–2450 mV (meest nauwkeurig) | 150–3100 mV (volledig bereik) |
|---|---|---|
| NTC boven: 3V3 – NTC – GPIO 34 – 10 kΩ – GND | Ongeveer −30 … +50 °C | Ongeveer −30 … +100 °C |
| NTC onder: 3V3 – 10 kΩ – GPIO 34 – NTC – GND | Ongeveer +3 … +114 °C | Ongeveer −26 … +114 °C |
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}Voor een thermometer binnen of buiten is de bedrading met de NTC boven ideaal. Meet je boven 50 °C, bijvoorbeeld een waterkoker, een koffiemachine of het bed van een 3D-printer, verplaats de NTC dan naar het onderste deel en verander de formule in Rntc = Rs × mV / (Vcc − mV). Als Wi-Fi aan staat, veroorzaken de stroompieken van de ESP32 kleine rimpels op de 3V3-rail; 64 metingen middelen en een condensator van 100 nF tussen GPIO 34 en GND toevoegen verbetert het resultaat merkbaar. Ben je nieuw met de ESP32, lees dan het artikel Wat is de ESP32 voor de installatie.
NTC met de Raspberry Pi Pico en MicroPython
De 12-bits ADC van de Pico zit op de pins GP26, GP27 en GP28; in MicroPython geeft read_u16() het resultaat geschaald naar 0–65535. De ADC-referentie van de Pico (ADC_VREF) wordt op het board via een klein RC-filter van de 3,3 V-rail afgeleid. Voed je de deler ook vanaf de pin 3V3(OUT), dan is de meting ongeveer ratiometrisch, net als op de Uno, en blijft de formule hetzelfde; je gebruikt alleen 65535 in plaats van 1023. De ADC van de Pico is wat ruisig en springt licht bij bepaalde codes, dus ook hier is middelen essentieel. AGND (pin 33) als analoge massa gebruiken vermindert de ruis een beetje. Gebruik je de Pico voor het eerst, dan vind je de MicroPython-installatie in het artikel Wat is de 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)In MicroPython is math.log() ook de natuurlijke logaritme, dus je gebruikt dezelfde formule als in de Arduino-code. De Pico heeft ook een ingebouwde temperatuursensor (ADC(4)), maar die meet de temperatuur van de chip zelf in plaats van de omgeving en geeft tijdens het draaien meestal een paar graden te hoog aan. Voor de omgevingstemperatuur is een externe NTC veel nauwkeuriger. Wil je Steinhart-Hart-coëfficiënten gebruiken, dan kun je de functie computeCoefficients() uit de Arduino-code in een paar regels naar Python vertalen.
NTC versus PTC: wat is het verschil?
Bij PTC-thermistoren (Positive Temperature Coefficient) stijgt de weerstand met de temperatuur. Het meest voorkomende type PTC wordt gebruikt voor beveiliging, niet voor meten: schakelende PTC's van bariumtitanaatkeramiek blijven tot een bepaalde temperatuur (het Curiepunt) laagohmig en boven dat punt springt hun weerstand plotseling honderden of duizenden keren omhoog. Oververhittingsbeveiliging in motorwikkelingen en zelfbegrenzende PTC-verwarmingen werken volgens dit principe. Polymere resetbare zekeringen (polyfuses) gedragen zich op vergelijkbare wijze; de zekering van 500 mA op de USB-lijn van de Arduino Uno is er een van. Silicium-PTC-sensoren zoals de KTY81 veranderen daarentegen vrijwel lineair met ongeveer 0,7–0,8%/°C. Platina-RTD's zoals de PT100 en PT1000 hebben ook een positieve coëfficiënt, maar het zijn metalen sensoren, geen thermistoren; ze meten 100 Ω of 1000 Ω bij 0 °C, kunnen boven 500 °C komen en hebben een versterker zoals de MAX31865 nodig om te worden uitgelezen.
| Eigenschap | NTC-thermistor | Schakelende PTC | PT100 / PT1000 (RTD) |
|---|---|---|---|
| Weerstand bij hogere temperatuur | Daalt (ongeveer −4,4%/°C bij 25 °C) | Verandert weinig en springt dan bij de schakeltemperatuur | Stijgt (ongeveer +0,385%/°C) |
| Curve | Exponentieel, niet lineair | Plotselinge sprong (als een schakelaar) | Vrijwel lineair |
| Typisch bereik | −40 … +125 °C (250–300 °C in glas) | Schakeltemperatuur per model gekozen (bijv. 80 °C, 120 °C) | −200 … +500 °C en hoger |
| Hoofdgebruik | Temperatuurmeting, beperking van inschakelstroom | Beveiliging tegen oververhitting en overstroom | Nauwkeurige industriële meting |
| Uitlezen met Arduino | Spanningsdeler + analoge pin | Meestal niet gebruikt voor meting | Met een versterkermodule zoals de MAX31865 |
| Prijs | Zeer goedkoop | Goedkoop | Duurder |
Toepassingen in 3D-printers en batterijen
In 3D-printers worden zowel de temperatuur van de hotend als die van het bed meestal met NTC-thermistoren gemeten. Hier gebruikt men NTC's van 100 kΩ in plaats van 10 kΩ, omdat een NTC van 10 kΩ bij 250 °C daalt tot ongeveer 35 Ω en de meting haar resolutie verliest; het configuratiebestand van de populaire Marlin-firmware waarschuwt voor de generieke thermistor van 10 kΩ zelfs: "niet gebruiken voor een hotend, geeft een slechte resolutie bij hoge temperatuur". Op 8-bits boards zoals RAMPS worden de thermistoringangen met een weerstand van 4,7 kΩ naar 5 V getrokken en zet Marlin de ADC-waarde met kant-en-klare tabellen om in temperatuur; een van de typen die voor thermistoren van 100 kΩ B3950 zijn gedefinieerd, is nummer 11. Als de draad van de thermistor breekt, leest de ADC zijn maximum, ziet de firmware dit als extreme kou en toont Err: MINTEMP; bij kortsluiting krijg je Err: MAXTEMP. Schiet de thermistor uit zijn houder, dan blijft de heater verwarmen maar stijgt de gemeten waarde niet; Marlin vangt dit op met zijn THERMAL RUNAWAY-beveiliging en schakelt de verwarmingen uit. Schakel deze beveiliging nooit uit.
Lithium-ioncellen mag je niet opladen onder 0 °C of boven ongeveer 45 °C; opladen in de kou zorgt ervoor dat zich metallisch lithium in de cel ophoopt en richt blijvende schade aan. Daarom hebben de meeste accu's van telefoons, laptops en e-bikes een NTC op de cellen geplakt, en de derde aansluiting op de batterijconnector (gemarkeerd met T of NTC) gaat meestal naar deze thermistor. Pin 1 (TEMP) van de populaire oplaadchip TP4056 is hiervoor bedoeld: volgens de datasheet wordt het opladen onderbroken als de spanning op deze pin langer dan 0,15 seconden onder 45% of boven 80% van de ingangsspanning blijft. In je eigen batterijproject kun je een NTC op de cel plakken, hem met een Arduino uitlezen en de laadschakeling met een MOSFET onderbreken wanneer de temperatuur buiten de grenzen komt. In voedingen beperken grote NTC's in schijfvorm de inschakelstroom die in de condensatoren vloeit wanneer het apparaat wordt ingeschakeld; naarmate ze opwarmen daalt hun weerstand van een paar ohm tot onder één ohm, zodat ze in normaal bedrijf heel weinig verlies veroorzaken.

Projectideeën met een NTC-thermistor
- Ventilatorthermostaat met hysterese: schakel met een relaismodule een ventilator in wanneer de temperatuur boven 30 °C komt en uit wanneer hij tot 28 °C daalt; het verschil van 2 graden voorkomt dat het relais constant aan- en uitklikt.
- Aquariumthermometer met een waterdichte sonde: meet de watertemperatuur met een NTC-sonde van roestvrij staal en laat een buzzer klinken als de verwarming uitvalt.
- Zakthermometer met een OLED-display: toon de temperatuur en een grafiek van het laatste uur op een OLED-display.
- Bewaking van een 3D-printerbehuizing: meet de temperatuur in de gesloten behuizing en start een afzuigventilator boven 45 °C.
- Batterijtemperatuurbewaking: houd de celtemperatuur tijdens het laden in de gaten, onderbreek het laden buiten 0–45 °C en waarschuw met een led.
- Wi-Fi-temperatuurlogger: schrijf met een ESP32 elke minuut een meetwaarde naar een SD-kaart of toon hem op een webpagina die je op je telefoon opent.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Waarde is altijd 1023 of 0 | Geen vaste weerstand, gebroken draad of kortgesloten NTC | Controleer de deler; bij 25 °C moet een multimeter ongeveer 2,5 V op A0 tonen |
| Temperatuur daalt als het warmer wordt | NTC en vaste weerstand zijn omgewisseld | Herstel de bedrading of gebruik de formule voor de andere bedrading |
| Resultaat is −273,15 °C, inf of nan | analogRead geeft 0, waardoor er door nul wordt gedeeld | Controleer de draad; haal de bereikcontrole niet uit de code |
| Klopt rond 25 °C, veel te ver ernaast verder weg | log10() gebruikt in plaats van ln, of verkeerde B-waarde (bijv. 3950 ingevuld voor een NTC van 3435) | Gebruik log() en vul de B-waarde uit de datasheet van de NTC in |
| Waarde is steeds 1–2 °C te hoog | Zelfopwarming, of de NTC zit dicht bij de regelaar of de ESP32-module | Voed de deler alleen tijdens het meten, plaats de NTC met een kabel verder van het board |
| Meetwaarden jitteren | Ruis, lange draden of slecht contact in het breadboard | Middel de metingen, voeg een condensator van 100 nF toe, draai de draden in elkaar |
| Onzinwaarden op de ESP32 bij kou of hitte | De spanning ligt buiten het lineaire gebied van 150–2450 mV van de ADC | Kies de bedrading die bij je bereik past (zie de ESP32-tabel) |
| Uitlezen op de ESP32 mislukt zodra Wi-Fi start | De NTC zit op een ADC2-pin | Gebruik een van de ADC1-pins, GPIO 32–39 |
| Zeer trage respons | Thermische massa van een dikke sonde of behuizing | Dat is normaal; kies voor snelle respons een dunne epoxydruppel of een SMD-NTC |
De NTC-thermistor leert je een goedkoop onderdeel met één weerstand en een paar regels wiskunde om te bouwen tot een nauwkeurige thermometer: spanningsdeler, ADC, logaritmen en kalibratie in één. Dezelfde aanpak gebruik je later bij andere analoge sensoren; om je meetwaarden nog vloeiender te maken, bekijk je de technieken voor het filteren van sensordata. In de BlueGrays-app vind je temperatuurmeting met een NTC en een 2x16-lcd, temperatuur en luchtvochtigheid met de DHT11, een ESP32-temperatuurstation met een lcd en een temperatuurlogger, elk met stap-voor-stap-schakelschema's en kant-en-klare code.
Veelgestelde vragen
Waar wordt een NTC-thermistor voor gebruikt?
Een NTC-thermistor is een halfgeleiderweerstand waarvan de weerstand daalt als de temperatuur stijgt. Hij wordt vooral gebruikt om temperatuur te meten: 3D-printers, airco's, koelkasten, accupakketten en digitale thermometers meten de temperatuur meestal met een NTC. Grote typen in schijfvorm worden gebruikt om de inschakelstroom in voedingen te beperken.
Hoe test je een NTC-thermistor met een multimeter?
Zet de multimeter op weerstand en meet over de twee pootjes van de NTC; een NTC van 10 kΩ moet bij 25 °C ongeveer 10 kΩ tonen en bij 20 °C ongeveer 12,5 kΩ. Houd de NTC daarna tussen je vingers: de weerstand moet binnen een paar seconden duidelijk dalen. Toont het display OL (open keten) of een waarde dicht bij nul, dan is de thermistor defect.
Wat is het verschil tussen NTC en PTC?
De weerstand van een NTC daalt als hij warmer wordt, die van een PTC stijgt. NTC's worden vooral gebruikt om temperatuur te meten en de inschakelstroom te beperken. De meest voorkomende PTC's zijn beveiligingsonderdelen waarvan de weerstand bij een bepaalde temperatuur plotseling omhoogspringt; oververhittingsbeveiliging van motoren en zelfbegrenzende verwarmingen werken zo.
Welke weerstand moet ik gebruiken bij een NTC-thermistor van 10k?
Meet je rond kamertemperatuur, gebruik dan een weerstand gelijk aan de waarde van de NTC bij 25 °C, dus 10 kΩ; de deler is bij die temperatuur het gevoeligst. Voor een specifiek bereik is de beste waarde het meetkundig gemiddelde van de NTC-weerstanden aan de twee uiteinden van het bereik, bijvoorbeeld ongeveer 4,7 kΩ voor 0–100 °C. Kies voor de nauwkeurigheid een metaalfilmweerstand van 1%.
Wat betekent de B-waarde (3950) van een thermistor?
De B-waarde is een materiaalconstante die aangeeft hoe snel de weerstand van de NTC met de temperatuur verandert, en de eenheid is kelvin. B25/50 = 3950 betekent dat hij is berekend uit de weerstanden bij 25 °C en 50 °C. Gebruik je in de code niet de echte B-waarde van je NTC, dan groeit de fout naarmate je verder van 25 °C komt.
Wat is beter: NTC-thermistor, DS18B20 of LM35?
Kies voor snelheid, lage kosten en klein formaat een NTC; voor een nauwkeurigheid van ±0,5 °C zonder kalibratie en lange kabels is de DS18B20 beter. De LM35 geeft een lineaire analoge uitgang, maar heeft minstens 4 V nodig, wat lastig is met de 3,3 V-ESP32 en -Pico. Boven 125 °C (bijvoorbeeld een hotend van een 3D-printer) heb je een NTC in glas, een PT100 of een thermokoppel nodig.
Projecten om hierna te bouwen
Alle projecten bekijken
Temperatuur meten met NTC en 2x16 LCD-display
Meet de temperatuur om je heen met een sensor die op een klein kraaltje lijkt. Dit onderdeel, een NTC, laat elektriciteit makkelijker door naarmate het warmer wordt; de Arduino leest die verandering…

Temperatuur en luchtvochtigheid met DHT11
Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

Lichtsterkte meten met een LDR
Wil je zien hoe licht je kamer is, als getal? De LDR, een klein onderdeel dat op licht reageert, meet het licht om je heen en de Arduino schrijft de waarde elke halve seconde naar je computerscherm.

Lichtsterkte meten met de ESP32 en een LDR-module
Volg in de Serial Monitor in realtime de ruwe ADC-waarde van de LDR-module en het relatieve lichtpercentage, berekend uit referentiewaarden voor donker en licht. Dit percentage is geen luxmeting. Je leert hoe de module gekalibreerd wordt. Ideaal om vóór Project 10 te doen, want je gebruikt het om de drempelwaarde te bepalen.

ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
Dit project meet de omgevingstemperatuur en luchtvochtigheid met een DHT22-sensor en toont de gegevens in realtime op een 16x2 I2C-LCD. De data wordt met het one-wire-protocol via de Adafruit DHT-bibliotheek uit de sensor gelezen. Dit project is de basis voor IoT-weerstations, slimme domotica of omgevingsbewaking in kassen. De communicatie met de DHT22 loopt via pin GPIO 4 van de ESP32.

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.

Een lcd-scherm gebruiken met I2C
Geef je Arduino een eigen scherm en laat hem zijn eerste bericht schrijven. Het lcd-scherm met twee regels sluit je aan met maar een paar draden; op de bovenste regel verschijnt een groet, daarna een…

Digitale voltmeter met lcd-scherm
Ontdek hoeveel spanning een batterij of voedingsadapter geeft met een meter die je zelf hebt gebouwd.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

