Interfaz grfica con pantalla LCD tctil para analizar

“Interfaz gráfica con pantalla LCD táctil para analizar señales de termocuplas tipo K, J, T usando el integrado DS 2760 de Dallas/Maxim y un microcontrolador” Martha Mite M. Andrés Contreras O. MSc. Carlos Valdiviezo

Objetivos del proyecto: § El objetivo de nuestro proyecto es utilizar la interfaz gráfica de una pantalla GLCD táctil para mostrar a través de ésta, el comportamiento de las señales de las termocuplas, usando el kit de Termocuplas DS 2760.

Diagrama de Bloques

Descripción del Proyecto: § El alcance del kit de las termocuplas es entender el funcionamiento de estas, para lograr obtener las temperaturas sensadas en los diferentes ambientes que se le presente. § Una vez que se logra la comunicación del módulo adquisitivo de datos con el microcontrolador se ingresan las tablas de datos de las temperaturas. Para mostrar el resultado que será una gráfica de Temperatura en función del tiempo.

Conexión de GLCD táctil a microcontrolador:

Kit de termocuplas DS 2760, Dallas/Maxim. Esta compuesto por el módulo de adquisición de Datos el chip DS 2760 y las termocuplas K, J, T.

Termocuplas: § Una termocupla es un transductor de temperatura, es un dispositivo que traduce una magnitud física en una señal eléctrica. § Son sensores de temperatura utilizados a nivel industrial, y a altas temperaturas. § Está compuesta por dos alambres de diferentes metales, que unidos de forma conveniente generarán entre sus extremos libres una diferencia de potencial proporcional a la diferencia de temperatura entre ellos.

Principio de las Termocuplas “Voltaje de Seebeck” Tiene este nombre debido a que el científico Seebeck realizó el descubrimiento en el año de 1821, este principio dice: “si se sueldan 2 metales diferentes, cuyos extremos están a distintas temperaturas, aparece una fuerza electromotriz (voltaje de Seebeck)”.

Los retos de utilizar las termocuplas en el proyecto, consiste en: § Obtener medición precisa muy baja ( en fracciones milivoltios). § Hallar el voltaje de Salida de termocupla (Voltaje de Seebeck). § Realizar la compensación de temperatura de la punta fría.

Tipos de Termocuplas:

Módulo DS 2760: § Para resolver los retos que trae el uso de termocuplas en la medición de temperatura, se usa el chip DS 2760, un módulo sencillo y eficaz, configurado para resolver esos inconvenientes. § El DS 2760 es un circuito integrado utilizado para adquirir los datos y cuenta con una memoria de datos no volátil donde se almacenan los datos de la variable sensada. § Este puede comunicarse como esclavo por medio de la red 1 -wire, compatible con software de programación del microcontrolador. § En este caso lo utilizaremos para la obtención de datos de temperatura.

§ § § Características del módulo: Interfaz de comunicación con protocolo 1 -wire. Módulo contiene un monitor de baterías Li de alta precisión. Incluye un sensor de temperatura integrado en chip, que mide continuamente la temperatura de la batería. Este es usado para calcular la compensación de voltaje según la temperatura en la punta de referencia de termocupla. Bajo consumo de potencia, 90 u. A activo – 2 u. A suspensión.

Protocolo 1 -wire: • Dallas Semiconductor ha desarrollado una poderosa tecnología llamada 1 -Wire, la cual utiliza un solo conductor más su conexión a tierra para efectuar las comunicaciones y la transmisión de energía entre un dispositivo maestro y múltiples esclavos. • Una red de dispositivos 1 -Wire está conformada por un maestro y uno o más esclavos que poseen un único pin de datos de tipo “opendrain”, al que se conecta una resistencia de “Pull Up” anclada a +5 VDC (nominal). • El BUS 1 -Wire, tiene una comunicación serial asincrónica entre un dispositivo maestro y uno o varios dispositivos esclavos.

PIC 18 F 4520:

Ejemplo práctico de medición de temperatura con termocuplas:

Tabla de Termocupla J:

Diagrama de flujo

Diagrama de flujo

FUNCIONAMIENTO DEL PROGRAMA

