NTC hőmérő modul tesztelése Arduino-val – stabil analóg mérés alapjai (KY-013)

Elsőre egyszerűnek tűnik: csak összekötöd az NTC hőmérséklet-érzékelő modult az Arduino-val, elindítod a programot, és már látod is az értékeket a képernyőn. Olvasod az analóg jelet, kiszámolod belőle a hőmérsékletet, és már működik is a rendszer. Az egész annyira kézenfekvőnek tűnik, hogy fel sem merül, hogy gond lehet vele. De amikor ténylegesen összerakod és kipróbálod, gyakran előjönnek kisebb-nagyobb problémák, amikre elsőre talán nem is számítasz.

Ezek az olcsó, kezdőknek szánt készletek ugyanis sok mindenre érzékenyek: nemcsak arra, hogy hogyan kötöd össze, hanem arra is, hogy milyen a tápellátás, és hogy pontosan mit ír a programod. Egy kis figyelmetlenség, egy rosszul választott ellenállásérték vagy egy apró hiba a kódban is elég lehet ahhoz, hogy furcsa, ingadozó vagy teljesen hibás értékeket kapj. Ráadásul ezek a hibák sokszor nem is nyilvánvalóak első ránézésre – csak azt látod, hogy valami nem stimmel, de azt nem könnyű kideríteni, miért. Ezért fontos, hogy külön kipróbáld és kiismerd a szenzort, mielőtt bonyolultabb projektbe fogsz vele.

Egy NTC hőmérséklet-érzékelő modul háromlábú csatlakozóval, fekete nyomtatott áramköri lapon (KY-013). — NTC hőérzékelő modul – egyszerű megoldás hőméréshez

Tartalomjegyzék

Mire figyelj, ha nem működik jól?

Ingadozó tápfeszültség: Ha az Arduino USB-n keresztül kap áramot, akkor előfordulhat, hogy az 5 volt nem teljesen stabil. Még egy néhány tized voltos eltérés is elég lehet ahhoz, hogy pontatlan legyen a mért hőmérséklet.
Hibás bekötés: Ha például fordítva kötöd be a jelet és a földet (GND), vagy rossz lábra dugod az analóg kimenetet (például nem az A0-ra), akkor a szenzor nem ad majd értelmes adatokat.
Gyenge forrasztás: Az ilyen készletmodulokon gyakran előfordul, hogy az alkatrészek nincsenek rendesen forrasztva, vagy maga az alkatrész gyenge minőségű. Ez instabil jeleket eredményezhet, amelyek ugrálnak, megszakadnak vagy nem követik jól a valós hőmérsékletváltozást.
Zajos bemenet: Az analogRead() utasítás egyetlen pillanatnyi értéket olvas be. Ha a környezet zajos – például túl hosszú a vezeték, vagy egy másik eszköz közel van és elektromágneses zavart okoz –, akkor ezek az értékek össze-vissza ugrálhatnak.
Túl ritkán olvasol: Ha a programod csak másodpercenként egyszer olvas adatot, akkor az túl ritkának bizonyulhat, ha gyors változást szeretnél észlelni (például amikor megfogod a szenzort vagy hideg vízbe teszed).
Rossz számítási alap: Az NTC szenzor pontos működéséhez ismerni kell néhány műszaki adatot: például milyen ellenállása van 25 °C-on, mekkora a B-értéke, és mekkora értékű az az ellenállás, amellyel sorba van kötve. Ezeket az adatokat nem mindig pontosan adják meg a gyári leírások, ezért érdemes utánanézni, vagy akár kimérni őket, ha eltérő értékeket tapasztalsz.

Hogyan lehet megbízhatóbbá tenni a mérést?

