Download Heiner Bello Cód: 142880 Felipe Patiño Cód: 261775 Lina Santana

Heiner Bello
Cód: 142880
Felipe Patiño
Cód: 261775
Lina Santana
Cód: 153434
Lina Soler
Cód: 245071
Sensor de temperatura
De los sensores investigados el sensor más completo es el que está basado en
un NTC, es decir en una resistencia con 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 2 partes, la del hardware y la del software
Hardware
Elementos necesarios para el sensor:
1 Arduino
1 Protoboard
1 NTC
1 Potenciómetro de 10K ohmios
5 diodos LED
5 Resistencias 220 ohmios
1 Resistencia 1 K ohmios
Cables
Por medio de la NTC se activan las 5 salidas del Arduino, cada una con un LED
para mostrar los diferentes niveles de temperatura. Cada salida se irá
activando a medida que la temperatura suba 2 °C. Esto se puede ajustas de la
manera que uno quiera en la parte del Software. El potenciómetro se encarga
de ajustar la temperatura la cual sirve para lanzar los avisos.
El circuito está estructurado en 3 partes:
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 corriente (si la corriente es
muy alta, el sensor no tendrá un comportamiento lineal, es decir el
voltaje de salida no es exacto).
b) Entrada de ajuste mínimo de temperatura
Se coloca un potenciómetro para controlar la entrada de temperatura
mínima que saca la NTC y sirve como divisor de tensión para una de las
entradas analógicas y utilizaremos su muestreo para mapearlo como se
necesite, esto se especificará en la parte del software.
c) Salidas
Para las salidas se utilizan los LEDS y resistencias con el fin de limitar la
corriente y que los LEDS no se dañen
Este es el circuito esquemático del sensor:
Software
El código de programación es el siguiente:
la librería math.h
#include <math.h>
//
int pinLed1 = 8;
int pinLed2 = 9;
int pinLed3 = 10;
int pinLed4 = 11;
int pinLed5 = 12;
//
int analogPin1 = 0;
int analogPin2 = 1;
//
int escala = 2;
//Variable para la temperatura de disparo
double tempMin = 0.0;
//Datos para las ecuaciones
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;
float Rntc = 0.0;
// [V]
Variable para almacenar Vout
// [ohm] Variable para NTC en ohmnios
float TempK = 0.0; // [K]
float TempC = 0.0; // [ºC]
Temperatura salida en Kelvin
Temperatura salida en Celsius
void setup() {
//comunicación puerto serie
Serial.begin(9600);
//pines de salida
pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
pinMode(pinLed4, OUTPUT);
pinMode(pinLed5, OUTPUT);
//pines de entrada
pinMode(analogPin1, INPUT);
pinMode(analogPin2, INPUT);
}
void loop()
{
//potenciómetro
tempMin = analogRead(analogPin2);
//
tempMin = map (tempMin, 0, 1023, -100, 800);
//
tempMin = tempMin/10;
//
Serial.println("-----------------------------------------------");
Serial.println();
Serial.print("AJUSTE DE TEMPERATURA MINIMA A ");
Serial.print(tempMin);
Serial.println(" GRADOS CELSIUS");
Serial.println();
Serial.println("-----------------------------------------------");
//Temperatura
//Vout del divisor
Vout=(Vin/1024)*(analogRead(analogPin1));
//resistencia de la NTC
Rntc=(Vout*Rfija)/(Vin-Vout);
//temperatura en Kelvin
TempK = Beta/(log(Rntc/R25)+(Beta/T0));
//temperatura en Celsius
TempC = TempK-273.15;
// Serial.println();
Serial.print("LA TEMPERATURA DE LA NTC ES DE ");
Serial.print(TempC);
Serial.println(" GRADOS CELSIUS");
Serial.println();
//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);
}
//
delay(500);
}
El código empieza agregando la librería math, luego se definen los pines de
entrada y salida del Arduino. Se declara la variable escala con la cual se
establece el intervalo de alarmas para los LEDS, en este caso se establece
como 2 grados.
Luego se introducen los datos necesarios para las ecuaciones que calcularán
la temperatura que va a mostrar la pantalla del computador. Como es necesario
que hayan decimales, estas variables son de tipo float.
Es necesario tener 2 referencias del NTC, su resistencia de referencia a una
temperatura en particular, estos datos se consiguen en el datasheet del
elemento. La resistencia es de 2800 ohmios a una temperatura de 25 °C. Se
define el bucle estableciendo una temperatura de referencia y poderla
comparar con los valores que salgan.
Por último los datos se envían por el puerto serie a la salida para que se
muestren en pantalla