Sensor de temperatura y control

por medio de PIC16F887

Administrador abril 15, 2014 PIC 37 comentarios

SENSOR DE TEMPERATURA Y CONTROL

POR MEDIO DE PIC16F887
En primer lugar, la temperatura es una magnitud física que poseen los cuerpos
rígidos, gases etc. La temperatura es energía cinética que contiene ese cuerpo en
un instante de tiempo, que es lo mismo que la medida en la que se puede
dictaminar si un cuerpo está caliente o esta frío. Como consecuencia, este
parámetro se puede medir con un sensor de temperatura y esto se cuantifica
mediante escalas de temperatura como lo son Celsius, Kelvin, Fahrenheit.

La temperatura es un factor a considerar para todo, debido a que un incremento

en temperatura de por ejemplo de una maquina industrial causaría desperfectos
en ella. Tan solo en el cuerpo humano un incremento de temperatura mayor a 36
grados Celsius puede causar un grave daño en el organismo. Además de la misma
manera pasa cuando se tienen temperaturas menores a los 36 grados Celsius se
podría caer hipotermia, por ello el control de la temperatura es un factor a
considerar. Por consiguiente la industria no es la excepción , ya que la
temperatura pude influir en causar daños a la misma máquina o al producto.

Para empezar, el control de temperatura ha sido un tema de interés para la

ingeniería. Como resultado, se han implementado diferentes sistemas de control
de temperatura, ya sea para aumentar o bajar la temperatura. Por lo tanto, se
tiene sistemas de calefacción, ciclos de refrigeración , lavado de aire que
comúnmente se le conoce como aire acondicionado, entre otros procesos de
control. Para el control de la temperatura se hace uso de la tecnología.
Finalmente en base a estas consideraciones los actuadores entran en acción, ya
sean ventiladores, ciclos de refrigeración etc.

OBJETIVOS DE SENSOR Y CONTROL DE

TEMPERATURA
 Desarrollar un sistema automático para la regulación y control de la temperatura
mediante un Sensor de temperatura aplicado a una maquina industrial.
 Poner en práctica los conocimientos de programación de microcontroladores PIC.
 Dar una aplicación real de los circuitos digitales que sean de utilidad.

MATERIAL Y EQUIPO PARA PROYECTO PIC

 Programador de PIC
 1 PIC 16F887
 1 Cristal de cuarzo a 20Mhz
 10 LED’s de 5 mm.
 10 Resistores de 330 Ω. a ¼ watt
 Cable de colores 24 AWG.
 2 Tabletas de prueba Protoboard.
 2 Capacitor Cerámico de 22 uF.
 1 Fuente de laboratorio.
 2 Cables Banana- Caimán.
 4 Push button
 2 Sensor de temperatura LM35
 L293D
 2 Ventiladores de 12 V
 Pantalla LCD 16×2
 1 Buzzer
PROPUESTA DE SENSOR DE TEMPERATURA Y
CONTROL CON L293
Para empezar, se requiere diseñar un sistema de control que sea capaz de sensar
la temperatura en tiempo real mostrada por medio de un LCD. El sistema tendrá
tres rangos de temperatura, menor a 0 °C, de 0 °C a 30 °C y mayor a 30 °C, en
este caso, por lo tanto, se mandara una alerta. Resumidamente para controlar la
temperatura se activaran dos ventiladores en proporción al rango que se
encuentre la temperatura actual. El sensor de temperatura es la entrada a nuestro
sistema.

A continuación se presenta el diagrama de bloques, por lo que podemos observar

de manera general el sistema. En este mismo diagrama se muestra, la internación
entre los elementos, como es que se conectan y cómo funciona el circuito.
Diagrama de bloques
DESARROLLO DEL SENSOR DE
TEMPERATURA Y CONTROL
En primer lugar, el diagrama de flujo es un estructura gráfica que permite
visualizar el algoritmo a seguir. Para tener una programación mas estructurada
del microcontrolador, debido a que se desea tener un mayor orden en el diseño
del sistema de control de temperatura.
Diagrama de flujo
 A partir del diagrama de flujo se procedió a la programación del
