A hőmérséklet-érzékelő hozzáadásának az egyik legegyszerűbb és legolcsóbb módja az Arduino projektben 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. Tehát néhány csatlakozással és néhány sornyi Arduino kóddal nagyon gyorsan lehet hőmérőprogramot írni.

Hozzávalók

Eszközök

• Önálló I2CLCD modul és Karakteres kijelző vagy
• Egybeépített karakteres kijelző és I2CLCD modul
• Arduino UNO alaplap vagy Arduino Mega alaplap (de bármelyik Arduino kompatibilis alaplap megfelel)
• TMP36 hőmérő
• Jumper/Dupont kábel (anya-anya) – 3 ér

Szoftver

• Arduino IDE keretrendszer
  A cikk a Windows alatti 1.8.13 verzióval készült.

TMP36 hőmérő

A TMP36 egy kis feszültségről is működő, precíziós Celsius-hőmérséklet-érzékelő, – amelyet az Analog Devices gyárt. Ez egy olyan chip, amely a °C-ban mért hőmérséklettel lineárisan arányos kimeneti feszültséget biztosít – ezért az Arduino-val nagyon könnyen használható.

A TMP36 hőmérséklet-érzékelő meglehetősen precíz, soha nem használódik el és külső alkatrész nélkül is széles környezeti hőmérséklet-tartományban használható. Ezenkívül a TMP36 érzékelő nem igényel kalibrálást, tipikusan ±1°C pontosságot biztosít +25°C-on (±2°C-os pontosságot a -40°C és +125°C hőmérséklet-tartományban).

Az érzékelő 2.7…5.5V tápfeszültséggel működik és csak 50 µA-t fogyaszt az aktív hőmérséklet-mérés során – ami nagyon alacsony önmelegedést biztosít (kevesebb, mint 0,1 °C álló (nem kevert, nem ventilált) levegőben). Ezenkívül egy alvási funkció is rendelkezésre áll, amely a tápáramot 0,5 µA alá csökkenti.

 A TMP36 specifikációja:

Bővebb adatokat az adatlap tartalmaz: TMP36 adatlap

Működési leírás

A TMP36 szilárdtest technikát használ a hőmérséklet mérésére. Kihasználja 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. Ennek a feszültségváltozásnak a pontos felerősítésével könnyen előállítható a hőmérséklettel egyenesen arányos analóg jel.

Ez a kapcsolat lineáris a V_BE feszültség és a hőmérséklet között. Ez az oka annak, hogy a tranzisztorokat hőmérsékletmérő eszközként is lehet használni. Lényegében így mérik a hőmérsékletet, bár az évek során történt némi fejlesztés ebben a technikában. A számításokat, linearizálást, hőfokfüggő differenciálást, azaz mindezeket az összetett számításokat a TMP36 tokon belül végzi. Végül csak a hőmérséklettel lineárisan arányos feszültséget ad ki.

Hőmérsékletmérés

A TMP36 használata egyszerű, csak tápot kell adni neki (GND és +Vs=2,7-5,5 V). Ekkor a középső érintkezőn analóg feszültségértéket kapunk, amely egyenesen arányos (lineáris) a °C-ban mérhető hőmérséklettel. Ez jól látható a kimeneti feszültség ~ hőmérséklet karakterisztikán. Tipp: az analóg kimeneti feszültség értéke független a tápfeszültségtől!

A feszültség hőmérsékletre átszámítása egyszerűen az alapképlettel lehetséges:

Temp (°C) = (V_out – 0.5) * 100

Például, ha a kimenő feszültség 1 V, az azt jelenti, hogy a hőmérséklet (1 – 0,5) * 100 = 50 °C.

És honnan jön ez a képlet?

A hőmérséklet-leolvasás kiszámítása előtt a kimeneti feszültségből levonunk 0,5 V-ot, mivel a TMP36-nak +500 mV-os eltolása van. Ez az eltolás az, ami lehetővé teszi az érzékelő számára a negatív hőmérsékletek mérését. Most, hogy ezt a kijövő feszültséget hőmérsékletre konvertáljuk: egyszerűen megszorozzuk 100-zal, mert a TMP36 skálázási tényezője 10 mV/°C. Olyan egyszerű ez így már leírva, mint az 1×1.