Átlagolás: Az analogRead() egyetlen értéket ad, ami sokszor zajos lehet. Ha viszont többször olvasol be gyorsan egymás után (például tízszer), és ezeknek kiszámolod az átlagát, akkor sokkal simább, egyenletesebb értéket kapsz. Ez főleg akkor segít, ha a környezetben van valamilyen elektromos zavarforrás vagy hosszú vezetéket használsz.
Mozgó átlag használata: Ha folyamatos mérést végzel, érdemes nemcsak sima átlagot, hanem mozgó átlagot alkalmazni. Ez azt jelenti, hogy a legutóbbi X értékből mindig újra és újra számítasz átlagot. Így a friss változások is megjelennek, de a rövid idejű kilengések kevésbé zavarják meg a kijelzést.
Analóg szűrés: Egy egyszerű RC aluláteresztő szűrő is sokat segíthet. Ha az NTC modul jelvezetékét egy kis soros ellenállással és egy kondenzátorral egészíted ki (pl. 1kΩ és 0.1µF), jelentősen csökkenthető a nagyfrekvenciás zaj.
Digitális simítás: Ha nem szeretnél hardveres szűrőt, megoldható digitálisan is. Például egy kis mértékű „exponenciális simítást” lehet alkalmazni, amely mindig a legutóbbi érték és az új érték kombinációját veszi figyelembe (pl. új_érték = régi_érték * 0.9 + friss_érték * 0.1).
Sűrűbb mintavétel: Az analogRead() utáni delay() parancs határozza meg, milyen gyakran frissül az adat. Ha ezt az értéket csökkented (például 1000 ms helyett 200 ms-ra), vagy akár megszünteted a késleltetést és folyamatosan olvasol, akkor az érzékelő gyorsabban tud reagálni a hőmérséklet-változásokra. Ez különösen akkor hasznos, ha valamilyen gyors reakciót szeretnél elérni, például kézmelegítés esetén.
Referenciafeszültség stabilizálása: Az Arduino belső referenciafeszültsége (általában 5 V) nem mindig stabil. Ha pontos mérést szeretnél, használhatod a analogReference(INTERNAL) parancsot, vagy külső feszültségreferenciát alkalmazhatsz.
Serial Plotter használata: Az Arduino IDE egyik hasznos beépített eszköze a Serial Plotter, ami nem csak számokat ír ki, hanem grafikont rajzol a soros kimenetből. Így nem kell kézzel követni az értékeket, hanem látod a változásokat időben. Ha megfogod az érzékelőt, vagy hideg tárgyat érsz hozzá, azonnal látszik a görbe mozgása. Ez segít abban is, hogy észrevedd a hibákat – például ha a jel ugrál, akkor valószínűleg zajos a bemenet vagy valami nincs rendben a szenzorral.
Hőhatás-teszt: Érdemes kipróbálni, hogyan reagál a szenzor különböző hőhatásokra. Használhatsz például fémtárgyat (kanalat), amit hideg vagy meleg vízbe teszel, vagy egy hajszárítót, amivel meleg levegőt fújsz az érzékelőre. Ezekkel gyorsan megnézheted, hogy a szenzor jól követi-e a hőmérséklet-változást. A gyors reakció és a stabil jelalak azt jelzi, hogy a rendszered jól működik. Ha lassú vagy ugráló az érték, akkor érdemes újra átnézni a bekötést, a kódot, vagy a szenzor minőségét.

Bekötési környezet és a szenzor felépítése

Az NTC hőmérő modul három kivezetéssel rendelkezik, és ezek a következő funkciókat látják el:

VCC – ez a tápfeszültség csatlakozási pontja, amelyhez az Arduino 5 V kimenetét kell kapcsolni.
GND – a földelés, vagyis a közös negatív pólus. Ez minden áramköri elem számára közös referencia.
S (Signal) – ez az analóg jel kimeneti lába, amelyet közvetlenül az Arduino egyik analóg bemenetére (általában A0) csatlakoztatunk.

A modul belsejében egy úgynevezett NTC (negatív hőmérsékleti együtthatójú) hőérzékelő található, amelynek ellenállása a hőmérséklet emelkedésével csökken. Ezt az érzékelőt sorba kötötték egy 10 kΩ-os fix referenciaellenállással, így egy egyszerű feszültségosztó áramkört alkotnak.