ANTECEDENTES Ø COMPILADOR MIKRO C (LENGUAJE C) Ø LIBRERIAS A USAR: • ADC : CONVERTIR SEÑALES ANALOGAS EN BINARIAS • Adc_read • GLCD: FUNCIONES DE GLCD • Glcd_Image, Glcd_Write_Text, Glcd_Rectangle, Glcd_fill • ONE_WIRE : COMUNICACIÓN CON KIT DS 2760 • Ow_Reset , Ow_Read, Ow_Write • EEPROM: GUARDAR DATOS DE TEMPERATURAS • EEPROM READ; EEPROM WRITE • CONVERSIONS : CONVERSIONES DE TIPOS DE DATOS • Byte. To. Str , Word. To. Str • • TIME : PARA GENERAR RETARDOS Delay_ms

Estructura del Programa n n n DECLARACION DE VARIABLES, CONSTANTES Y DEFINICION DE FUNCIONES PROGRAMA PRINCIPAL IMPLEMENTACION DE FUNCIONES

n n n n n n Declaración de variables y funciones TABLAS DE CONVERSIÓN DE TERMOCUPLAS K , J Y T unsigned temp_K, temp_J, temp_T; // VARIABLES TEMPORALES const code unsigned K_table_pos[1024]; // TABLA DE COMPENSACION DE TERMOCUPLA K const code unsigned J_table_pos[1024]; // TABLA DE COMPENSACION DE TERMOCUPLA J const code unsigned T_table_pos[401]; // TABLA DE COMPENSACION DE TERMOCUPLA T VARIABLES GLCD char GLCD_Data. Port at PORTD; // CONFIGURACION PUERTOS PARA GLCD sbit GLCD_CS 1 at RB 0_bit; sbit GLCD_CS 2 at RB 1_bit; sbit GLCD_RS at RB 2_bit; sbit GLCD_RW at RB 3_bit; sbit GLCD_EN at RB 4_bit; sbit GLCD_RST at RB 5_bit; sbit GLCD_CS 1_Direction at TRISB 0_bit; sbit GLCD_CS 2_Direction at TRISB 1_bit; sbit GLCD_RS_Direction at TRISB 2_bit; sbit GLCD_RW_Direction at TRISB 3_bit; sbit GLCD_EN_Direction at TRISB 4_bit; sbit GLCD_RST_Direction at TRISB 5_bit; VARIABLES GLOBALES const code char PRESENTACION [1024]; // IMAGEN DE PRESENTACION unsigned Y, tmp 5; unsigned X, tmp 4; unsigned short flag; // bandera de seleccion de termocupla

n Variables Globales (2) n unsigned x_coord 128, y_coord 64; //variables de posicion unsigned cj. Comp, temp, t. Cu. Vtemp, tmp. CJtemp, tbl. Hi, tbl. Lo, ee. Pntr, test. Val; unsigned short t. Cu. V_H, t. Cu. V_L, sign, tmp. CJ_H, tmp. CJ_L, sign 2, temp. C, V_Seebeck, T_Union ; int ii, i, error; char *Text=“ "; char *Text 1=“ "; unsigned posx, tmp. Y; // grafico Tvst n Definicion de funciones n n n n void Detecion_Tecla(); // detecta el toque del teclado unsigned short elegir_termo (unsigned x_coord 128, unsigned y_coord 64); void delay 2 S(); // Funcion de delay de 2 s unsigned Get. X(); // lee posicion x unsigned Get. Y(); // lee posicion y void Busqueda_Binaria(); // algoritmo para hallar la temperatura unsigned Voltaje_Seebeck(); unsigned Temperatura_Union (); // calcula la temperatura de contacto void CALCULA_TEMPERATURA(); // calcula la temperatura en grados void grafico_k(); grafica T vs t