TMP36 szenzorteszt

A TMP36 tesztelése meglehetősen egyszerű, csak csatlakoztatni kell a bal kivezetést a 2,7..5,5 V-os tápegységhez (pl. két AA elem kiválóan megfelel a célra), a jobboldali kivezetést pedig a földeléshez (feltételezve, hogy az érzékelő lapos oldala szembe néz). Ezután a  multimétert DC feszültség módban a testhez és a középső érintkezőhöz kell érinteni. Szobahőmérsékleten (~25°C) a feszültségnek körülbelül 0,75 V-nak kell lennie.

Ha kézzel melegítjük a hőmérőt (finoman összenyomva az érzékelő műanyag háza) – akkor érzékeli a hőmérséklet emelkedését.

Tipp: sózott jég esetén elérhetünk 0 fok alatti hőfokot is! Fontos! Vizes, sós közegben a hőmérőt érdemes folpack-ba csomagolni! A sós nedvesség igen korrozív – tesztelés után le kell mosni!

TMP36 szenzor lábkiosztás

A TMP36 három különböző kivitelben kapható, de a leggyakoribb típus a 3 tűs TO-92 csomag, amely úgy néz ki, mint egy tranzisztor.

A V_out (Output) pin analóg feszültséget állít elő, amely egyenesen arányos (lineáris) a hőmérséklettel. Arduinoval méréshez az Analóg (ADC) bemenetére kell csatlakoztatni.

TMP36 csatlakoztatása az Arduinohoz

A TMP36 Arduino-hoz csatlakoztatása rendkívül egyszerű. Csak a három kivezetést kell csatlakoztatni: kettőt a tápellátáshoz és egyet az érzékelő értékének leolvasásához.
Az érzékelő táplálható a 3,3V vagy az 5V kimenetről. A pozitív feszültség a „+Vs”-hez, a föld pedig a „GND”-hez csatlakozik. A középső „V_out” kivezetés az érzékelő analóg jelkimenete és ez az Arduino A4 analóg bemenetéhez csatlakozik.

Az alábbiakban látható a TMP36 csatlakoztatása:

Tipp: Az összekötés egyszerűen BreadBoard-dal vagy közvetlenül a DuPont kábellel is lehetséges.

A levegő hőmérsékletének méréséhez elegendő az érzékelőt a szabad levegőn hagyni, vagy rögzíteni olyan tárgyhoz, amelynek hőmérsékletét kell megmérni – például egy mosogatóhoz (Fontos! Az érzékelő nem vízálló kivitelű, így kívülről kell a mosogatótálcához rögzíteni).

Az analóg hőmérsékleti adatok olvasása

A fenti kapcsolási rajzon látható, hogy a TMP36 kimenete az Arduino egyik analóg bemenetéhez csatlakozik. Ennek az analóg bemenetnek az értéke az analogRead() függvénnyel olvasható ki.
Az analogRead() függvény azonban valójában nem adja vissza az érzékelő kimeneti feszültségét – ehelyett leképezi a 0 és az ADC referenciafeszültség közötti bemeneti feszültség közé (a referenciafeszültség alapértelmezetten a rendszer tápfeszültsége, azaz 5 V vagy 3,3 V). A kapott eredmény 10 bites egész érték, amelyek 0 és 1023 közötti értéket vehet fel. A szenzor kimeneti feszültségének meghatározása:

V_out = (ADC) * (5.0 / 1024)

Ez a képlet az ADC-ből származó 0-1023 számértéket 0..5 V-ra számítja át. Ha 3,3 V-os Arduino az alaprendszer, akkor a képlet így módosul:

V_out = (ADC) * (3.3 / 1024)

Ez a képlet pedig az ADC-ből származó 0-1023 számot 0-3,3 V-ra számítja át.

Ezután a V_out (TMP36) ismeretében a korábbi képlettel a hőfok kiszámítható:

Temperature (°C) = (V_out – 0.5) * 100

Az Arduino program

The following sketch shows a quick way to read a TMP36 temperature sensor and can serve as the basis for more practical experiments and projects. It simply reads the value from the TMP36 using analog port A0 and prints the current temperature (in both °C and °F) on the serial monitor. Go ahead and upload it to your Arduino.