Amikor ez az áramkör feszültség alá kerül, a két ellenállás az ellenállásérték arányában leosztja a tápfeszültséget. Itt a közös pontjukon – ahonnan a „Signal” vezeték is indul – olyan feszültség jelenik meg, amely a ntc és a normál ellenállás ellenállás-arányának értékétől függ. És az NTC hőfokfüggő – így végülis a leosztott feszültség a hőmérsékletre vezethető vissza. Ezt a feszültséget az Arduino A0 bemenete érzékeli, majd digitális értékké alakítja, amelyet később szoftveresen lehet feldolgozni, például a tényleges hőmérséklet kiszámításához.

Ez a bekötési mód gyors, egyszerű és ideális kezdő projektekhez, mivel nem igényel semmilyen külső áramkört vagy bonyolult mérőeszközt – elegendő az Arduino és maga az NTC modul.

A programkód

Ahhoz, hogy az NTC szenzor megbízható adatokat szolgáltasson, fontos nemcsak a helyes bekötés és stabil tápellátás, hanem az is, hogy a mérési eredményeket megfelelően kezeljük szoftveresen. Az alábbi kódban nemcsak az analogRead() utasítással beolvasott érték szerepel, hanem tíz mérési minta átlaga is, így a végeredmény kevésbé lesz érzékeny a zajra és a véletlenszerű kilengésekre. A példában szereplő számítás a →Steinhart–Hart egyenleten alapul, amely pontos hőmérséklet-értéket ad az NTC ellenállása alapján. Lássuk, hogyan néz ez ki a gyakorlatban!

/*
  Program neve: NTC hőmérsékletmérő – analóg szenzor olvasása
  Verzió: 1.0
  Dátum: 2025. július 19.

  Szerző: Cseh Róbert
  E-mail: avr@tavir.hu
  Web: https://www.tavir.hu

  Leírás:
  Ez a program egy NTC hőmérő segítségével méri a hőmérsékletet.
  Az NTC hőérzékelő egy feszültségosztó részeként csatlakozik az Arduino A0 bemenetére.
  A program több mintát átlagolva számolja ki az ellenállást, majd a Steinhart–Hart egyenlettel
  határozza meg a környezeti hőmérsékletet Celsius-fokban. Az eredmény megjelenik a soros monitoron.

  Hardverkövetelmények:
  - Arduino UNO
  - 10 kΩ NTC hőmérő + 10 kΩ referencia ellenállás vagy NTC modul
  
  Könyvtárak:
  - Nincs szükség külső könyvtárra

  Felhasználási feltételek:
  Szabadon felhasználható és módosítható oktatási célokra. A szerző nevének megőrzése szükséges.
*/

#define NTC_PIN A0           // NTC modul kimenete az A0 analóg bemenetre

// NTC hőmérő jellemzői
#define Rref 10000.0         // referencia ellenállás (10 kΩ)
#define nominalTemp 25.0     // névleges hőmérséklet [°C]
#define nominalRes 10000.0   // névleges ellenállás 25 °C-on [Ω]
#define Bcoef 3950.0         // B-állandó (datasheet alapján)

void setup() {
  Serial.begin(9600);        // Soros kommunikáció a PC felé
}

void loop() {
  float sum = 0;
  const int samples = 10;    // 10 mérési minta az átlaghoz

  for (int i = 0; i < samples; i++) {
    sum += analogRead(NTC_PIN);  // analóg érték beolvasása
    delay(10);                   // kis várakozás két olvasás között
  }

  float avg = sum / samples;
  float Vout = avg * (5.0 / 1023.0);           // feszültség [V]
  float Rntc = Rref * (5.0 / Vout - 1.0);      // NTC ellenállás kiszámítása

  // Steinhart–Hart egyenlet alkalmazása
  float steinhart = log(Rntc / nominalRes) / Bcoef + 1.0 / (nominalTemp + 273.15);
  float temperature = 1.0 / steinhart - 273.15;
  Serial.print("A0=");
  Serial.print(avg);
  Serial.print("  ");
  Serial.println(temperature);                // Kiírás a soros monitorra / plotterre
  delay(1000);                                // Frissítés 1 másodpercenként
}

Program neve: NTC hőmérsékletmérő – analóg szenzor olvasása