microcontrolador empelando el software PIC C CCS, en lenguaje C. El programa
se muestra a continuación, con sus respectivos comentarios.

DIAGRAMA ELÉCTRICO ESQUEMÁTICO DEL

CONTROL DE TEMPERATURA
Una vez depurado de errores y sintaxis errónea se procedió a compilar el
programa el cual no tiene ningún error. Posteriormente se simuló el programa en
PROTEUS y se comprobó que efectivamente el circuito de control cumpliera con
las especificaciones y objetivos del proyecto. Dando resultados positivos de esta
manera se paso al siguiente paso, a grabar el chip por medio una tarjeta de
desarrollo para el PIC16F887.

Diagrama electrico simulacion

En la Figura se muestra la simulación del circuito el cual consiste en diferentes
etapas las cuales son las siguientes:

 Procesamiento: El cual se da por medio del microcontrolador PIC16F887.

 Sensores: Por medio de dos sensores de temperatura LM35.
 Actuadores: Se lleva a cabo por medio de dos ventiladores de 12 V a 1.2 A.
 Despliegue: Este forma dos partes: Ambiente gráfico en C# mediante
comunicación RS232 y LCD de 16×2 pixeles.
 Interacción: Por medio de dos botones dedicados para cada sensor de
temperatura.
 Alarma: Esta conforma por tres LED´s los cuales fingirán como semáforos,
cuando si la temperatura es mayor a 40 °C se activa una alarma sonora.
DIAGRAMA A DETALLES SENSOR DE
TEMPERATURA Y VENTILADORES
Posteriormente se comenzara la lectura de la temperatura proporcionada por un
Sensor de temperatura LM35. Donde el microcontrolador PIC comenzara la
lectura del la señal proporcionada por el sensor de temperatura.A continuación se
muestra cómo es que se da el despliegue de la señal por medio del LCD, además
de la comunicación RS232 esta se simulara por medio de una terminal virtual que
es una herramienta que nos proporciona el simulador Proteus.

Despliegue de la señal (LCD)

En este caso se muestra una temperatura de 45°C lo cual según nuestro rango de
temperaturas es alto. Debido a esto, se mandara una señal de alarma por medio de
un buzzer, además de que en el semáforo se debe encender el LED rojo. A su
vez, además deben de estar funcionando ambos ventiladores, con el fin de reducir
la temperatura.

Simulación del funcionamiento

En el caso de que se encuentre una temperatura en el rango medio, que debe ser
el adecuado, se procede de la misma forma. En este caso solo se acciona un
motor, con el fin de eficiente el suministro de energía, el despliegue se da de la
misma manera, esto se ilustra a continuación.

Diagrama de control
Para último caso que la temperatura sea menor de 10 °C, el despliegue del LCD,
el semáforo, será de la siguiente manera.
 Diagrama de control
Ese es el funcionamiento del circuito de control, se han tratado los tres posibles
casos. Por lo que es de esta manera que el sistema funciona.

PROGRAMA EN C# PARA EL SISTEMA DE

CONTROL Y COMUNICACIÓN
En este ambiente de control gráfico tenemos que cuenta tres botones uno de ellos
nos conecta al PIC y comienza a recibir datos por medio de la comunicación
RS232. El segundo botón nos desconecta de dicha conexión y el tercer botón se
utiliza para salir de la aplicación. Así mismo cuenta con una etiqueta la cual nos
indica el estado de nuestra aplicación, ya sea conectado o desconectado. Otra
etiqueta nos informa el estado de los motores es decir activado o desactivado. La
tercer etiqueta nos indica la temperatura actual que se encuentra nuestro
dispositivo.
 Interfaz grafica
En esta imagen observamos que la conexión es exitosa y así mismo tiene una
temperatura de 9°C. Por lo tanto su color es verde y así mismo se encuentran los
motores desactivados