A következő vázlat bemutatja a TMP36 hőmérséklet-érzékelő gyors leolvasásának módját, és gyakorlati kísérletek és projektek alapjául szolgálhat. Egyszerűen kiolvassa az értéket a TMP36-ról az A0 analóg porton keresztül, és kinyomtatja az aktuális hőmérsékletet (°C-ban és °F-ban egyaránt) a soros monitoron. A kódot elég az Arduino-ra közvetlenül feltölteni.

#define sensorPin A4

void setup() {
    Serial.begin(9600);
}

void loop() {
    int reading = analogRead(sensorPin);

    float voltage = reading * (5.0 / 1024.0);
    float temperatureC = (voltage - 0.5) * 100;

    Serial.print("Temperature: ");
    Serial.print(temperatureC);
    Serial.print("\xC2\xB0"); // shows degree symbol
    Serial.print("C | ");

    float temperatureF = (temperatureC * 9.0 / 5.0) + 32.0;
    Serial.print(temperatureF);
    Serial.print("\xC2\xB0"); // shows degree symbol
    Serial.println("F");

    delay(1000); // wait a second between readings
}

Ha mindent jól sikerült csinálni – valami ilyesmi lesz az Arduino terminálban megjelenítve:

A kód működése

Az Arduino program (sketch) azzal kezdődik, hogy meghatározzuk azt az Arduino kivezetést, amelyhez az érzékelő V_out kivezetése csatlakozik.

#define sensorPin A0

A beállítások részen (ez a setup()) inicializáljuk a soros kapcsolatot a számítógéppel.

void setup() {
 Serial.begin(9600);
}

A loop()-ban először az analóg jelet olvassuk be a TMP36-ból az analógRead() függvény segítségével.

int reading = analogRead(sensorPin);

Ezután a cikkben korábban tárgyalt képletek segítségével az analóg bemeneti adatokból a feszültséget számítjuk ki és utána ebből a tényleges hőmérsékletet.

float voltage = reading * (5.0 / 1024.0);
float temperatureC = (voltage - 0.5) * 100;

Ezután az eredményeket a soros monitorra küldjuk ki:

Serial.print("Temperature: ");
Serial.print(temperatureC);
Serial.print("\xC2\xB0");
Serial.print("C | ");

A kapott hőmérséklet értéke Celsius fokban (°C) áll rendelkezésre, és ezt Fahrenheit-re (°F) konvertáljuk egy egyszerű képlet segítségével. ezt szintén a soros monitorra küldjük:

T(°F) = T(°C) × 9/5 + 32

float temperatureF = (temperatureC * 9.0 / 5.0) + 32.0;
Serial.print(temperatureF);
Serial.print("\xC2\xB0");
Serial.println("F");

Tipp: a programban fok jel kiírása a \xC2\xB0 UTF karakterkóddal történik.

És a program végén 1 másodperc szünet és a mérő-kiíró program újból lefut – a végtelenségig…

A TMP36 érzékelő pontosságának javítása

Mivel nem konfiguráltuk a programban az analóg bemenethez használt referenciafeszültséget (A_Ref), az ADC-től kapott maximális felbontás 5.0/1024 = 4,88 mV vagy átszámítva 0,49 °C. (Az alapértelmezett referencia a tápfeszültség értéke.)

A pontosabb eredmények érdekében a 3,3 V-os referenciafeszültség is használható A_Ref-ként az 5 V helyett. Ez pontosabb és kevésbé zajos mérést teszt lehetővé. A 3.3V-os referenciafeszültséggel 3.3/1024 = 3.22 mV vagy 0.32°C felbontást kaphatunk.

Ha a 3,3 V-os tápkivezetést analóg referenciaként szeretnénk használni, akkor egy átkötéssel ez egyszerűen megoldható: elég csatlakoztatni az AREF (analóg referencia) bemenethez így:

Ezen a hardware átalakításon kívül néhány változtatást kell még végrehajtani a kódon is. A kód pirossal jeleztem a módosításokat:

#define sensorPin A2
#define aref_voltage 3.3

void setup() {
   Serial.begin(9600);
   analogReference(EXTERNAL);
}

