Hőmérő Építése Képekben: Lépésről Lépésre Vezetett Útmutató

A hőmérséklet mérése számos projekt alapvető eleme, legyen szó környezeti monitorozásról, barkácsprojektekről vagy ipari alkalmazásokról. Az egyik legegyszerűbb és legköltséghatékonyabb módja a hőmérséklet-érzékelő integrálásának az Arduino projektekben a TMP36 hőmérséklet-érzékelő használata. Ezek az érzékelők meglehetősen pontosak, és nem igényelnek külső alkatrészeket a működésükhöz. Néhány egyszerű csatlakozással és néhány sornyi Arduino kóddal gyorsan létrehozhatunk egy működő hőmérőprogramot.

Ez a cikk részletesen bemutatja a TMP36 hőmérő építésének folyamatát, a szükséges alkatrészektől a programozásig, beleértve egy önálló hőmérő megvalósítását is LCD kijelzővel.

Hozzávalók és Eszközök

A TMP36 hőmérő Arduino-val történő megépítéséhez a következőkre lesz szükségünk:

Alkatrészek:

  • TMP36 hőmérő: Ez a kis, precíziós Celsius-hőmérséklet-érzékelő az Analog Devices gyártmánya. Lineárisan arányos kimeneti feszültséget biztosít a mért hőmérséklethez, így ideálisan használható Arduino-val.
  • Arduino UNO alaplap (vagy bármely Arduino kompatibilis alaplap): A mikrokontroller, amely feldolgozza az érzékelő adatait és futtatja a programot.
  • Jumper/Dupont kábel (anya-anya): Három érre lesz szükségünk a TMP36 és az Arduino összekötéséhez.
  • Önálló I2CLCD modul és Karakteres kijelző (opcionális, az önálló hőmérőhöz): Ha nem szeretnénk a számítógéphez kötni a hőmérőt, hanem egy kijelzőn szeretnénk látni az értékeket, szükségünk lesz egy LCD kijelzőre és egy hozzá való I2C interfész modulra.

Eszközök:

  • Számítógép: Az Arduino IDE telepítéséhez és a program feltöltéséhez.
  • USB kábel: Az Arduino és a számítógép összekötéséhez.
  • Multiméter (opcionális, teszteléshez): Hasznos lehet a csatlakozások ellenőrzéséhez és a kimeneti feszültség méréséhez.
  • Breadboard (opcionális): Megkönnyíti az alkatrészek ideiglenes összekötését.

Szoftver:

  • Arduino IDE keretrendszer: A programozáshoz és a kód feltöltéséhez. A cikk a Windows alatti 1.8.13 verzióval készült.

A TMP36 Hőmérséklet-érzékelő Működési Elve

A TMP36 egy kis feszültségről is működő, precíziós Celsius-hőmérséklet-érzékelő. Ez egy olyan chip, amely a °C-ban mért hőmérséklettel lineárisan arányos kimeneti feszültséget biztosít. A TMP36 szilárdtest technikát használ a hőmérséklet mérésére, kihasználva azt a tényt, hogy a diódával kapcsolt tranzisztor alapja és emittere közötti feszültségesés a hőmérséklet emelkedésével ismert ütemben csökken. A chipen belül történnek a számítások, a linearizálás és a hőfokfüggő differenciálás, így a kimeneten csak a hőmérséklettel lineárisan arányos feszültséget kapjuk.

TMP36 chip

TMP36 Jellemzők és Specifikációk:

  • Tápfeszültség: 2.7V - 5.5V
  • Működési áramfelvétel: 50µA (nagyon alacsony önmelegedést biztosít, kevesebb, mint 0,1 °C álló levegőben)
  • Mérési tartomány: -40°C .. +125°C
  • Pontosság: Tipikusan ±1°C 25°C-on (±2°C a -40°C és +125°C tartományban)
  • Kimeneti arány: 10mV/°C
  • Kimeneti feszültség (25°C): 750mV (0.5V eltolással)

Ezek a jellemzők teszik a TMP36-ot ideálissá számos Arduino projekthez, mivel megbízható, pontos és minimális külső alkatrészt igényel. A TMP36 adatlapja további részleteket tartalmaz a specifikációiról.