Interfaz grafica
En esta siguiente imagen observamos que ahora la temperatura es de 19°C. Por lo
tanto, nos encontramos en una alerta media lo cual lo vemos en la imagen ya que
es de color amarillo y se encuentra un motor activado
 Interfaz grafica
Para esta imagen vemos que la temperatura es de 40°C. Por lo tanto nos manda
una señal de alerta así como los indicadores color rojo

IMPLEMENTACIÓN FÍSICA DEL SISTEMA

CONTROLADOR DE TEMPERATURA
Ya pasada la etapa de programación y simulación del micrcontrolador, se
procedió a la parte de la implantación física.

 Implementación del Circuito

 Implementación de una maqueta ilustrativa
 Circuito de prueba
La parte de los ventiladores se implemento por medio de una etapa de
amplificación. Empleado un chip L293D que es un puente H, ya que los
ventiladores funciona a 12 V y a 1.2V. El microcontrolador no es capaz de
suministrar tal energía, se muestra a continuación el ventilador a emplear.
Ventilador
 Maqueta fisica

Los resultados obtenidos se muestran en las siguientes imágenes. Las imagenes

muestran el proyecto final, ya implementado en su totalidad.

Proyecto final

CÓDIGO DE MICROCONTROLADOR PIC16F887

Código de programación del micrcocontrolador en lenguaje C por medio del
compilador CCS.

//Mendez Cruz Juan Daniel

//Carlos Chavez
//Control de temperatura por medio de dos sensores LM35 controlados por PIC16F887
//Rangos de Temperatura baja>10 grados C,Temperatura media[10,30] grados C
//Temperatura alta> 40 grados C, para temperatura media se acciona un ventilador
//Para Temperatura alta se acciona segundo ventilador se dispara una alarma

#include <16F887.h>
#device ADC=10 //Resolución de 10 bits para ADC
#fuses INTRC_IO,NOCPD,NOWDT,NOPUT,NOLVP,NOBROWNOUT,MCLR
#use delay(clock=2M)
#define use_portd_lcd TRUE
#use rs232(baud=9600,xmit=PIN_C6,rcv=PIN_C7) // Pines para establecer comunicación RS232
#include <lcd.c>

#use fast_IO(A) // Configuración rápida del puerto A

#use fast_IO(B) // Configuración rápida del puerto B
#use fast_IO(C) // Configuración rápida del puerto C

long temp; //Variable de tipo long temp

long conversion; //Variable de tipo long conversión
long conversion1; //Variable de tipo long conversión1
float temo; // //Variable de tipo flotante temo

unsigned int16 resultado; //Variable de 16 bits sin signo resultado