Programa Principal n n n n n n n n n n void main() { OSCCON=0 X 7 E; ADCON 0 = 0 x 17; ADCON 1 = 0 x 0 C; TRISA = 0 x 07; // RA 0 i RA 1 are analog inputs TRISC = 0; // PORTC is output PORTC = 0; Glcd_Init (); //Inicializa GLCD Glcd_Fill (0 x 00); tmp 4=0; tmp 5=0; X=0; Y=0; x_coord 128=0; y_coord 64=0; delay_ms(200); while (1) { Glcd_Image (truck_bmp); delay_ms(200); Detecion_Tecla(); Glcd_Fill (0 x 00); delay_ms(2); Glcd_Write_Text("MENU TERMOCUPLAS", 20, 0, 1); Glcd_Rectangle(20, 7, 100, 18, 1) ; Glcd_Write_Text("TERMOCUPLA K", 22, 1, 1); Glcd_Rectangle(20, 23, 100, 34, 1) ; Glcd_Write_Text("TERMOCUPLA J", 32, 3, 1); Glcd_Rectangle(20, 39, 100, 50, 1) ; Glcd_Write_Text("TERMOCUPLA T", 32, 5, 1); Glcd_Rectangle(30, 55, 90, 64, 1) ; Glcd_Write_Text("SALIR", 35, 7, 1); Detecion_Tecla(); flag= elegir_termo(x_coord 128, y_coord 64); Glcd_Write_Text(txt, 1, 2, 0); Glcd_Fill (0 x 00);

continuación n n n n n n n n n while(1) { Glcd_Fill (0 x 00); posx=0; ii=0; while(1) { CALCULA_TEMPERATURA(); EEPROM_Write(ii, temp. C ); // escribe datos en la memoria eeprom Delay_ms(5); ii++; if(ii==83) break; } Detecion_Tecla(); ii=0; // selección de localidad de la memoria EEPROM while(1) { temp. C=EEPROM_Read(ii); // lee los datos de EEPROM Delay_ms(2); grafico_k(); Byte. To. Str(temp. C, txt); Glcd_Write_Text(txt, 1, 2, 0); Delay_ms(10); ii++; if(ii==83) break; if(posx==83) { posx=0; break; } } Detecion_Tecla(); if (i==0) break; } } }

Implementación de Funciones n n n n DETECTA POSICION X Y Y DETECCION DE TECLA MENU DE TERMOCUPLAS VOLTAJE SEEBECK ALGORITMO DE BUQUEDA BINARIA TEMPERATURA DE UNION FRIA CALCULA TEMPERATURA GRAFICA T VS t

Detecta posición X y Y n n n n n // DEVUELVE POSICION EN X (Tmp 4) unsigned Get. X () { PORTC. B 0 = 1; // DRIVEA = 1 (LEFT GND, RIGHT 5 V, TOP OFF ) PORTC. B 1 = 0 ; // DRIVEB = 0 (BOTTOM LEE X ) Delay_ms(10); X = ADC_Read(1); //' LEE X (BOTTOM) tmp 4 = 128 -((X*128)/1024); return tmp 4; // VARIABLE GLOBAL } // DEVUELVE POSICION EN Y (Tmp 5) unsigned Get. Y () { PORTC. B 0 = 0 ; // DRIVEA = 0 (LEFT LEE Y , RIGHT OFF , TOP 5 V ) PORTC. B 1 = 1 ; //DRIVEB = 1 (BOTTOM GND) Delay_ms(10); Y = ADC_Read(2) ; // LEE Y (LEFT) tmp 5=64 -((Y*64)/1024); return tmp 5; }

Detección de tecla Menú de termocuplas n n n n n n unsigned short elegir_termo (unsigned x_coord 128, unsigned y_coord 64) { if(((x_coord 128>=28) && (x_coord 128<=98)) && ((y_coord 64>=46) && (y_coord 64<=64))) return 1; // si es termocupla K if(((x_coord 128>=28) && (x_coord 128<=98)) && ((y_coord 64>=30) && (y_coord 64<=45))) return 2; // si es termocupla J if(((x_coord 128>=28) && (x_coord 128<=98)) && ((y_coord 64>=14) && (y_coord 64<=29))) return 3; // si es termocupla t if(((x_coord 128>=28) && (x_coord 128<=98)) && ((y_coord 64>=0 ) && (y_coord 64<= 13))) return 4; // si es salir } void Detecion_Tecla(); { while (1) { y_coord 64 = Get. Y(); x_coord 128 = Get. X(); if(((x_coord 128>=10) && (x_coord 128<=80)&& ((y_coord 64>=10) && y_coord 64<=50) break; } }

REGISTROS DS 2760

Rutinas de Termocupla n n n n n n VOLTAJE SEEBECK (t. Cu. V en microvoltios) // LEE EL REGISTRO DE CORRIENTE Y EXTRAE EL VOLTAJE EN BITS // -- CADA BIT ES 15. 625 Uv unsigned Voltaje_Seebeck() { Ow_Reset(&PORTA, 4); // Onewire señal de reset Ow_Write(&PORTA, 4 , 0 x. CC); // salta netaddress Ow_Write(&PORTA, 4, 0 x 69); // comando para LEER registros Ow_Write(&PORTA, 4, 0 x 0 E); // Lee registro de corriente 0 x 0 E y extrae el voltaje t. Cu. V_H = Ow_Read(&PORTA, 4 ); // lee el primer byte H t. Cu. V_L = Ow_Read(&PORTA, 4 ); // lee el segundo byte L sign = t. Cu. V_H & 0 x 80 ; // verifico bit de signo t. Cu. V = t. Cu. V_L >> 3; t. Cu. Vtemp= t. Cu. V_H; t. Cu. Vtemp=t. Cu. Vtemp << 5; t. Cu. V =t. Cu. V + t. Cu. Vtemp ; // realizo desplazamientos para registro de 16 bits if (sign == 0 x 80) // si es negativo t. Cu. V = t. Cu. V | 0 XF 000 ; // elimina calculos para temperaturas negativas t. Cu. V = t. Cu. V * 125/8; // x 15. 625 u. V y guarda en t. Cu. V Return t. Cu. V; } Valor maximo de t. Cuv es 64 m. V (64000 u. V) para 10 bits

Temperatura de Unión Fría n n n n n // LEE LA TEMPERATURA DE LA UNION FRIA EN LOS CONTACTOS //-- CADA BIT 0. 125 GRADOS C // -- RETORNA TEMPCJ EN GRADOS unsigned Temperatura_Union (); { Ow_Reset(&PORTA, 4); // Onewire SEÑAL DE RESET Ow_Write(&PORTA, 4 , 0 x. CC); // SALTA NETADDRESS Ow_Write(&PORTA, 4, 0 x 69); // COMANDO PARA ACCEDER A REGISTRO Ow_Write(&PORTA, 4, 0 x 18); //LEE REGISTRO DE TEMPERATURA 0 x 18 tmp. CJ_H = Ow_Read(&PORTA, 4 ); // LEE EL PRIMER BYTE H tmp. CJ_L = Ow_Read(&PORTA, 4 ); // LEE EL SEGUNDO BYTE L sign 2 = tmp. CJ_H & 0 x 80 ; // VERIFICA BIT DE SIGNO if (sign 2 == 0 x 80) tmp. CJ = 0; // SI ES NEGATIVO else tmp. CJ = tmp. CJ_H; // TEMPCJ EN GRADOS RETURN tmp. CJ; }

Algoritmo de Búsqueda Binaria n n n n n void Busqueda_Binaria() { // Usamos un algoritmo binario modificado para encontrar temperatura de cj. Comp // busqueda de la tabla a la inversa tbl. Lo = 0; // valor mas bajo de temperatura temp. C = 27; // temp. default del cuarto switch (flag) { case 1: test. Val = K_table_pos[tbl. Hi]; break; // chequeo la max temperatura case 2: test. Val = J_table_pos[tbl. Hi]; break; // tesval guarda la max temperatura case 3: test. Val = T_table_pos[tbl. Hi]; break; } if (cj. Comp > test. Val) error = 1; // fuera del rango else while (1) { ee. Pntr = (tbl. Lo + tbl. Hi) / 2 ; // buscamos en el punto medio del arreglo n n n n n } switch (flag) { case 1: test. Val=K_table_pos[ee. Pntr]; break; case 2: test. Val=J_table_pos[ee. Pntr]; break; // tesval guarda la temp. punto medio case 3: test. Val=T_table_pos[ee. Pntr]; break; } if (cj. Comp == test. Val) break; // encontro y sale del lazo if (cj. Comp < test. Val) tbl. Hi = ee. Pntr; else tbl. Lo = ee. Pntr; // busca de la mitad para arriba if ((tbl. Hi - tbl. Lo) < 2) { // ee. Pntr guarda valor final de temperatura ee. Pntr = tbl. Lo; break; } } temp. C = ee. Pntr;

n n n n n n n n Cálculo de la Temperatura void CALCULA_TEMPERATURA() { V_Seebeck= Voltaje_Seebeck(); T_Union= Temperatura_Union (); if (flag==1) cj. Comp = K_table_pos[T_Union]; if (flag==2) cj. Comp = J_table_pos[ T_Union]; if (flag==3) cj. Comp = T_table_pos[T_Union]; // combina cj. Comp and t. Cu. V if (sign == 0 x 80) { //TC por debajo de la temp de union fria if ((t. Cu. V) < (cj. Comp)) { cj. Comp = cj. Comp - t. Cu. V; } else cj. Comp = 0; // limita a 0 C } else // TC esta sobre la temp de union fria cj. Comp = cj. Comp + t. Cu. V; switch (flag) { case 1: tbl. Hi=1023; break; // Elige el valor del tamaño de la tabla de termocuplas de acuerdo a flag case 2: tbl. Hi=1023; break; case 3: tbl. Hi=400; break; } Busqueda_Binaria(); }

Graficar T vs t n n n n void grafico_k() { tmp. Y = 63 -(temp. C); Delay_ms(2); Glcd_Dot(posx, tmp. Y, 1); posx++; }

Simulación

RESULTADO DE LA MEDICION DE TEMPERATURA CON LA TERMOCUPLA K

Conclusiones: § Logramos visualizar los resultados de las muestras de datos de Temperatura en función del Tiempo en la pantalla GLCD, datos que fueron obtenidos con la aplicación de fuentes externas a las termocuplas, en este caso utilizamos una secadora de cabello y un encendedor. § Debido a que la pantalla GLCD, utiliza 3 leds para generar el fondo de color blanco de la imagen, aumentando el consumo de corriente, cuyo valor aproximado es de 50 m. A. Y la única forma de bajar este consumo es utilizando un solo color y reducir el nivel del contraste. Pero esto bajaría la calidad de la imagen. § Para obtener y reflejar en pantalla los valores de temperatura, se necesito una mediana cantidad de memoria FLASH, por lo cual se utilizo el PIC 18 F 4520. Suficiente para almacenar las tablas de datos y valores adecuados que permitirán la conversión de la señal en milivoltios que da la termocupla a un valor de temperatura en °C.

§ Para calcular el voltaje de Seebeck, tenemos que hacer que el voltaje generado en los contactos entre la placa del DS 2760 y las termocuplas sea 0, y esto lo logramos a traves de software, esto se realiza luego del llamado de dos subrutinas, la de voltaje de Seebeck y la de la temperatura de contacto. § Las termocuplas son muy practicas en aplicaciones industriales debido a su robustez mecánica y a la precisión a altas temperaturas, así como de rápida respuesta y bajo costo. § La subrutina de “búsqueda binaria”, es una de las más importantes del código, ya que aquí es donde se realizan los cálculos importantes para poder buscar en la tabla de termocuplas el valor de temperatura más cercano al medido y además de llevar el valor que se encuentra en la tabla al valor de temperatura decimal que corresponde. Para luego ser mostrada por pantalla.

§ Para tomar muestras de datos reales, se ha considerado la ayuda del DS 3234 que utiliza comunicación SPI, este integrado nos va a servir para mostrar las fechas y hora actuales de los datos de temperatura que se tomen. § Se tuvo que considerar una memoria externa SD, debido a que no había capacidad en el microcontrolador para almacenar los datos de temperatura. Y como se va a mostrar en pantalla la fecha y hora de las muestras de datos, fue necesario considerar el uso de esta memoria.

Recomendaciones: • Es muy importante para realizar proyectos como el nuestro, contar conocimientos suficientes en microcontroladores y lenguaje de programación Micro. CPro (que es el utilizado aquí), ya que esto facilitará un mejor desarrollo, configuración e implementación del proyecto. • Leer, comprender y analizar de forma detenida las Hojas de Especificaciones Técnicas del microcontrolador PIC 18 F 4520, Pantalla GLCD táctil y el Módulo de Adquisición DS 2760. Ya que un mal entendimiento puede producir conexiones erróneas que nos harán tomar más del tiempo del necesario para el desarrollo del proyecto.

• Una vez implementado el Proyecto en el protoboard, ser cuidadoso en el traslado de éste, hasta su debida conexión en placas. • Realizar un algoritmo o diagrama de flujo del Código Fuente a utilizarse en la programación, para hallar así más pronto los errores lógicos con los que se pueda encontrar en la implementación del Proyecto, en lo que respecta a la parte de Software. • Hacer un buen analisis antes de elegir el microntrolador y el lenguaje en el que se va a desarrollar el proyecto, ya que en nuestro caso utilizamos por completo todos los recursos del integrado y tuvimos que agregar una memoria externa.

Muchas gracias