Sensor de temperatura basado en una resistencia NTC

Sensor de temperatura basado en una resistencia NTC
Heiner Bello, Felipe Patiño, Lina Santana, Lina Soler
Universidad Nacional de Colombia
Bogotá D. C. Colombia
[email protected]
[email protected]
[email protected]
[email protected]
Abstract- This document shows the design
and construction of a temperature sensor based
on an NTC. We will see design, hardware and
software and some applications you may have
this sensor. This document can be interpreted as
a guide for anyone interested in having your own
temperature sensor.
I. INTRODUCCIÓN
Existen varias maneras de construir un sensor de
temperatura, sin embargo un sensor basado en una
NTC es un sensor muy completo y su construcción
es simple. Una resistencia NTC es aquella que tiene
un coeficiente de temperatura negativo respecto a la
variación de su resistencia, esto quiere decir que a
mayor temperatura, menos resistencia existirá y más
corriente fluirá. Basados en esa corriente o voltaje,
se determina a qué temperatura esta el NTC.
El proyecto está dividido en 3 partes: el hardware, el
software y la baquela y su caja de protección.
II.
LA NTC
Cuando se tienen estos datos, se utiliza la ecuación
anterior para calcular la resistencia en una
temperatura en particular:
𝑅𝑇 = 𝑅0 𝑒
1 1
(𝐵( − ))
𝑇 𝑇0
Donde:





RT= Resistencia a temperatura T en grados
Kelvin
Ro= Resistencia de referencia a una
temperatura T en Kelvin.
B = Valor Beta de la NTC.
T0= Temperatura de referencia en Kelvin.
T = Temperatura a medir.
Con esta ecuación, también se puede saber cuál será
la resistencia máxima que nos va a dar nuestra NTC
al calcular su curva característica, lo que sirve para
diseñar el divisor de tensión. A continuación se
muestra el gráfico de la curva característica de una
NTC de 10 K ohmios:
La relación entre la resistencia y la temperatura en la
NTC no es lineal sino exponencial. Dicha relación
cumple con la fórmula siguiente:
𝐵
𝑅 = 𝐴 ∗ 𝑒𝑇
Donde A y B son constantes que dependen del
resistor. Estas constantes están dadas por el
fabricante y se encuentran en el datasheet disponible
en la web. Las constantes A y B son:


A: El valor resistivo para una temperatura en
concreto (en este caso de ejemplo 2800Ω para
25º).
B: La Beta (Temperatura característica del
material entre 2000K y 4000K).
Figura 1: Curva característica para una NTC de 10KΩ
La NTC puede medir temperaturas desde -30 hasta
130 grados centígrados según los datos del
fabricante encontrados en el datasheet disponible en
la WEB.
III. HARDWARE
Los elementos necesarios para construir el hardware
del sensor son:
analógica, utilizando su muestreo para establecer la
temperatura crítica de las salidas. Ésta parte se
especifica en la parte del software.
C. Salidas
1 Arduino UNO
1 Protoboard
1 NTC
1 Potenciómetro de 10K ohmios
5 diodos LED
5 Resistencias 220 ohmios
1 Resistencia 1 K ohmios.
Cables
Caja de protección
Para las salidas se utilizan los LEDS y las
resistencias de 220 ohmios con el fin de limitar la
corriente y que los LEDS no se quemen.
Este es el circuito esquemático del sensor:
Por medio de la NTC se activan las 5 salidas del
Arduino, cada una con un LED para mostrar los
diferentes niveles de temperatura. La primera salida
muestra que la temperatura está por debajo de la
temperatura crítica la cual se ajusta con el
potenciómetro. Las siguientes 4 salidas se irán
activando a medida que la temperatura suba 2 °C
(ésta se puede ajustar de la manera que uno quiera
en la parte del Software).
El circuito está estructurado en 3 partes:
Figura 3: Esquema del circuito del sensor de temperatura
A. Entrada de temperatura ambiente.
La NTC se conecta en paralelo con otra resistencia
para tener un divisor de corriente el cual nos permite
controlar el voltaje de entrada del circuito además de
eliminar el problema de la no linealidad (cuando la
corriente en la NTC es muy alta, se disipará en calor
y su medición de temperatura no será confiable.)
Es importante probar el circuito en una Protoboard
antes de tener el circuito impreso en una baquela ya
que si existen problemas de conexión, estos se
pueden corregir en la Protoboard. A continuación se
muestra las conexiones de ejemplo del sensor en la
Protoboard:
Diagrama del divisor de voltaje:
Figura 2: Diagrama de un divisor de tensión
B.
Entrada de ajuste mínimo de temperatura
Para tener un control para ajustar la temperatura
mínima, simplemente se coloca un potenciómetro
dispuesto como divisor de voltaje, a la entrada
Figura 4: Sensor de temperatura utilizando una Protoboard
IV. SOFTWARE
El programa que se utiliza para programar el
Arduino se encuentra en la web en la página oficial
del Arduino. El código de programación se anexa al
final del software. A continuación se explicará de
forma detallada el código:
#include <math.h>
La librería math.h posee las funciones que
necesitamos para el programa. El #include nos
importa estas funciones.
Se definen los pines de entrada y salida
//Pines para los LED
int pinLed1 = 8;
int pinLed2 = 9;
int pinLed3 = 10;
int pinLed4 = 11;
int pinLed5 = 12;
//Pines para las entradas
analógicas
int analogPin1 = 0;
int analogPin2 = 1;
Se declara la variable “escala” como entero:
int escala = 2;
Esta variable se utiliza para establecer el intervalo
entre las alarmas, es decir, si se pone una
temperatura de disparo de 20ºC, con una escala de 2
la primera alarma será a 20º, la segunda a 22º, la
tercera a 24º, etc. Si se coloca una escala de 5 con
una temperatura de 15°C, la primera alarma será a
15°, la segunda a 20°, la tercera a 25°, etc.
Se introducen los datos para hacer las ecuaciones
que nos permitirán, en base a la lectura de la entrada
analógica conectada al divisor de tensión, calcular la
temperatura.
float Vin = 5.0;
// [V]
Tensión alimentación del divisor
float Rfija = 1000; // [ohm]
Resistencia fija del divisor
float R25 = 2800;
// [ohm]
Valor de NTC a 25ºC
float Beta = 3900.0; // [K]
Parámetro Beta de NTC
float T0 = 293.15;
// [K]
Temperatura de referencia en Kelvin
float Vout = 0.0;
// [V]
Variable para almacenar Vout
float Rntc = 0.0;
// [ohm]
Variable para NTC en ohmnios
float TempK
Temperatura
float TempC
Temperatura
= 0.0;
// [K]
salida en Kelvin
= 0.0;
// [ºC]
salida en Celsius
La variable de tipo “float” es para los números en
coma
flotante
(número
decimal),
estas
variables tienen un valor máximo 3.4028235E+38, y
como mínimo -3.4028235E+38. Ocupan 4bytes
(32bits) con una resolución mucho mayor que los
enteros, lo que permite hacer cálculos bastante
precisos, se debe tener en cuenta no olvidar la coma
en los números de la operación, de manera que se
evitan errores de interpretación en el programa.
En cuanto a los parámetros se necesitan conocer los
2 datos de la NTC que vendrán dispuestos en el
datasheet, una resistencia de referencia a una
temperatura determinada, en este caso de ejemplo
2800Ω a 25º y la Beta de 3950 K.
Una vez finalizada la declaración de variables
globales, se “configura” el setup
Serial.begin(9600);
Esta instrucción inicializa la comunicación puerto
serie desde Arduino al PC a una velocidad de 9600
baudios (bits por segundo), con esto, cualquier cosa
que se envía se visualiza en el monitor de puerto
serie del software de Arduino
Figura 5: Herramienta Monitor Serial para visualizar la
temperatura en el PC
Se declaran los pines de entrada y los pines de salida
//Declaración de
pinMode(pinLed1,
pinMode(pinLed2,
pinMode(pinLed3,
pinMode(pinLed4,
pinMode(pinLed5,
pines de salida
OUTPUT);
OUTPUT);
OUTPUT);
OUTPUT);
OUTPUT);
//Declaración pines de entrada
pinMode(analogPin1, INPUT);
pinMode(analogPin2, INPUT);
Se comienza el bucle, en primer lugar se lee la señal
del potenciómetro para establecer una temperatura
de referencia sobre la que comparar la temperatura
de la NTC y disparar los avisos. Se lee el valor del
pin analógico 2 y lo se almacena en tempMin:
tempMin = analogRead(analogPin2);
A continuación se tiene una nueva instrucción:
tempMin = map (tempMin, 0, 1023,
-100, 800);
La función map tiene la siguiente estructura:
map(valor, fromLow, fromHigh, toLow, toHigh)
Esta estructura convierte los calores que van de 0 a
1023 en valores escalonados y proporcionados desde
-100 has 800. Con esto se adapta la lectura del
potenciómetro a un rango de -100 a 800, Luego se
divide este valor en 10
tempMin = tempMin/10;
La temperatura que se devuelve es la de referencia o
crítica y está entre -10.0º y +80.0º,. La temperatura
de disparo se puede ajustar con una precisión de
0.1°.
Se manda por el puerto serie el dato prefijado para
tener una referencia visual del mismo.
Serial.println("----------------------------------------------");
Serial.println();
Serial.print("AJUSTE DE
TEMPERATURA MINIMA A ");
Serial.print(tempMin);
Serial.println(" GRADOS
CELSIUS");
Serial.println();
Serial.println("----------------------------------------------");
El Serial.println() envia por puerto serie cualquier
cosa que se incluya dentro de ( ), si es una variable,
con poner el nombre de la variable es suficiente,
como se puede ver con tempMin, pero también se
puede mandar cualquier texto, siempre que se
incluya entre comillas.
//Y por último la temperatura en
Kelvin
TempK =
Beta/(log(Rntc/R25)+(Beta/T0));
//Ahora la pasamos a celsius
TempC = TempK-273.15;
Se envían por el puerto serie:
Serial.println();
Serial.print("LA TEMPERATURA DE
LA NTC ES DE ");
Serial.print(TempC);
Serial.println(" GRADOS
CELSIUS");
Serial.println();
El delay que se pone al final es para que mande los
datos de temperatura 500 milisegundos por el puerto
serie.
delay(500);
V. BAQUELA Y CAJA DE
PROTECCIÓN
Esta parte del sensor es opcional, ya que no se puede
hacer en casa como las demás partes del sensor y no
es necesaria para su funcionamiento además de
requerir conocimientos en programas de diseño de
circuitos. Para pasar el circuito de la Protoboard a un
circuito impreso es necesario tener un software de
diseño de circuitos, como PROTEUS, ORCAD,
MULTISIM etc.
En el software se diseña el circuito del sensor, en
este caso de ejemplo se utilizo el programa
PROTEUS, lo importante no es tener los mismos
componentes del circuito sino tener componentes en
el diseño con los mismos puertos que tienen los
componentes físicos ya que no siempre se pueden
simular los componentes del diseño en físico, como
es el caso de los LEDs o el potenciómetro.
Diseño en ISIS del circuito:
Se introducen las funciones que calcularán la
temperatura de la NTC
//Primero la Vout del divisor
Vout=(Vin/1024)*(analogRead(analogP
in1));
//Ahora la resistencia de la NTC
Rntc=(Vout*Rfija)/(Vin-Vout);
Figura 6: Diseño del circuito del sensor en ISIS
Ahora se debe utilizar la herramienta “Netlist
Transfer to Ares” ubicada en la parte superior
derecha
introducir el circuito con el Arduino y tener listo el
sensor de temperatura. A continuación un ejemplo
de cómo puede quedar un sensor de temperatura
basado en una NTC utilizando esta guía:
Se Abre el programa Ares donde se sacará el circuito
impreso para la baquela. Se puede ajustar los
elementos de manera subjetiva o el programa los
puede ubicar en el sitio más apropiado. Luego de
ubicar los elementos de la manera que uno quiera se
inicia la herramienta Auto-router
el cual
organiza las pistas del circuito de la mejor forma:
Figura 9: Sensor de temperatura parte inferior
Figura 7: Diseño del circuito del sensor en ARES para la
impresión de la baquela
Se debe imprimir el diseño del circuito para poder
imprimir la baquela y tener el circuito listo para
soldar. Una forma de imprimir el circuito es con el
programa libre PDFCreator disponible en la Web (el
diseño de éste circuito es un ejemplo, puede ser
acomodado como se requiera).
Figura 8: Circuito impreso del sensor de temperatura para la
impresión en la baquela
Ya con el circuito impreso se puede mandar a
imprimir en una baquela en cualquier tienda
electrónica de la ciudad, en Bogotá las tiendas de
componentes electrónicos se encuentran en la calle
19 con avenida novena.
Luego de soldar los componentes se puede comprar
una caja de plástico y de acuerdo al diseño,
Figura 10: Sensor de temperatura parte superior
VI. COSTOS
Los costos de todo el sensor del ejemplo son:
1 Arduino UNO
1Cable Arduino
1 NTC
1 Potenciómetro de 10K ohmios
5 diodos LED
6 Resistencias
Cables de conexión
Caja de protección
Baquela
$70 000
$7 000
$4 000
$500
$500
$300
$ 6 000
$ 6 000
$ 9 000
Total
$103 300
Herramientas que se utilizaron:
Protoboard
Alicates
Estaño y crema para soldar
Cautín
Bisturí
VII. APLICACIONES
El sensor de temperatura tiene muchas aplicaciones,
como por ejemplo medir la temperatura ambiental de
manera permanente o estacional gracias a que los
datos se pueden ver en un computador y ser
almacenados con el fin de sacar un promedio de
temperaturas, así, se puede hacer un historial de
temperaturas del tiempo que se requiera.
Si se necesita mandar los datos a un lugar lejano, por
medio del internet la temperatura medida se podrá
ver en cualquier lugar del mundo. Existen varios
lugares en los cuales se necesita saber la temperatura
ambiente como en hospitales, salas de recuperación,
en cocinas y restaurantes, en un laboratorio, un
invernadero, bodegas, entre muchos otros lugares.
Otra aplicación muy importante es la medición de la
temperatura de algún equipo o material. Cuando los
equipos de algún proceso ya sea de industria o de
otro tipo se sobrecalientan o no trabajan a la
temperatura que se requiere su vida útil se verá
afectada, por lo que un sensor de temperatura es
indispensable
para
garantizar
el
buen
funcionamiento del equipo o del material.
RECONOCIMIENTOS
Se le agradece al profesor Jaime Villalobos (Phd)
por su gran motivación la cual permitió que este
proyecto se hiciera realidad
VIII.
REFERENCIAS
[1]
(2012) Sensores de temperatura. [Online]. Disponible
en: http://www.antirrobo.net/sensores/sensores-de-temperatura.
html
[2]
(2012) formato IEEE para presentar artículos.
[Online]. Disponible en http://www.cidca.edu.co/Formato_IEEE/
Formato _Articulos_IEEE.pdf
[3]
R. C. Dorf y J. A. Svodoba. Circuitos eléctricos, sexta
edición. 2006
Código completo del programa:
/*
Sensor NTC
Se conecta una NTC a una entrada
analógica para controlar cinco salidas
en función de la temperatura.
Se utiliza un potenciómetro para
controlar la temperatura a partir de la cual
se activarán las salidas
*/
//Se añade la librería math.h
#include <math.h>
//Pines para
int pinLed1 =
int pinLed2 =
int pinLed3 =
int pinLed4 =
int pinLed5 =
los LED
8;
9;
10;
11;
12;
//Pines para las entradas analógicas
int analogPin1 = 0;
int analogPin2 = 1;
//Escala de Avisos
int escala = 2;
//Variable para la temperatura de disparo
double tempMin = 0.0;
//Datos para las ecuaciones
float
float
float
float
float
Vin = 5.0;
Rfija = 1000;
R25 = 2800;
Beta = 3900.0;
T0 = 293.15;
// [V]
// [ohm]
// [ohm]
// [K]
// [K]
Tensión alimentación del divisor
Resistencia fija del divisor
Valor de NTC a 25ºC
Parámetro Beta de NTC
Temperatura de referencia en Kelvin
float Vout = 0.0;
float Rntc = 0.0;
// [V]
// [ohm]
Variable para almacenar Vout
Variable para NTC en ohmnios
float TempK = 0.0;
float TempC = 0.0;
// [K]
// [ºC]
Temperatura salida en Kelvin
Temperatura salida en Celsius
void setup() {
//Comienza la comunicación puerto serie
Serial.begin(9600);
//Declaración de
pinMode(pinLed1,
pinMode(pinLed2,
pinMode(pinLed3,
pines de salida
OUTPUT);
OUTPUT);
OUTPUT);
pinMode(pinLed4, OUTPUT);
pinMode(pinLed5, OUTPUT);
//Declaración pines de entrada
pinMode(analogPin1, INPUT);
pinMode(analogPin2, INPUT);
}
void loop()
{
//Se lee el potenciómetro
tempMin = analogRead(analogPin2);
//Se mapea a valores de -100 a 800
tempMin = map (tempMin, 0, 1023, -100, 800);
//Se divide entre 10 para darle un decimal
tempMin = tempMin/10;
//Se lanza el ajuste establecido vía serie
Serial.println("-----------------------------------------------");
Serial.println();
Serial.print("AJUSTE DE TEMPERATURA MINIMA A ");
Serial.print(tempMin);
Serial.println(" GRADOS CELSIUS");
Serial.println();
Serial.println("-----------------------------------------------");
//Se calcula la temperatura
//Primero la Vout del divisor
Vout=(Vin/1024)*(analogRead(analogPin1));
//Ahora la resistencia de la NTC
Rntc=(Vout*Rfija)/(Vin-Vout);
//Y por último la temperatura en Kelvin
TempK = Beta/(log(Rntc/R25)+(Beta/T0));
//de kelvin a Celsius
TempC = TempK-273.15;
//se muestra por puerto serie
Serial.println();
Serial.print("LA TEMPERATURA DE LA NTC ES DE ");
Serial.print(TempC);
Serial.println(" GRADOS CELSIUS");
Serial.println();
//Ahora las comparaciones para las salidas
if(TempC < tempMin)
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if (((TempC <= (tempMin + escala)) & (TempC > tempMin)))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if (((TempC<=(tempMin+(escala*2)))&(TempC>tempMin+escala)))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if ((TempC<=(tempMin+(escala*3)))&(TempC>tempMin+(escala*2)))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, LOW);
}
else if (TempC > (tempMin + (escala*4)))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, HIGH);
}
//Un delay para fijar el tiempo de muestra en el puerto, en este caso son
500 milisegundos
delay(500);
}