float sensor(int8 primero , int8 segundo) //función que controla al sensor de temperatura par
{
while(true) //Cliclo siempre activo
{
set_adc_channel(primero); //Seleccionando canal a primero
delay_us(10); // tiempo de espera de 10 us segundos
conversion=read_adc(); //conversión lee el canal analógico
set_adc_channel(segundo); // definiendo el canal que se va a leer
delay_us(10); // tiempo de espera de 10 us segundos

conversion1=read_adc() ; //Conversión1 lee el canal analóico

if(conversion>conversion1) //Condisión conversión> conversió 1
{
temp=conversion-conversion1;

temo=temp*500/1023 ; //rectifica el sensor de temperatura

lcd_gotoxy(2,1); // posición 2 en x y 1 en y de LCD
printf(lcd_putc,"Tempera:%f",temo); //Imprime en el LCD Tempera es temo
printf("%6.2F",temo); //imprime en LCD
delay_ms(200); //tiempo de espera de 200 msSegundos

lcd_gotoxy(2,2); // posicion 2x y 2 y del LCD

printf(lcd_putc"Grados Celcius"); // imprime en el LCD
delay_ms(200); // tiempo de retardo 200 ms S
if(temo>30) // consicion de rangos de temp si temo menor a treinta
{
OUTPUT_high(PIN_C3); // nivel alto pin C3
delay_ms(30); //espera 50 ms S
OUTPUT_low(PIN_C3); //apaga C3
delay_ms(20); //espera 50 ms S
OUTPUT_high(PIN_C3); //nivel alto pin C3
delay_ms(20); //espera 50 ms S
OUTPUT_low(PIN_C3); //apaga C3
delay_ms(20); //espera 50 ms S
OUTPUT_high(PIN_C3); // nivel alto pin C3
delay_ms(20); //espera 50 ms S
OUTPUT_low(PIN_C3); //apaga C3
delay_ms(20); //espera 50 ms S
OUTPUT_high(PIN_C3); // nivel alto pin C3
delay_ms(20); //espera 50 ms S
OUTPUT_low(PIN_C3); //apaga C3
delay_ms(20); //espera 50 ms S
OUTPUT_high(PIN_C3); // nivel alto pin C3
OUTPUT_low(PIN_C4); //apaga C4
OUTPUT_low(PIN_C5); //apaga C5
}

if(temo>10 && temo<30 ) //temo esta entre 10 y 30

{
OUTPUT_high(PIN_C4); //prende CA
delay_ms(100); //espera 100 ms
OUTPUT_low(PIN_C4); //apaga C3
delay_ms(100); //espera 100 ms S
OUTPUT_high(PIN_C4); //prende C4
delay_ms(100); //espera 100 ms
OUTPUT_low(PIN_C3); //apaga C3
OUTPUT_low(PIN_C5); //apaga C5

}
if(temo>10) //temo mayor a 18
{
OUTPUT_HIGH(PIN_C0); //enciende C0
OUTPUT_LOW(PIN_B6); //enciende Buzzer
}

else
{
OUTPUT_LOW(PIN_C0); //apaga C0
OUTPUT_LOW(PIN_B6);
}

if(temo>40) //temo mayor a 40

{
OUTPUT_HIGH(PIN_B7); //enciende B7
OUTPUT_HIGH(PIN_B6); //enciende B7
}

else
{
OUTPUT_LOW(PIN_B7); //apaga B7
OUTPUT_LOW(PIN_B6); //enciende B7
}

if(temo>0 && temo<10) //temo mayor a 0

{
OUTPUT_high(PIN_C5); // enciende C5
delay_ms(100); //espera 100 ms S
OUTPUT_low(PIN_C5); // apaga C5
delay_ms(100); //espera 100 ms S
OUTPUT_high(PIN_C5); //enciende C5
delay_ms(100); //espera 100 ms S
OUTPUT_low(PIN_C3); // apaga C3
OUTPUT_low(PIN_C4); // apaga C4
}
}

if(conversion1>conversion) //conversion1>conversion
{
temp=conversion1-conversion;
temo=temp*500/1023 ;
lcd_gotoxy(2,1); //posición 2x 1y del LCD
printf(lcd_putc,"Tempera:-%f",temo); //impirme en LCD
lcd_gotoxy(2,2); //posición 2x 2y del LCD
printf(lcd_putc"Grados Celcius"); //imprime en LCD
delay_ms(200); // espera 200 ms
// printf("\fUNAM MECATRONICA FI\rCircuitos Digitales \rTemperatura: -%6.2f C°",temo); //Im
delay_ms(200); //tiempo de 200 ms
if(temo>0) //temo mayor a 0
{
OUTPUT_high(PIN_C5); // enciende C5
delay_ms(100); //espera 100 ms S
OUTPUT_low(PIN_C5); // apaga C5
delay_ms(100); //espera 100 ms S
OUTPUT_high(PIN_C5); //enciende C5
delay_ms(100); //espera 100 ms S
OUTPUT_low(PIN_C3); // apaga C3
OUTPUT_low(PIN_C4); // apaga C4
}
}
delay_ms(800); //tiempo de espera 800 ms S
}
return temo; //regresa el valor de temo
}