void loop() {
   int reading = analogRead(sensorPin);
   float voltage = reading * (aref_voltage / 1024.0);

   float temperatureC = voltage * 100;

   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"); // shows degree symbol
   Serial.println("F");

   delay(1000); // wait a second between readings
}

A módosítások során az analogReference(EXTERNAL); sorral mondjuk meg külső referenciafeszültséget kell alapértelmezettnek venni, illetve az aref_voltage változóval egyszerűen átírható, hogy 5V vagy 3V3 vagy bármi egyéb a számításban a referenciafeszültség.

Így a hőmérés érzékenysége megnőtt, de sokszor még ez is kevés…

Bevethető a belső referenciafeszültség használata is (ez UNO esetén 2.56V, Mega esetén 1.1V vagy 2.56 V is lehet). Így az érzékenység még jobbá válik. Ez a trükk lett használva az LM35 esetén: → LM35 hőmérő és az Arduino.

De még pontosabb mérés esetén a DS18B20 digitális hőmérő is megoldás lehet: → DS18B20 használata Arduino rendszerben.

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

Néha felmerül egy ötlet, hogy jó lenne valós időben megjeleníteni a hőmérsékleti értékeket, és akár riasztást adni, ha a hőmérséklet a megadott tartományon kívül esik. Ez esetben egy 16×2 vagy 20×4 karakteres LCD-re lesz szükség a soros terminal helyett.

Itt ebben a példában az I2CLCD-t az Arduino-hoz csatlakoztatjuk a TMP36-tal együtt.
Tipp: érdemes az alapokat megismerni a használat előtt: → Az I2CLCD használata Arduino alatt.

A bekötést a következő ábra mutatja:

A következő program a hőmérsékleti értékeket a 20×4 karakteres I2CLCD-re írja ki. A kód hasonló az első példához, azzal a különbséggel, hogy a mért értékek az I2CLCD-n jelennek meg.

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);

byte Degree[] = {
    B00111,
    B00101,
    B00111,
    B00000,
    B00000,
    B00000,
    B00000,
    B00000
};

#define sensorPin A4

void setup() {
    lcd.init();
    lcd.backlight();
    lcd.createChar(0, Degree);
}

void loop() {
    int reading = analogRead(sensorPin);
    float voltage = reading * (5.0 / 1024.0);
    float temperatureC = (voltage - 0.5) * 100;
    lcd.setCursor(0, 0);
    lcd.print("Temperature:");
    lcd.setCursor(0, 1);
    lcd.print(temperatureC, 1);
    lcd.write(0); // print the custom degree character
    lcd.print("C ");
    float temperatureF = (temperatureC * 9.0 / 5.0) + 32.0;
    lcd.print(temperatureF, 1);
    lcd.write(0); // print the custom degree character
    lcd.print("F ");
    delay(1000); // wait a second between readings
}

A kijelzőn – ha mindent jól csináltunk – az alábbit kell látni:

A program működése

Az előzőkhöz képest az alábbiak kerültek még a programkódba:

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);

Ez a két sor az I2CLCD modul használatát és az LCD méretének meghatározását tartalmazza. Ekkor történik meg az lcd objektum létrehozása

byte Degree[] = {
 B00111,
 B00101,
 B00111,
 B00000,
 B00000,
 B00000,
 B00000,
 B00000 };

A fokjel karakterdefiniálási “térképe”.

lcd.init();
lcd.backlight();
lcd.createChar(0, Degree);

Az LCD inicializálása, képernyőtörlés és a háttérvilágítás bekapcsolása. Valamint a 0. kódú karakterre a fokjel tényleges létrehozása.

lcd.setCursor(0, 0);
lcd.print("Temperature:");

És a kiírások az LCD-re…

Ha a programkódba még mindenféle szépséget szeretnénk beletenni, akkor alkalmazni lehet még a Kapcsolódó anyagok közt levő I2CLCD autodetect mintát, a pontosságnövelési trükköket az LM35 hőmérőnél leírtak szerint…. Ezek a cikk rövidsége miatt csak a Kapcsolódó anyagok közt találhatóak meg…

Kapcsolódó anyagok

• Mintakódok a TMP36 hőméréshez
• TMP36 adatlap
• DS18B20 használata Arduino rendszerben
• LM35 hőmérő és az Arduino
• Automata I2CLCD illesztés Arduinora