Verzió: 1.0

Dátum: 2025. július 19.

Szerző: Cseh Róbert

E-mail: avr@tavir.hu

Web: https://www.tavir.hu

Leírás:

Ez a program egy NTC hőmérő segítségével méri a hőmérsékletet.

Az NTC hőérzékelő egy feszültségosztó részeként csatlakozik az Arduino A0 bemenetére.

A program több mintát átlagolva számolja ki az ellenállást, majd a Steinhart–Hart egyenlettel

határozza meg a környezeti hőmérsékletet Celsius-fokban. Az eredmény megjelenik a soros monitoron.

Hardverkövetelmények:

- Arduino UNO

- 10 kΩ NTC hőmérő + 10 kΩ referencia ellenállás vagy NTC modul

Könyvtárak:

- Nincs szükség külső könyvtárra

Felhasználási feltételek:

Szabadon felhasználható és módosítható oktatási célokra. A szerző nevének megőrzése szükséges.

#define NTC_PIN A0 // NTC modul kimenete az A0 analóg bemenetre

// NTC hőmérő jellemzői

#define Rref 10000.0 // referencia ellenállás (10 kΩ)

#define nominalTemp 25.0 // névleges hőmérséklet [°C]

#define nominalRes 10000.0 // névleges ellenállás 25 °C-on [Ω]

#define Bcoef 3950.0 // B-állandó (datasheet alapján)

void setup() {

Serial.begin(9600); // Soros kommunikáció a PC felé

}

void loop() {

float sum = 0;

const int samples = 10; // 10 mérési minta az átlaghoz

for (int i = 0; i < samples; i++) {

sum += analogRead(NTC_PIN); // analóg érték beolvasása

delay(10); // kis várakozás két olvasás között

}

float avg = sum / samples;

float Vout = avg * (5.0 / 1023.0); // feszültség [V]

float Rntc = Rref * (5.0 / Vout - 1.0); // NTC ellenállás kiszámítása

// Steinhart–Hart egyenlet alkalmazása

float steinhart = log(Rntc / nominalRes) / Bcoef + 1.0 / (nominalTemp + 273.15);

float temperature = 1.0 / steinhart - 273.15;

Serial.print("A0=");

Serial.print(avg);

Serial.print(" ");

Serial.println(temperature); // Kiírás a soros monitorra / plotterre

delay(1000); // Frissítés 1 másodpercenként

}

Mit látsz működés közben?

A soros monitoron vagy a →Serial Plotteren másodpercenként frissülő hőmérsékletérték jelenik meg, amely folyamatosan követi a szenzor által érzékelt környezeti változásokat. Ha például megfogod az érzékelőt, letakarod az ujjaddal, hideg fémtárggyal érinted, vagy levegőt fújsz rá, az értékek gyorsan reagálnak. Ezek az ingadozások azonnal észlelhetők, akár numerikus formában a monitoron, akár vizuálisan a Plotter grafikonján. A Plotter esetén ezt grafikonon is követheted, így nemcsak az aktuális értékek, hanem azok időbeli lefutása is látszik. Ez különösen hasznos, ha például késleltetést, szenzorérzékenységet vagy mérési hibát (például zajos jelalak, véletlenszerű ugrások) szeretnél észrevenni. Emellett az is jól megfigyelhető, mennyire sima vagy egyenetlen a jel, és hogyan változik a viselkedése különféle hatásokra reagálva.

Felhasznált források

– Using a Thermistor [Adafruit]
– KY-013 Modul adatlap [ArduinoModulesInfo]
– NTC Sensor Module [ElectroThinks]
– NTC modul [TavIR WebShop]
– Soros plotter (diagram) az Arduino 1.x alatt [TavIR]

Kapcsolódó cikkek:

– Hőmérséklet és páratartalom mérése Arduino-val: DHT11 (KY-015)
– Soros plotter (diagram) az Arduino 1.x alatt
– DHT11, DHT22 hőmérséklet- és páraszenzor
– TMP36 hőmérő és az Arduino
– LM35 hőmérő és az Arduino