void main ()
{
set_tris_b(0x0C); //configurando como salida el puerto B
set_tris_c(0x00); //configurando como salida el puerto C

setup_adc(ADC_CLOCK_DIV_32); //EL RELOJ DE CONVERSIÓN del ADC

setup_adc_ports(sAN0| sAN1| sAN5|sAN6); //Canales analógicos a usarse AN0, AN1, AN5,
delay_ms(100); //tiempo de espera 100 ms
lcd_init();
//printf("\fUNAM MECATRONICA FI\rCircuitos Digitales \rProyecto Final"); // imprimiend
delay_ms(500); //tiempo de espera 500 ms S
//printf("\fCargando......"); // imprimiendo por medio de RS232
delay_ms(200); //tiempo de espera 200 ms S
printf(lcd_putc,"UNAM INGENIERIA\n MECATRONICA FI"); //imprimiendo en LCD
delay_ms(2000); //tiempo de espera 1000 ms S
printf(lcd_putc,"\f"); // borrando LCD
printf(lcd_putc," Control de \n temperatura"); //imprimiendo en LCD
delay_ms(1000); //tiempo de espera 1000 ms
printf(lcd_putc,"\f"); // borrando LCD
printf(lcd_putc," Circuitos\n Digitales"); //imprimiendo en LCD
delay_ms(1000); //tiempo de espera 1000 ms
printf(lcd_putc,"\f"); // borrando LCD
printf(lcd_putc," DanielMendez\n Carlos Chavez"); //imprimiendo en LCD
delay_ms(1000); //tiempo de espera 1000 ms

lcd_init(); //INICIALIZA LCD

while(true) //bucle infinito

{
if(input(PIN_A2)==0 && input(PIN_A2)==0 ) //si a2 esta apagado
{
printf(lcd_putc,"Presione\n un boton"); // imprime LCD
delay_ms(3000); //espera 1500 ms
printf(lcd_putc,"\f"); //borrando LCD

OUTPUT_LOW(PIN_B7); //apaga B7
OUTPUT_LOW(PIN_C0); //apaga C0
}

if(input(PIN_A2)==1) // si la entrada A2 se presiona

{
printf(lcd_putc,"Sensor 1"); //impirme en LCD
delay_ms(500); //espera 1500 ms
printf(lcd_putc,"\f"); //borrando LCD
delay_ms(500);
sensor(5,6); //activa función sensor con canala analógico 5, 6
DELAY_MS(200); //espera 200 ms S
}

if(input(PIN_A3)==1) // si la entrada A3 se presiona

 {
printf(lcd_putc,"Sensor 2"); //imprime en LCD
delay_ms(500); //espera 1500 ms
printf(lcd_putc,"\f"); //borrando LCD
delay_ms(500);
sensor(0,1); //activa función sensor con canala analógico 0, 1
}
}
}
view rawcontrol-temperatura-pic.c hosted with ❤ by GitHub

PROGRAMA EN C# PARA EL SISTEMA DE