TMP36 Szenzor Lábkiosztása és Csatlakoztatása az Arduinohoz

A TMP36 érzékelőnek három kivezetése van. A lábkiosztás megértéséhez tartsuk az érzékelőt úgy, hogy a lapos, feliratozott oldala nézzen felénk. Ebben az esetben a bal oldali láb a tápellátás (+Vs), a középső a kimeneti feszültség (Vout), a jobb oldali pedig a földelés (GND).

TMP36 lábkiosztás

Csatlakoztatás az Arduinohoz:

  1. +Vs (bal láb): Csatlakoztassa az Arduino 5V vagy 3.3V kimenetéhez.
  2. Vout (középső láb): Csatlakoztassa az Arduino egyik analóg bemenetéhez (pl. A4 vagy A0, a kódtól függően).
  3. GND (jobb láb): Csatlakoztassa az Arduino GND (földelés) kivezetéséhez.

Az alábbi ábra szemlélteti a TMP36 csatlakoztatását az Arduino UNO-hoz:

TMP36 csatlakoztatása Arduinohoz

A csatlakoztatás egyszerűen breadboarddal vagy közvetlenül DuPont kábelekkel is elvégezhető. A levegő hőmérsékletének méréséhez az érzékelőt szabadon hagyhatjuk, vagy rögzíthetjük olyan tárgyhoz, amelynek hőmérsékletét mérni szeretnénk. Fontos megjegyezni, hogy az érzékelő nem vízálló, így külső védelemre lehet szükség nedves környezetben.

Az Analóg Hőmérsékleti Adatok Olvasása és Feldolgozása

Az Arduino analóg bemenetei képesek érzékelni a bemeneti feszültség változásait. Az analogRead() függvény egy 0 és 1023 közötti egész értéket ad vissza, amely az ADC (Analóg-Digitális Átalakító) referenciafeszültsége és a bemeneti feszültség közötti arányt képviseli. Alapértelmezetten az Arduino UNO referenciafeszültsége az 5V-os tápfeszültség.

A Feszültség Kiszámítása:

Az analóg leolvasásból (0-1023) kiindulva kiszámíthatjuk a tényleges bemeneti feszültséget (Vout):

Vout = (ADC_érték) * (Referenciafeszültség / 1024.0)

Ha 5V-os referenciát használunk:Vout = (ADC_érték) * (5.0 / 1024.0)

Ha 3.3V-os Arduino-t használunk, a képlet:Vout = (ADC_érték) * (3.3 / 1024.0)

A Hőmérséklet Kiszámítása Celsiusban:

A TMP36 kimeneti feszültsége lineárisan arányos a hőmérséklettel, de van egy 0.5V-os eltolása (offset), amely lehetővé teszi a negatív hőmérsékletek mérését is. A képlet a következő:

Hőmérséklet (°C) = (Vout - 0.5) * 100

Például, ha a kimeneti feszültség 1V, akkor a hőmérséklet:(1V - 0.5V) * 100 = 0.5V * 100 = 50°C

A Hőmérséklet Kiszámítása Fahrenheitben:

A Celsius fokot Fahrenheitre a következő képlettel konvertálhatjuk:

Hőmérséklet (°F) = (Hőmérséklet (°C) * 9.0 / 5.0) + 32.0

Az Arduino Program (Sketch)

Az alábbi vázlat bemutatja a TMP36 hőmérséklet-érzékelő gyors leolvasásának módját, és alapul szolgálhat további kísérletekhez és projektekhez. A kód kiolvassa az értéket az A4 analóg portról, és kinyomtatja az aktuális hőmérsékletet (°C-ban és °F-ban egyaránt) a soros monitoron.

#define sensorPin A4 // Meghatározza, hogy melyik analóg pin-hez csatlakozik az érzékelővoid setup() { Serial.begin(9600); // Inicializálja a soros kommunikációt 9600 baud sebességgel}void loop() { int reading = analogRead(sensorPin); // Beolvassa az analóg értéket a sensorPin-ről (0-1023) // Kiszámítja a bemeneti feszültséget (feltételezve 5V referenciafeszültséget) float voltage = reading * (5.0 / 1024.0); // Kiszámítja a hőmérsékletet Celsiusban a TMP36 képlet alapján float temperatureC = (voltage - 0.5) * 100; // Kiírja a hőmérsékletet Celsiusban a soros monitorra Serial.print("Temperature: "); Serial.print(temperatureC); Serial.print("\xC2\xB0"); // Fok jel (UTF-8 kódolás) Serial.print("C | "); // Kiszámítja a hőmérsékletet Fahrenheitben float temperatureF = (temperatureC * 9.0 / 5.0) + 32.0; // Kiírja a hőmérsékletet Fahrenheitben a soros monitorra Serial.print(temperatureF); Serial.print("\xC2\xB0"); // Fok jel (UTF-8 kódolás) Serial.println("F"); delay(1000); // Vár egy másodpercet a következő mérés előtt}

A Kód Működése:

  1. #define sensorPin A4: Meghatározza, hogy az érzékelő kimenete az Arduino A4 analóg bemeneti pin-hez van csatlakoztatva.
  2. setup() függvény: Inicializálja a soros kommunikációt a számítógéppel a Serial.begin(9600) paranccsal. Ez teszi lehetővé az adatok megjelenítését a Soros Monitor ablakban.
  3. loop() függvény:
    • analogRead(sensorPin): Beolvassa az analóg értéket az A4 pin-ről. Az érték 0 és 1023 között lesz.
    • voltage = reading * (5.0 / 1024.0): Átváltja az analóg leolvasást feszültségértékre (0-5V).
    • temperatureC = (voltage - 0.5) * 100: A TMP36 specifikus képletével kiszámítja a hőmérsékletet Celsius fokban.
    • Serial.print(...) parancsok: Kiírják a mért hőmérsékletet Celsiusban és Fahrenheitben a Soros Monitorra, beleértve a fok jelet is.
    • delay(1000): Szünetelteti a program végrehajtását 1 másodpercig, mielőtt újabb mérést végez.

TMP36 hőmérséklet-érzékelő használata Arduinóval (39. lecke)

Ha mindent megfelelően csatlakoztatott és feltöltötte a kódot, a Soros Monitorban a következőhöz hasonló kimenetet fog látni:

Temperature: 24.50°C | 76.10°FTemperature: 24.60°C | 76.28°FTemperature: 24.70°C | 76.46°F...

A TMP36 Érzékelő Pontosságának Javítása

Az alapértelmezett beállításokkal az Arduino ADC maximális felbontása 5.0/1024 ≈ 4.88 mV, ami átszámítva kb. 0.49°C felbontást jelent. A pontosabb mérések érdekében több módszer is létezik:

Külső Referenciafeszültség Használata:

Az Arduino 3.3V-os kimenetét analóg referenciaként (ARef) is használhatjuk. Ez pontosabb és kevésbé zajos mérést tesz lehetővé. A 3.3V-os referenciával a felbontás 3.3/1024 ≈ 3.22 mV, ami kb. 0.32°C felbontást eredményez.

Ehhez csatlakoztassa az Arduino ARef pin-jét a 3.3V kimenethez, és módosítsa a kódot:

#define sensorPin A4#define aref_voltage 3.3 // Külső referenciafeszültség meghatározásavoid setup() { Serial.begin(9600); analogReference(EXTERNAL); // Beállítja a külső referenciafeszültséget}void loop() { int reading = analogRead(sensorPin); // A feszültség kiszámítása a külső referenciafeszültséggel float voltage = reading * (aref_voltage / 1024.0); // A hőmérséklet kiszámítása (0.5V offset nélkül, mert a TMP36 kimenete 0.5V-tól indul) // A képlet módosítása a 0.5V offset miatt float temperatureC = voltage * 100; // A képlet pontosítása: voltage * 100, mivel az offset már bele van számítva a voltage-ben. // Helyesebb képlet: temperatureC = (voltage - 0.5) * 100; ha a voltage már a kimeneti feszültség // De ha a voltage az ADC leolvasásból jön, akkor a fenti képlet a helyes. // A korábbi képlet (voltage - 0.5) * 100 helyes, ha a voltage a kimeneti feszültség. // Tehát ha a voltage kiszámításánál az 5.0/1024.0 a referencia volt, akkor a voltage-t kell használni. // Ha az új kódban a voltage = reading * (aref_voltage / 1024.0); // akkor a temperatureC = (voltage - 0.5) * 100; képlet a helyes. // A fenti kódban a temperatureC = voltage * 100; sor hibásan lett feltételezve. // A helyes képlet a voltage és a 0.5V offset figyelembevételével: // float temperatureC = (voltage - 0.5) * 100; // Javított kód a 3.3V referenciával: int reading = analogRead(sensorPin); float voltage = reading * (aref_voltage / 1024.0); float temperatureC = (voltage - 0.5) * 100; // A 0.5V offset miatt ez a képlet a helyes Serial.print("Temperature: "); Serial.print(temperatureC); Serial.print("\xC2\xB0"); Serial.print("C | "); float temperatureF = (temperatureC * 9.0 / 5.0) + 32.0; Serial.print(temperatureF); Serial.print("\xC2\xB0"); Serial.println("F"); delay(1000);}

Megjegyzés: A fenti kód módosításoknál a temperatureC = voltage * 100; sor javítva lett float temperatureC = (voltage - 0.5) * 100;-ra, hogy megfeleljen a TMP36 specifikációinak.

Belső Referenciafeszültség Használata:

Az Arduino UNO esetében a belső referenciafeszültség 2.56V. Más Arduino modellek (pl. Mega) eltérő belső referenciafeszültséggel rendelkezhetnek (pl. 1.1V vagy 2.56V). Ennek használatával még jobb érzékenységet érhetünk el. A kód módosítása hasonló az analogReference(INTERNAL) paranccsal történik.

További Pontossági Tippek:

  • LM35 Érzékelő: Ha még nagyobb pontosságra van szükség, az LM35 érzékelő is jó választás lehet, amelynek kimeneti feszültsége 10mV/°C, de nincs 0.5V offset-je.
  • DS18B20 Digitális Hőmérő: A legpontosabb és legmegbízhatóbb megoldásért érdemes a digitális DS18B20 érzékelőt használni, amely egyvonalas interfészen kommunikál.

Önálló Hőmérő TMP36-tal és I2CLCD-vel

Egy önálló hőmérő megépítéséhez, amely nem igényel számítógéphez való csatlakoztatást, szükségünk lesz egy LCD kijelzőre és egy I2C interfész modulra. Az I2C interfész lehetővé teszi az LCD kijelző vezérlését mindössze két adatvonal (SDA és SCL) segítségével.

Arduino, TMP36 és I2CLCD modul

Csatlakoztatás:

  1. TMP36 csatlakoztatása: Azonos módon, mint korábban az Arduino-hoz.
  2. I2CLCD modul csatlakoztatása:
    • VCC: Arduino 5V kimenet.
    • GND: Arduino GND kivezetés.
    • SDA: Arduino SDA pin (UNO esetén A4).
    • SCL: Arduino SCL pin (UNO esetén A5).

Az alábbi ábra mutatja a Mega 2560-hoz csatlakoztatott TMP36 és I2CLCD modult:

Mega2560, TMP36 és I2CLCD bővítő

Az Arduino Program I2CLCD-vel:

Ehhez a programhoz szükség lesz a LiquidCrystal_I2C.h könyvtárra. Ezt az Arduino IDE könyvtárkezelőjében telepíthetjük.