CONTROL Y COMUNICACIÓN
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Diagnostics;
using System.Threading;
using System.Windows.Forms;
using System.Windows.Forms.DataVisualization.Charting;
namespace SerialPort
{
public partial class Form1 : Form
{
string RxString;
int y;
public Form1()
{
InitializeComponent();
}
public void timer1_Tick(object sender, EventArgs e)
{
this.tiempo.Text = DateTime.Now.ToString("dddd d MMMM yyyy \n HH:mm.ss ");
Di();
}
private void button1_Click(object sender, EventArgs e)
{
serialPort1.PortName ="COM3";
serialPort1.BaudRate =9600;
try
{
serialPort1.Open();
if (serialPort1.IsOpen)
{
//recibido.Clear();
btStart.Enabled = false;
btStop.Enabled = true;
textBox1.ReadOnly = false;
lStatus.Text = "CONECTADO";
lStatus.ForeColor = Color.Green;
cbPorts.Enabled = false;
}
}
catch(Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void Di()
{
if (serialPort1.IsOpen)
do
{
Thread.Sleep(500);
y = Convert.ToInt32(RxString);
if (y &gt;= 40)
{
this.label7.Text = Convert.ToString(y) + ".00 °C";
label7.BackColor = Color.Red;
label7.ForeColor = Color.White;
this.label9.Text = "ALERTA TEMPERATURA ALTA";
label9.BackColor = Color.Red;
label9.ForeColor = Color.Yellow;
this.label12.Text = "MOTORES ACTIVADOS";
}
else
{
if (y &lt; 40 &amp;&amp; y &gt;= 10)
{
this.label7.Text = Convert.ToString(y) + " °C";
label7.BackColor = Color.Yellow;
label7.ForeColor = Color.Red;
this.label9.Text = "";
this.label12.Text = "MOTOR 1 ACTIVADO";
}
else
{
if (y &lt; 10 &amp;&amp; y &gt;= -10)
{
this.label7.Text = Convert.ToString(y) + " °C";
label7.BackColor = Color.Green;
label7.ForeColor = Color.Yellow;
this.label9.Text = "";
this.label12.Text = "MOTORES DESACTIVADOS";
}
}
}
} while (!serialPort1.IsOpen);
}
private void signalRead()
{
}
private void DisplayText(object sender, EventArgs e)
{
textBox1.AppendText(RxString);
}
private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventA
{
RxString = serialPort1.ReadExisting();
this.Invoke(new EventHandler(DisplayText));
}
private void textBox1_KeyPress(object sender, KeyPressEventArgs e)
{
// If the port is closed, don't try to send a character.
if (!serialPort1.IsOpen) return;
// If the port is Open, declare a char[] array with one element.
char[] buff = new char[1];
// Load element 0 with the key character.
buff[0] = e.KeyChar;
// Send the one character buffer.
serialPort1.Write(buff, 0, 1);
// Set the KeyPress event as handled so the character won't
// display locally. If you want it to display, omit the next line.
e.Handled = true;
}
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
if (serialPort1.IsOpen) serialPort1.Close();
}
private void btStop_Click(object sender, EventArgs e)
{
if (serialPort1.IsOpen)
{
serialPort1.Close();
btStart.Enabled = true;
btStop.Enabled = false;
textBox1.ReadOnly = true;
// trackBar1.Enabled = false;
//trackBar1.Value = 1;
// button1.Enabled = false;
cbPorts.Enabled = true;
lStatus.Text = "DESCONECTADO";
lStatus.ForeColor = Color.Red;
}
}
private void button1_Click_1(object sender, EventArgs e)
 {
Application.Exit();
}
private void Form1_Load(object sender, EventArgs e)
{
}
}
}
view rawsensor-temperatura-contro.c hosted with ❤ by GitHub

CONCLUSIONES DE SENSOR DE
TEMPERATURA Y CONTROL CON PIC
El convertidor analógico digital es una herramienta con bastante utilidad para
realizar el control de temperatura. Ya que lo que hace, es convertir una señal
analógica de un sensor de temperatura en una digital. Lo útil de esta parte es que
sistemas o dispositivos actuales manejan señales digitales. Las señales ya
digitalizadas son mas fáciles de procesar y de manipular, además de poder ser
empleadas en algún caso especifico de implementación de sensado o control con
temperatura.

El ADC del PIC además es capaz de leer señales de audio, video, se sensores de
presión, temperatura, proximidad etc. Este ADC contiene 14 canales, por lo que
se pueden tener varias señales siendo adquiridas. Existen sensores que entregan
una señal ya digital, en este caso esos sensores ya tienen integrado un ADC. En
el caso de que entreguen una señal digital, usualmente utilizan protocolos de
comunicación. Los protocolos de comunicación convencionales para este tipo de
sensores son I2C y SPI.

En este proyecto se pudo diseñar satisfactoriamente. En este caso, un sistema de

control inteligente y automático que sea capaz de mantener una temperatura de
control. El control utilizado en este proyecto es extremadamente simple, ya que
es un control básico. Sin embargo, podemos concluir que gracias al sensor de
temperatura y las condiciones de control, el sistema funciona de manera
satisfactoria.