#include <LiquidCrystal_I2C.h> // Tartalmazza az I2C LCD funkciókat// Az LCD inicializálása: címmel (0x27 vagy 0x3F), oszlopokkal (20), sorokkal (4)LiquidCrystal_I2C lcd(0x27, 20, 4);// Egyedi fokjel karakter definiálása (opcionális)byte Degree[] = { B00111, B00101, B00111, B00000, B00000, B00000, B00000, B00000};#define sensorPin A4 // Meghatározza az érzékelő pin-jétvoid setup() { lcd.init(); // Inicializálja az LCD-t lcd.backlight(); // Bekapcsolja a háttérvilágítást lcd.createChar(0, Degree); // Létrehozza az egyedi fokjelet a 0. pozícióban}void loop() { int reading = analogRead(sensorPin); float voltage = reading * (5.0 / 1024.0); float temperatureC = (voltage - 0.5) * 100; // Beállítja a kurzort az LCD első sorának elejére lcd.setCursor(0, 0); lcd.print("Temperature:"); // Kiírja a "Temperature:" feliratot // Beállítja a kurzort az LCD második sorának elejére lcd.setCursor(0, 1); lcd.print(temperatureC, 1); // Kiírja a Celsius hőmérsékletet 1 tizedesjegy pontossággal lcd.write(0); // Kiírja a korábban definiált fokjelet lcd.print("C "); // Kiírja a "C" betűt float temperatureF = (temperatureC * 9.0 / 5.0) + 32.0; lcd.print(temperatureF, 1); // Kiírja a Fahrenheit hőmérsékletet 1 tizedesjegy pontossággal lcd.write(0); // Kiírja a fokjelet lcd.print("F "); // Kiírja az "F" betűt delay(1000); // Vár egy másodpercet a következő mérés előtt}

A Program Működése (I2CLCD verzió):

  • #include <LiquidCrystal_I2C.h>: Beemeli az LCD kezeléséhez szükséges könyvtárat.
  • LiquidCrystal_I2C lcd(0x27, 20, 4);: Létrehozza az LCD objektumot. A 0x27 az I2C cím (ez eltérhet, ellenőrizni kell az I2C szkennerrel), a 20 az oszlopok száma, a 4 pedig a sorok száma.
  • byte Degree[] = {...};: Definiálja az egyedi fok karaktert, amelyet a lcd.write(0) paranccsal jeleníthetünk meg.
  • lcd.init(); lcd.backlight(); lcd.createChar(0, Degree);: Az setup() függvényben inicializálja az LCD-t, bekapcsolja a háttérvilágítást és létrehozza az egyedi karaktert.
  • lcd.setCursor(0, 0); lcd.print(...): Beállítja a kurzor pozícióját és kiírja a szöveget az LCD-re.
  • lcd.print(temperatureC, 1);: Kiírja a hőmérsékletet 1 tizedesjegy pontossággal.
  • lcd.write(0);: Megjeleníti az első (0-s indexű) egyedi karaktert, ami a fok jel.

Ha mindent jól csatlakoztatott és a kódot feltöltötte, az LCD kijelzőn folyamatosan frissülő hőmérsékleti értékeket fog látni Celsius és Fahrenheit fokban.

További Fejlesztési Lehetőségek

A TMP36 hőmérő alapvető megvalósításán túl számos további fejlesztési lehetőség kínálkozik:

  • Több érzékelő használata: Az Arduino több analóg bemenetének kihasználásával egyszerre több helyszín hőmérsékletét is mérhetjük.
  • Adatgyűjtés és naplózás: Az érzékelt adatok mentése SD kártyára vagy felhő alapú szolgáltatásokra a későbbi elemzéshez.
  • Figyelmeztetések beállítása: Ha a hőmérséklet egy bizonyos küszöbérték fölé vagy alá kerül, a rendszer küldhet e-mailt, SMS-t vagy aktiválhat egy hangjelzést.
  • Hőmérséklet-szabályozás: A mért hőmérséklet alapján vezérelhetünk reléket, amelyek fűtőelemeket, ventilátorokat vagy hűtőket kapcsolnak be/ki.
  • Energiahatékonyság: A központi fűtési rendszerekhez telepített hőmérőkkel optimalizálható a hőfelhasználás, jelentős megtakarítást eredményezve. Az ilyen rendszerek telepítése jogszabályi előírásokhoz és engedélyezési eljárásokhoz kötött lehet.

A hőmérő építése nem csupán egy technikai kihívás, hanem egy remek lehetőség a digitális világ megértésére és a saját projektjeink megvalósítására. A TMP36 érzékelővel ez a folyamat rendkívül egyszerűen és gyorsan kivitelezhető.

tags: #hoember #epites #kepekben

Népszerű bejegyzések: