Universidad de Costa Rica Facultad de Ingeniería Escuela de Ingeniería Eléctrica

IE – 0502 Proyecto Eléctrico

Diseño y construcción de un sistema de control de temperatura para una incubadora de huevos de aves de corral

Por: Félix David Suárez Bonilla

Ciudad Universitaria Rodrigo Facio Junio del 2009

Diseño y construcción de un sistema de control de temperatura para una incubadora de huevos de aves de corral Por: Félix David Suárez Bonilla

Sometido a la Escuela de Ingeniería Eléctrica de la Facultad de Ingeniería de la Universidad de Costa Rica como requisito parcial para optar por el grado de:

BACHILLER EN INGENIERÍA ELÉCTRICA Aprobado por el Tribunal:

_________________________________ Ing. Ismael Mazón Profesor Guía

_________________________________ Ing. Teodoro Willink Profesor lector

_________________________________ Ing. Felipe Córdoba Profesor lector

DEDICATORIA

Este proyecto se lo dedico a mis padres por su apoyo incondicional, esfuerzo y trabajo, pero sobre todo a mis dos abuelas ya fallecidas Nancy y Tita.

ÍNDICE GENERAL ÍNDICE DE FIGURAS....................................................................................................... VIII ÍNDICE DE TABLAS ........................................................................................................... XI NOMENCLATURA ............................................................................................................. XII RESUMEN ..........................................................................................................................XIV CAPÍTULO 1: INTRODUCCIÓN.......................................................................................... 1 1.1 Objetivos ..............................................................................................................................2 1.1.1 Objetivo general .......................................................................................................................... 2 1.1.2 Objetivos específicos................................................................................................................... 2 1.2

Levantamiento de requerimientos .........................................................................................2

1.3

Metodología .........................................................................................................................4

CAPÍTULO 2: DESARROLLO TEÓRICO ........................................................................... 6 2.1 Sistemas de control en tiempo continuo ................................................................................6 2.1.1 Elementos de control .................................................................................................................. 6 2.1.2 Característica estática ................................................................................................................. 9 2.1.3 Característica dinámica ............................................................................................................. 10 2.1.4 Identificación experimental ...................................................................................................... 10 2.1.5 Tipos de controladores ............................................................................................................. 11 2.1.5.1 Controlador PID ideal ............................................................................................................ 11 2.1.5.2 Controlador PID paralelo ...................................................................................................... 12 2.1.5.3 Controlador PID serie............................................................................................................ 13 2.1.5.4 Controlador PID industrial .................................................................................................... 14 2.1.6 Proceso térmico ........................................................................................................................ 15 2.2 Sistemas de control en tiempo discreto................................................................................ 19 2.2.1 Esquema de control digital ....................................................................................................... 19 2.2.2 Modelos de sistemas discretos ................................................................................................. 21 2.2.3 Diseño de un controlador discreto ........................................................................................... 22

2.3 Microcontrolador Atmega16 ............................................................................................... 25 2.3.1 Descripción general del microcontrolador ............................................................................... 25 2.3.2 Estructura del microcontrolador ............................................................................................... 25 2.3.3 Unidad de procesamiento central ............................................................................................ 27 2.3.3.1 Archivo de registros .............................................................................................................. 27 2.3.3.2 Contador de programa (PC) ................................................................................................... 28 2.3.3.3 Registro de banderas (SREG) ................................................................................................ 29 2.3.3.4 Puntero de pila ..................................................................................................................... 31 2.3.4 Sistema de memoria ................................................................................................................. 32 2.3.4.1 Memoria flash ....................................................................................................................... 32 2.3.4.2 Memoria SRAM ..................................................................................................................... 33 2.3.4.3 Memoria EEPROM ................................................................................................................ 34 2.3.5 Interrupciones ........................................................................................................................... 35 2.3.6 Periféricos ................................................................................................................................. 36 2.3.6.1 Puertos de entrada/salida .................................................................................................... 36 2.3.6.2 Convertidor analógico a digital ............................................................................................. 37 2.3.6.3 Temporizadores .................................................................................................................... 39

CAPÍTULO 3. IMPLEMENTACIÓN DEL SISTEMA....................................................... 45 3.1

Descripción del sistema ....................................................................................................... 45

3.2

Diseño del sistema .............................................................................................................. 47 3.2.1 Microcontrolador..................................................................................................................... 47 3.2.2 Actuador .................................................................................................................................. 48 3.2.3 Sensor ...................................................................................................................................... 50 3.2.4 Visualizador.............................................................................................................................. 51 3.2.5 Alarma...................................................................................................................................... 54 3.2.6 Esquemático final del controlador ........................................................................................... 55

3.3

Implementación de la planta ............................................................................................... 56

3.4 Identificación del proceso ................................................................................................... 58 3.4.1 Obtención de la curva de reacción............................................................................................ 58 3.4.2 Obtención del modelo .............................................................................................................. 59 3.5

Sintonización ...................................................................................................................... 59

3.6

Diagrama de flujo ............................................................................................................... 63

3.7

Programación ..................................................................................................................... 68

3.8

Prototipo final .................................................................................................................... 76

CAPÍTULO 4: CONCLUSIONES Y RECOMENDACIONES ............................................ 81 BIBLIOGRAFÍA .................................................................................................................. 85 APÉNDICE A: CÓDIGO. .................................................................................................... 88

ÍNDICE DE FIGURAS

Figura 2.1. Diagrama de bloques general de un sistema de control realimentado. ............................ 6 Figura 2.2. Diagrama de bloques detallado de un sistema de control realimentado.......................... 7 Figura 2.3. Característica estática. ....................................................................................................... 9 Figura 2.4. Controlador PID serie. ...................................................................................................... 13 Figura 2.5. Controlador PID industrial. .............................................................................................. 15 Figura 2.6. Proceso térmico sencillo. ................................................................................................. 16 Figura 2.7. Red generalizada del proceso térmico............................................................................. 17 Figura 2.8. Diagrama de bloques del proceso térmico. ..................................................................... 17 Figura 2.6. Sistema de control en tiempo discreto. ........................................................................... 20 Figura 2.7. Señal discreta. .................................................................................................................. 21 Figura 2.8. Señal analógica. ............................................................................................................... 21 Figura 2.9. Diagrama de bloques del Atmega16. ............................................................................... 26 Figura 2.10. Archivo de registros. ...................................................................................................... 27 Figura 2.11. Registros X, Y y Z. ........................................................................................................... 28 Figura 2.12. Registro de banderas. .................................................................................................... 29 Figura 2.13. Puntero de pila............................................................................................................... 32 Figura 2.14. Mapa de memoria. ........................................................................................................ 33 Figura 2.15. Memoria SRAM. ............................................................................................................. 34 Figura 2.16. Configuración de pines del microcontrolador Atmega16. ............................................. 37 Figura 2.17. Convertidor analógico a digital del Atmega16. .............................................................. 38

Figura 2.18. Temporizador/Contador 0. ............................................................................................ 41 Figura 2.19. Temporizador/Contador 1. ............................................................................................ 42 Figura 2.20. Temporizador/Contador 2. ............................................................................................ 43 Figura 3.1. Diagrama del sistema a diseñar. ...................................................................................... 45 Figura 3.2. Sistema calefactor............................................................................................................ 48 Figura 3.3. Manejo del sistema calefactor. ........................................................................................ 49 Figura 3.4. Sensor de temperatura LM35DT...................................................................................... 50 Figura 3.5. Visualizador de siete segmentos de ánodo común NTE3058. ......................................... 52 Figura 3.6. Conexión de los visualizadores al microcontrolador. ...................................................... 53 Figura 3.7. Sistema de alarma............................................................................................................ 55 Figura 3.8. Esquemático del controlador. .......................................................................................... 56 Figura 3.9. Proceso implementado. ................................................................................................... 57 Figura 3.10. Curva de reacción del proceso. ...................................................................................... 58 Figura 3.11. Subrutinas de atención a interrupciones externas. ....................................................... 63 Figura 3.12. Subrutina de interrupción de sobreflujo en temporizador 1. ........................................ 65 Figura 3.13. Subrutina de sobreflujo en temporizador 0................................................................... 66 Figura 3.14. Diagrama de flujo de rutina principal. ........................................................................... 67 Figura 3.15. Subrutina void port_define_IO(void). ............................................................................ 68 Figura 3.16. Subrutina void port_initiate(void). ................................................................................ 69 Figura 3.17. Subrutina void enc_timer0(void).................................................................................... 69 Figura 3.18. Subrutina void enc_timer1(void).................................................................................... 70 Figura 3.19. Subrutinas de interrupciones externas. ......................................................................... 70 Figura 3.19 (Continuación). Subrutinas de interrupciones externas. ................................................ 71

Figura 3.20. Subrutinas config_pwm(). .............................................................................................. 72 Figura 3.21. Subrutina de sobreflujo en temporizador uno. ............................................................. 73 Figura 3.22. Archivo estructuras.h. .................................................................................................... 73 Figura 3.23. Salida del controlador. ................................................................................................... 74 Figura 3.24. Encendido de la alarma.................................................................................................. 75 Figura 3.25. Prototipo final. ............................................................................................................... 76 Figura 3.26. Respuesta del sistema para un valor deseado de 36.5ºC. ............................................. 77 Figura 3.27. Respuesta del sistema para un valor deseado de 38.5ºC. ............................................. 78 Figura 3.28. Respuesta del sistema para un valor deseado de 35.5ºC. ............................................. 79 Figura 3.29. Respuesta del sistema para un valor deseado de 37.2ºC. ............................................. 80

ÍNDICE DE TABLAS

Tabla 1. Fuentes de interrupción. ...................................................................................................... 35 Tabla 2. Temporizadores del Atmega16. ........................................................................................... 39 Tabla 3. Equivalencia entre la salida del sensor LM35DT y la temperatura. ..................................... 51

NOMENCLATURA

FTLA

Función de transferencia de lazo abierto del sistema.

FTLC

Función de transferencia de lazo cerrado del sistema.

C (s )

Función de transferencia del controlador.

P (s )

Función de transferencia de la planta.

KC

Ganancia del controlador.

KP

Ganancia de la planta.

L(s )

Función de transferencia de lazo abierto.

M yr (s )

Función de transferencia del servomecanismo.

M yd (s )

Función de transferencia del control regulatorio.

P

Controlador proporcional.

PI

Controlador proporcional e integral.

PD

Controlador proporcional y derivativo.

PID

Controlador proporcional, integral y derivativo.

R (s )

Función de transferencia de lazo cerrado del sistema.

s

Variable compleja.

Td

Función de transferencia de lazo cerrado del sistema.

Ti

Función de transferencia de lazo cerrado del sistema.

Y (s )

Señal realimentada del sistema de control.

D(s )

Perturbaciones del sistema de control.

LED

Diodo emisor de luz (siglas en inglés de Light Emitting Diode)

RESUMEN

El proyecto consistió en el diseño e implementación de un controlador de temperatura para una incubadora de huevos de aves de corral. El sistema se elaboró utilizando como unidad de procesamiento central un microcontrolador Atmega16, el sensor de temperatura seleccionado fue el LM35DT debido a su bajo costo y gran cantidad de documentación disponible, y como elemento final de control, tres lámparas, dos incandescentes y uno halógeno. Se construyó la planta, y se obtuvo la curva de reacción del proceso, a partir del cual se obtuvieron los parámetros de sintonización del controlador. Se programó un controlador PID ideal en el microcontrolador utilizando estos parámetros y posteriormente se realizaron un conjunto de pruebas para comprobar su correcto funcionamiento.

CAPÍTULO 1: Introducción El control automático ha desempeñado una función vital en el avance de la ingeniería y la ciencia. Además de su extrema importancia en las áreas científicas y militar; el control automático se ha convertido en parte integral de los procesos modernos industriales. Entre las áreas de aplicación del control automático en procesos industriales, el caso que nos atañe es el control de temperatura en sistemas térmicos. En este proyecto se pretende el diseño e implementación de un controlador de temperatura para una incubadora de huevos de aves de corral. Las incubadoras de huevos son máquinas de gran importancia en la industria avícola, pues de su buen desempeño depende una tasa alta de eclosión y por lo tanto una producción exitosa que conlleve a mayores dividendos para la compañía. El sistema para llevar a cabo el control de temperatura está basado en un microcontrolador Atmega16, que se usa para realizar un controlador PID discreto, se contará con un sensor para medir la temperatura y un actuador para modificar el flujo de calor del proceso. El objetivo del proyecto es diseñar e implementar tanto el proceso térmico (incubadora) como el sistema de control. Para implementar el conjunto controlador-planta se debe primero diseñar el sistema, adquirir todos los elementos, materiales y circuitos integrados necesarios, para luego realizar la implementación.

1

1.1

Objetivos

1.1.1 Objetivo general

Desarrollar un sistema de control de temperatura de bajo costo y alta adaptabilidad para una incubadora de huevos de aves de corral.

1.1.2 Objetivos específicos

•

Implementar una interfaz de operación simple para el control de temperatura de la incubadora.

•

Determinar el sensor de temperatura y el actuador adecuado tomando en consideración del costo de los elementos.

•

Construir el sistema de control y todos los circuitos necesarios para la puesta en operación del mismo.

1.2

Levantamiento de requerimientos

Un sistema de control de temperatura para una incubadora debe ser preciso, pues pequeñas variaciones de tan solo fracciones de grados, aunque sean tan solo temporales tendrán como resultado una reducción de la incubabilidad. En términos cuantitativos el error permanente en éste sistema no debe ser mayor a 0.2 ºC. El modo integral de un 2

controlador PID garantiza que esto sea así, ya que su contribución en la salida del controlador no alcanza un valor constante, a menos que el error sea cero y permanezca siendo cero. Otro requerimiento importante es la ventilación, una incubadora debe permitir una buena circulación del aire, se desea que el dióxido de carbono no sea mayor al 0.5% y el oxígeno debe ser de entre 21% y 22%. En general un ambiente limpio permitirá que se cumplan estas especificaciones. De forma adicional el operador de la incubadora debe poder seleccionar la temperatura deseada a través de botones o alguna clase de teclado y observar la temperatura del proceso en alguna clase de visualizador. Es de suma importancia contar con dos o más calefactores y que la tasa de calor entregada por un único calefactor sea suficiente para mantener la temperatura deseada del sistema, aunque se deterioren los parámetros de desempeño. Esto permite contar con un respaldo en caso de que un calefactor falle. La mayoría de controladores comerciales de temperatura cuentan con alarmas que se activan ante condiciones peligrosas de temperatura. Se pretende que este sistema en particular cuente con una alarma sonora que se active cuando la temperatura alcanza valores peligrosamente altos o peligrosamente bajos. También el sistema debe permitir al operador modificar los parámetros del controlador PID, estos son: tiempo integral, tiempo derivativo y ganancia proporcional; lo que sin duda dará versatilidad y robustez al sistema. También permitirá al ingeniero de control

3

identificar el proceso y escoger el método de sintonización que considere más adecuado para una aplicación en particular

1.3

Metodología

A continuación se detallan en orden cronológico los pasos en que se incurrieron para llevar a cabo la elaboración del sistema:

•

Se construyó el prototipo y se escogió el sensor así como el actuador. El sensor debió ser lo suficientemente exacto y el actuador debió proporcionar una tasa de flujo de calor que proporcione una respuesta rápida ante un cambio en el valor deseado de temperatura.

•

Se realizaron un conjunto de pruebas sobre el proceso térmico para obtener la curva de reacción. Se energizó el sistema y se observó la evolución de la temperatura en el interior de la incubadora, se tomaron datos con los cuales se determinó la gráfica de temperatura contra tiempo.

•

Se realizaron cálculos de los parámetros del controlador con base en un método de sintonización. Se prefirió métodos que permitieron obtener un rápida respuesta en el servomecanismo.

4

•

El sistema se construyó sobre un microcontrolador Atmega16, el código se escribió en C. Se diseñó el diagrama de flujo antes de comenzar su implementación.

•

Se finalizó el diseño del programa y se comenzó con la implementación del diagrama de flujo en lenguaje C. Se usó el convertidor analógico digital del microcontrolador para medir la salida de tensión del sensor, una salida PWM, y los puertos de entrada y salida digitales.

•

Se finalizó la escritura del programa. El controlador PID discreto se obtuvo a partir de un controlador PID continuo utilizando la aproximación de la derivada.

•

Ensamblaje del circuito en una tarjeta de prototipos y descarga del programa en el microcontrolador.

•

Se realizó pruebas sobre el circuito para la corrección y detección de fallas. Probablemente serán necesarios algunos ajustes para obtener un adecuado funcionamiento del circuito.

5

CAPÍTULO 2: Desarrollo teórico

2.1

Sistemas de control en tiempo continuo

2.1.1 Elementos de control

En la siguiente figura se muestra el diagrama de bloques general de un sistema de control realimentado monovariable en tiempo continuo:

Figura 2.1. Diagrama de bloques general de un sistema de control realimentado.

Se incluyen en el diagrama la función de transferencia del proceso P(s ) , que incluye el actuador y el sensor, la función de transferencia del controlador C (s ) , el valor deseado de

6

la variable controlada R(s ) , la señal a la salida del controlador U (s ) y la perturbación D (s ) .

En la siguiente figura se muestra un diagrama que muestra el sistema de control en forma más detallada:

Figura 2.2. Diagrama de bloques detallado de un sistema de control realimentado.

Se incluye el elemento final de control que es el elemento físico que finalmente realiza el control sobre el proceso. El sensor/transmisor que mide la variable controlada y crea una señal que es transferida al controlador. Los modos de control que utilizan un algoritmo para generar una señal correctora para ajustar el proceso acorde. La función de transferencia de lazo cerrado (FTLC) es la razón entre la salida y la entrada cuando el lazo de retroalimentación está cerrado. Debido a que el sistema de control presenta dos entradas, se puede determinar la FTLC para cada una de estas dos

7

entradas. La función de transferencia respecto al valor deseado, denominada servocontrol, está dada por:

M yr ( s ) =

Y (s) C ( s) ⋅ P( s) = R( s) 1 + C ( s) ⋅ P( s)

(2-1)

La función de transferencia FTLC respecto a la perturbación, denominada control regulatorio, está dada por: M yd ( s ) =

Y (s) P( s) = D( s ) 1 + C ( s ) ⋅ P ( s )

(2-2)

La función de transferencia de lazo abierto (FTLA) es la razón entre la señal de salida y el valor deseado en ausencia de la retroalimentación. Está definida por la siguiente ecuación: L( s ) = C ( s ) ⋅ P ( s )

(2-3)

De la ecuación se observa que el polinomio en el denominador de M yz (s ) y M yr (s ) es el mismo, siendo éste: p(s) = 1 + C ( s) ⋅ P(s)

(2-4)

El cual recibe la denominación de polinomio característico, pues determina en gran medida la dinámica del sistema.

8

2.1.2 Característica estática

La característica estática de la planta es la información correspondiente a la relación entre sus señales de entrada y salida en condiciones de estado estacionario. La característica estática define el ámbito del control, que es el intervalo de valor deseado para el cual ésta diseñado el controlador, esto permite establecer ciertos límites de operación con los cuales se puede dimensionar y seleccionar el elemento final de control y los instrumentos de medición y transmisión. Esta información suele representarse gráficamente como una familia de curvas. En la siguiente figura se tiene un ejemplo de ellas:

Figura 2.3. Característica estática.

9

La relación entre la variable controlada C y la variable manipulada M se llama característica estática de la planta. La relación entre la señal realimentada y la salida del controlador se llama característica del conjunto actuador-planta-sensor.

2.1.3 Característica dinámica La característica dinámica hace referencia a la respuesta del sistema ante una señal en algunas de sus entradas. Debido a la presencia de dos entradas: el valor deseado y la perturbación; se tienen dos funciones de transferencia M yr (s ) y M yd (s ) que describen esta dinámica. El primer paso para entender el comportamiento dinámico del sistema es determinar la respuesta de la planta aplicándole una excitación particular y a partir de esto determinar los parámetros con los cuales se modela la planta. A este procedimiento se le llama identificación. Una vez establecido el modelo de la planta, el segundo paso es llevar a cabo la sintonización del controlador.

2.1.4 Identificación experimental

La identificación es el procedimiento en el cual se introduce una excitación al proceso a controlar para determinar a partir de la información de salida un modelo matemático para la planta. Hay dos tipos de métodos. Los métodos de lazo abierto calculan los parámetros del modelo a partir de la curva de reacción, y los métodos de lazo cerrado, entre los cuales 10

destaca el método de Ziegler y Nichols, que consiste en variar la ganancia del controlador funcionando sólo en su parte proporcional para obtener una respuesta oscilatoria, ésta respuesta proporciona la información última que es usada para obtener el modelo.

2.1.5 Tipos de controladores

En general, los controladores tienen varios modos de control que se encuentran relacionados por medio de una función matemática que caracteriza el tipo de controlador. Así se distinguen los controladores proporcionales (P), los proporcionales integrales (PI), y los proporcionales integrales y derivativos (PID). Como parte del proceso histórico que ha seguido el desarrollo de los controladores se pueden distinguir controladores PID ideales, PID serie, PID paralelo y PID industriales.

2.1.5.1 Controlador PID ideal

Los controladores PID ideales están caracterizados por la siguiente ecuación en el dominio del tiempo y en el dominio de la frecuencia, respectivamente:

 1 t de(t )  u (t ) = K c ⋅ e(t ) + ⋅ ∫ e(τ )dτ + Td ⋅  0 Ti dt  

(2-5)

 1   ⋅ E ( s ) U ( s ) = K c ⋅ (1 + Td ⋅ s ) ⋅ 1 + T s i  

(2-6)

11

En el dominio del tiempo algunas veces se dice que es un controlador no interactuante porque los modos actúan en forma independiente sobre la señal de error. Por otro lado, desde el punto de vista del dominio de la frecuencia se dice que es interactuante porque ambos ceros del controlador se ven afectados al variar cualquiera de los parámetros Ti o Td .

2.1.5.2 Controlador PID paralelo Este es quizás el tipo de controlador PID menos utilizado en la industria. Está caracterizado por la siguiente ecuación:

  K Kd U ( s) =  K p + i + ⋅ E ( s) s α ⋅ K d ⋅ s + 1 

(2-7)

El efecto de la variación de las diferentes ganancias del controlador paralelo no tiene el mismo efecto que el normalmente asociado a la ganancia y constantes de tiempo integral y derivativo de los controladores PID, siendo normalmente más difícil de sintonizar mediantes procedimientos de prueba y error.

12

2.1.5.3 Controlador PID serie

Este controlador es el resultado de colocar un controlador PI en serie con un PD. Tiene la siguiente ecuación característica:

 T '⋅s + 1   Td '⋅s + 1   ⋅   ⋅ E ( s ) U ( s ) = K c '⋅ i T ' ⋅ s α ⋅ T ' ⋅ s + 1 d  i   

(2-8)

Contrario a lo que sucede con el controlador ideal, el serie se conoce como controlador interactuante en el dominio del tiempo, porque el modo integral interactúa con el derivativo para procesar la señal de error, mientras que en el dominio de la frecuencia se dice que es no interactuante, porque uno de los ceros del controlador depende sólo de Ti y el otro sólo de Td . En la siguiente figura se muestra el diagrama de bloques del controlador serie:

Figura 2.4. Controlador PID serie. 13

2.1.5.4 Controlador PID industrial

Tanto el controlador PID ideal como el PID serie aplican el modo derivativo directamente a la señal de error; por lo tanto, ante un escalón en el valor deseado R(s), se produce un pico en la salida del controlador producido por el modo derivativo. Para evitar esto se creó el controlador PID industrial, el cual aplica el modo derivativo únicamente a la señal realimentada Y(s). Hay que tomar en cuenta que, en la práctica, un cambio escalón en R(s) puede ser producido en cualquier momento por el operador. La siguiente ecuación representa la salida del controlador PID industrial. Se puede observar que ésta es deducida a partir de la ecuación PID serie.

  T '⋅s + 1    T '⋅s + 1   ⋅  R ( s ) −  d  ⋅ Y ( s ) U ( s ) = K c '⋅ i  Ti '⋅s    α ⋅ Td '⋅s + 1  

(2-9)

Se puede ver que se tienen dos controladores, uno PI que se denomina el compensador

de valor deseado y un PID serie que se denominar compensador de realimentación. Si se compara con el PID serie es fácil comprobar que el comportamiento del lazo de control es idéntico ante un cambio en la perturbación, más no así en el caso de un cambio en el valor deseado. En la figura 2.5 se ilustra el diagrama de bloques del controlador PID industrial:

14

Figura 2.5. Controlador PID industrial.

2.1.6 Proceso térmico

A continuación se presenta el análisis y modelado de un sistema térmico sencillo, lo cual permite comprender la dinámica de una incubadora de huevos, y en general de cualquier proceso térmico, tales como hornos domésticos y calentadores de agua. El modelado se hizo utilizando la red generalizada, la cual es una manera uniforme y única de estudiar cualquier sistema dinámico. En la red generalizada se tienen dos tipos de variables, las transvariables y las pervariables. Las transvariables son aquellas variables que requieren de dos puntos para medirse y que se obtiene a través de los elementos, las pervariables son aquellas variables que se propagan por los elementos y para cuya medición se requiere solamente de un punto.

15

La figura 2.6 muestra un esquemático del sistema y todas las variables involucradas en el proceso:

Figura 2.6. Proceso térmico sencillo.

La primera consideración en el análisis es que el flujo de calor entrante a la cavidad es una fuente de pervariable, y la temperatura ambiente una fuente de transvariable. El espacio en el interior es una capacitancia térmica, ya que almacena energía en función de un incremento en la temperatura. El material entre la cavidad interior y el exterior es una resistencia térmica, en virtud de la resistencia que ofrece al flujo de calor. Tomando en consideración estas observaciones se obtiene la red generalizada de la figura 2.7.

16

Figura 2.7. Red generalizada del proceso térmico.

Se hace notar que la variable manipulada es el flujo de calor qi (s ) , la variable controlada es la temperatura interna T (s ) y la perturbación es la temperatura ambiente Ta (s ) (véase figura 2.8).

Figura 2.8. Diagrama de bloques del proceso térmico.

Del análisis de la figura 2.7 se desprende la función de transferencia del proceso, dada por la ecuación 2-10.

17

    Rt 1  ⋅ qi ( s ) +   ⋅ Ta ( s ) T ( s ) =   Rt ⋅ Ct ⋅ s + 1   Rt ⋅ Ct ⋅ s + 1 

(2-10)

Al considerar únicamente el valor deseado que corresponde al flujo de calor entrante, se tiene la función de transferencia de la ecuación 2-11.

  Rt  ⋅ qi ( s ) T ( s ) =   Rt ⋅ Ct ⋅ s + 1 

(2-11)

Nótese que la respuesta del proceso al considerar únicamente el valor deseado es de primer orden. Al considerar únicamente la perturbación se tiene la función de transferencia dada por la ecuación 2-12.

  1  ⋅ Ta ( s ) T ( s ) =  R ⋅ C ⋅ s + 1 t  t 

(2-12)

La respuesta del proceso al considerar únicamente la perturbación es de primer orden. Nótese que se trata de un proceso autoregulado que comprende únicamente un elemento almacenador de energía - la capacitancia térmica - y un elemento disipador de energía - la resistencia térmica - y que está caracterizado por la constante de tiempo T = Rt Ct .

18

2.2

Sistemas de control en tiempo discreto

2.2.1 Esquema de control digital

Un sistema de control en tiempo discreto es similar al caso continuo, salvo por el hecho de que el controlador se encuentra dentro de un sistema computador. La obtención del error no es más que una resta, y la acción de control se hace con una serie de sumas y multiplicaciones. Para unir este ámbito de números dentro de un programa al ámbito físico del sistema a controlar se necesita una interfaz. Esa es la labor que realizan precisamente los dos elementos nuevos que aparecen en el control discreto: el convertidor analógico a digital (ADC: por sus siglas en inglés analog to digital converter) y el convertidor digital a analógico (DAC: por sus siglas en inglés digital to analog converter). El convertidor DAC sirve para convertir el valor de la acción de control calculado por el computador en una señal física que actúa sobre el proceso. A su vez el convertidor ADC se utiliza para convertir la señal que proporciona el sensor en un número dentro del programa.

19

Figura 2.6. Sistema de control en tiempo discreto.

En un sistema continuo las señales vienen representadas por funciones continuas. En un sistema discreto sin embargo, se representan como secuencias discretas. Estas secuencias discretas son una serie de números que provienen de tomar los valores instantáneos de señales analógicas en instantes de tiempo concretos (muestreo). Esos instantes suelen estar espaciados por un tiempo que se denomina tiempo de muestreo. A cada uno de los valores se les denomina muestras y se identifican por su número de muestra k. En la figura 2.7 se tiene la siguiente secuencia y k = {yo , y1 , y 2 , y3 ...} la cual proviene de la señal analógica y (t ) de la figura 2.8

20

Figura 2.7. Señal discreta.

Figura 2.8. Señal analógica.

2.2.2 Modelos de sistemas discretos

Un modelo de un sistema continuo, lineal e invariante en el tiempo está representado por una ecuación diferencial: 21

an ⋅

d n y (t ) dy (t ) d mu (t ) du (t ) + ... + ⋅ + ⋅ ( ) = ⋅ + ... + b1 ⋅ + b0 ⋅ u (t ) (2.10) a a y t b m 1 0 n m dt dt dt dt

Siendo y (t ) la salida del sistema y u (t ) la entrada. La ecuación en tiempo discreto equivalente a la ecuación diferencial en tiempo continuo corresponde a una ecuación en diferencias: an ⋅ yk − n + ... + a1 ⋅ yk −1 + a0 ⋅ yk = bm ⋅ uk − m + ... + b1 ⋅ uk −1 + b0 ⋅ uk

(2.11)

De la misma forma que en un sistema de tiempo continuo se puede obtener la función de transferencia a partir de la ecuación diferencial por medio de la Transformada de Laplace, en los sistemas discretos se puede obtener su función de transferencia a partir de la ecuación en diferencias y por medio de Transformada Z, teniendo en cuenta lo siguiente: y k − n → z − n ⋅ Y (z )

(2.12)

Al considerar la última ecuación se obtiene la siguiente función de transferencia: Y ( z ) bm ⋅ z − m + ... + b1 ⋅ z −1 + b0 = U ( z ) a n ⋅ z − n + ... + b1 ⋅ z −1 + b0

(2.13)

2.2.3 Diseño de un controlador discreto

Para diseñar un regulador discreto hay básicamente dos enfoques: El primero es diseñar utilizando todo un conjunto de nuevos métodos y técnicas aplicables a los sistemas discretos. La segunda es aplicar todos lo referente a sistemas continuos para obtener un controlador continuo que luego se convierte en uno discreto. Para hacer esto último se 22

tienen dos posibilidades, tener en cuenta la relación z = e sT , o bien utilizar métodos aproximados como el de la derivada. El método más sencillo es el de la derivada, que consiste en aproximar la derivada por la pendiente de la recta que pasa por dos muestras consecutivas, con lo cual se tiene:

y − y k −1 dy (t ) → k dt T

(2.14)

Al llevar ambas expresiones a su correspondiente transformada se obtiene: s ⋅ Y ( s) →

1 − z −1 ⋅ Y (z) T

(2.15)

Por lo tanto para obtener un controlador discreto a partir de un controlador continuo es suficiente con sustituir las s por

1 − z −1 . T

Entonces es posible obtener un controlador PID discreto a partir de su ecuación continua:   U ( s) 1 = K ⋅ 1 + + s ⋅ Td  E ( s) Ti ⋅ s  

Sustituyendo las s por

(2.16)

1 − z −1 y resolviendo, se obtiene la función de transferencia del T

PID discreto:  T T T  K ⋅ 1 + + d − 1 + 2 ⋅ d T  T U ( z)  Ti = −1 E ( z) 1− z 23

  −1 Td ⋅ z −2  ⋅z + T  

(2.17)

Transformando en una ecuación en diferencias, se tiene: u k = b0 ⋅ ek + b1 ⋅ ek −1 + b2 ⋅ ek − 2 + u k −1

(2.18)

Donde los coeficientes están determinados por los parámetros del controlador ( Ti , Td y K C ) y el tiempo de muestreo ( T ).  T T  b0 = K ⋅ 1 + + d   Ti T 

(2.19)

T   b1 = − K ⋅ 1 + 2 ⋅ d  T  

(2.20)

Td T

(2.21)

b2 = K ⋅

24

2.3

Microcontrolador Atmega16

En esta sección se describe la arquitectura y los periféricos del microcontrolador Atmega16.

2.3.1 Descripción general del microcontrolador

El Atmega16 es un microcontrolador de ocho bits fabricado con tecnología CMOS, posee un conjunto reducido de instrucciones (RISC) y tiene memoria separada para datos e instrucciones, lo que se denomina arquitectura Harvard. Posee un conjunto de periféricos que le permiten interactuar con el mundo exterior, como lo son un convertidor analógico a digital, temporizadores, puertos de entrada y salida, entre otros.

2.3.2 Estructura del microcontrolador En la figura 2.9 se muestra el diagrama de bloques que presenta el microcontrolador Atmega16. En el diagrama se puede ver cada uno de los elementos que integran el microcontrolador, así como la forma en que éstos interactúan; también se detallan los elementos que conforman la unidad de procesamiento central (CPU) y los periféricos. Entre los periféricos se pueden observar cuatro puertos de ocho bits cada uno, el convertidor analógico a digital con ocho canales y un comparador analógico. En la unidad de procesamiento central se tienen varios tipos de memoria y registros, entre ellos; registros de 25

control, de propósito general y de propósito especial. Cada uno de estos elementos se explica con más detalle en las secciones subsiguientes.

Figura 2.9. Diagrama de bloques del Atmega16. 26

2.3.3 Unidad de procesamiento central

La unidad de procesamiento central

se encarga de ejecutar las instrucciones

almacenadas en memoria, a continuación se explica con detalle los elementos que la conforman.

2.3.3.1 Archivo de registros

El Atmega16 cuenta con 32 registros de propósito general. Algunos de estos registros tienen funciones especiales adicionales. La figura 2.10 muestra el archivo de registros; nótese que están nombrados de R0 a R31 y están divididos en dos partes de 16 registros cada una, de R0 a R15 y de R16 a R31.

Figura 2.10. Archivo de registros. 27

Los registros R26 a R31 tienen un propósito adicional, sirven de punteros de 16 bits para direccionamiento indirecto de memoria. Cuando se usan con este propósito estos punteros son nombrados como X, Y y Z; según se muestra en la figura 2.11.

Figura 2.11. Registros X, Y y Z.

2.3.3.2 Contador de programa (PC)

El Atmega16 dispone de un registro de 16 bits llamado contador de programa (PC por sus siglas en inglés: program counter) el cual sigue la ejecución del programa. Una vez finalizada la ejecución de una instrucción el contador de programa contiene la dirección que apunta a la siguiente instrucción a ejecutar.

28

2.3.3.3 Registro de banderas (SREG)

El registro de banderas (SREG por sus siglas en inglés: Status Register) contiene información acerca del resultado de la última operación aritmética realizada y el estado de la CPU. Esta información puede ser usada para alterar el flujo corriente del programa a través de instrucciones de salto condicional. La figura 2.12 muestra el registro de banderas:

Figura 2.12. Registro de banderas.

A continuación se explica cada una de las banderas del registro:

I: Bandera de habilitación de interrupciones.

Ésta bandera habilita las interrupciones globales de la máquina. Un uno en esta bandera permite interrupciones, y un cero las inhabilita.

T: Bandera de copia de bit.

Las instrucciones BLD (Bit Load) y BST (Bit Store) usan ésta bandera como fuente o destino en una operación de bit. La instrucción BST copia un bit de algún registro del 29

archivo de registros en esta bandera, y la instrucción BLD copia la bandera en algún registro del archivo de registros.

H: Bandera de acarreo intermedio.

Ésta bandera indica un acarreo del bit 3 al bit 4 en algunas operaciones aritméticas. Ésta bandera es fuertemente usada en aritmética BCD.

S: Bandera de signo.

La bandera de signo es siempre una OR exclusiva entre las banderas N y V. Estas dos banderas se explican mas adelante.

V: Bandera de sobreflujo.

Ésta bandera indica sobreflujo en operaciones aritméticas con números en complemento a dos.

N: Bandera de Negativo.

Ésta bandera se utiliza para verificar si el resultado es negativo en operaciones lógicas o aritméticas.

30

Z: Bandera de cero.

Ésta bandera indica un resultado igual a cero después de operaciones lógicas o aritméticas.

C: Bandera de acarreo. La bandera C se utiliza para almacenar el acarreo que se genera después de realizar una operación aritmética o para conectar en lazo el bit más significativo con el bit menos significativo en instrucciones de rotación de bits.

En esta arquitectura el registro de banderas no es automáticamente almacenado al entrar en una subrutina de atención a interrupciones y no es restaurado al salir de ésta. Esto debe ser manejado por software.

2.3.3.4 Puntero de pila

El puntero de pila es un registro de 16 bits usado para direccionar un segmento de la memoria llamado “pila”. La pila está ubicada en la memoria SRAM y es usada principalmente para almacenamiento temporal de datos, variables locales, y direcciones de retorno en saltos a subrutina. El puntero de pila del Atmega16 crece de posiciones altas a posiciones más bajas y está divido en una parte alta y una parte baja, según se muestra en la figura 2.13. 31

Figura 2.13. Puntero de pila.

2.3.4 Sistema de memoria

En esta sección se describen los diferentes tipos de memoria del Atmega16. La arquitectura tiene memorias separadas para datos e instrucciones.

2.3.4.1 Memoria flash

El Atmega16 contiene 16K de memoria flash para almacenar las instrucciones del programa. Debido a que las instrucciones tienen 16 o 32 bits de ancho, la memoria está organizada en 8K x16. El mapa de memoria, el cual se muestra en la figura 2.14; está dividido por razones de seguridad en dos secciones: una sección de aplicación (Aplication Flash Section) y una sección de arranque (Boot Flash Section).

32

Figura 2.14. Mapa de memoria.

2.3.4.2 Memoria SRAM

La memoria SRAM es un espacio de 1120 localidades de ocho bits y es utilizada para almacenamiento de datos. Esta memoria contiene los archivos de registros, el espacio de entrada/ salida y 1024 localidades de propósito general.

33

Figura 2.15. Memoria SRAM.

Nótese en la figura 2.15 que el archivo de registros y el espacio entrada/salida puede ser tratado como localidades de memoria SRAM.

2.3.4.3 Memoria EEPROM

La memoria EEPROM es usada para almacenamiento de datos y consiste en 512 posiciones de ocho bits. La memoria EEPROM no está mapeada en memoria, está ubicada en un espacio independiente, por eso se requiere el uso tres registros de entrada/salida para su acceso. Para la dirección se usa el registro EEAR, para el dato se usa EEDR y para su control el registro EECR. 34

2.3.5

Interrupciones

Una interrupción es la ocurrencia de una condición o evento que ocasiona la suspensión temporal del programa principal para atender con una secuencia de código diferente el evento que generó la interrupción, al programa que trata la interrupción se le conoce como rutina de servicio a la interrupción (ISR por sus siglas en inglés: interrupt service routine). En el Atmega16 se tienen 21 fuentes de interrupción que se listan en la tabla 1.

Tabla 1. Fuentes de interrupción.

35

Para atender una interrupción la bandera I del registro de banderas (SREG) debe estar en alto, además de las habilitaciones individuales para cada periférico. Al generarse la interrupción el Contador de programa es almacenado en la pila y la bandera I se pone en bajo, para no permitir que otras interrupciones puedan ser atendidas. El flujo del programa se transfiere a la respectiva subrutina de servicio a la interrupción cuya dirección está dada por el vector de interrupción. La subrutina termina con la instrucción RETI la cual recupera el contador de programa (PC) de la pila y ajusta el valor de la bandera I.

2.3.6 Periféricos

El microcontrolador cuenta con un conjunto de periféricos que le permite intercambiar información con el mundo exterior.

2.3.6.1 Puertos de entrada/salida

El Atmega16 presenta cuatro puertos de entrada/salida conectados a los pines del encapsulado y accesibles desde el exterior del microcontrolador. Cada uno de estos pines comparte funciones con otros periféricos y la Unidad central de procesamiento. La figura 2.16 muestra la configuración de pines de este microcontrolador.

36

Figura 2.16. Configuración de pines del microcontrolador Atmega16.

Para habilitar los pines de estos puertos como entradas o salidas digitales se escribe uno para salida, o un cero para entrada, en el registro correspondiente DDRx. Las direcciones pueden configurarse de manera independiente para cada terminal.

2.3.6.2 Convertidor analógico a digital

El convertidor analógico a digital del Atmega16 tiene una resolución de 10 bits, posee ocho canales de entrada y tensiones de referencia separados, utiliza la técnica de aproximaciones sucesivas como método de conversión y posee un registro retenedor. La figura 2.17 muestra la estructura interna de este periférico.

37

Figura 2.17. Convertidor analógico a digital del Atmega16.

Los voltajes de referencia externos se introducen mediante los pines AREF y AVCC. Para utilizar el convertidor analógico a digital es necesario escribir la configuración deseada en los registros ADCSRA, ADMUX y SFIOR.

38

2.3.6.3 Temporizadores

El temporizador es usado por el microcontrolador para determinar intervalos de tiempos concretos; a nivel de hardware se trata de un registro que se incrementa de manera automática en cada ciclo de reloj, que al llegar a un valor predeterminado genera alguna clase de señalización.

El Atmega16 cuenta con dos temporizadores de ocho bits y uno de 16 bits. En la tabla 2 se muestran estos temporizadores, su tamaño, y el nombre de sus registros contadores.

Tabla 2. Temporizadores del Atmega16. Temporizador

Tamaño

Registros

Temporizador/Contador 0

8 bits

TCNT0

Temporizador/Contador 1

16 bits

TCNT1H, TCNT1L

Temporizador/Contador 2

8 bits

TCNT2

Los temporizadores manejan tres clases de eventos, estas son situaciones que tendrán como resultado una señalización de la que dará cuenta la Unidad central de procesamiento:

•

Desbordamiento: Cuando el respectivo temporizador alcanza su valor máximo, se reinicia en cero, y el evento de registra en la bandera TOVn del registro TIFR. 39

El registro TCNTn puede ser cargado con un valor inicial para generar diferentes intervalos de tiempo.

•

Coincidencia: Un registro llamado OCRn puede ser cargado con un valor para ser comparado con el valor del temporizador en cada ciclo de reloj; una coincidencia tendrá como resultado un evento que es reportado en la bandera OCFn.

•

Captura. El microcontrolador tiene terminales que capturan eventos externos, un cambio en esas terminales tendrá como resultado una lectura del registro TCNTn, cuyo valor será almacenado en ICRn, indicando el evento en la bandera ICFn.

De la misma forma existen tres formas de detectar eventos con el fin de actuar en base a ellos:

•

Sondeo: El programa lee constantemente el estado de las banderas, hasta que ocurre el evento y es reportado en las banderas. También se denomina a éste método “polling” y es muy ineficiente en el uso de los recursos del sistema.

40

•

Interrupción: Para que los eventos generen interrupciones, éstos se deben habilitar en el registro TISMK, y en el registro SREG se deben habilitar las interrupciones globales.

•

Reacción automática: El microcontrolador ofrece la posibilidad de reaccionar automáticamente a nivel de hardware sin intervención de la Unidad central de procesamiento al ocurrir un evento de comparación. Se podría utilizar para poner un pin en alto al darse una coincidencia en el temporizador 1, por citar un ejemplo.

Temporizador/Contador 0

Este temporizador de ocho bits se muestra en la figura 2.18.

Figura 2.18. Temporizador/Contador 0. 41

El registro TCNT0 es el registro que realiza el conteo. El registro OCR0 se compara continuamente con el registro TCNT0 para generar eventos de coincidencias por comparación. Las propiedades del temporizador se modifican a través del registro de control TCCR0.

Temporizador/Contador 1

Este temporizador se muestra en la figura 2.19. Debido a que se trata de un temporizador de 16 bits muchos de sus registros se componen de dos registros de ocho bits.

Figura 2.19. Temporizador/Contador 1. 42

El conteo se realiza con TCNT1, que está dividido en dos registros de ocho bits, TCNT1H para la parte alta y TCNT1L para la parte baja. Los registros OCR1A y OCR1B se utilizan para la continua comparación con TCNT1, con el fin de generar eventos de coincidencia, estos registros también son de 16 bits. También está presente el registro ICR1 cuya función es capturar y retener el valor de TCNT1 ante un evento en la terminal ICP1. Los registros de control son TCCR1A y TCCR1B, ambos de ocho bits.

Temporizador/Contador 2

La figura 2.20 muestra los subsistemas que conforman este temporizador.

Figura 2.20. Temporizador/Contador 2. 43

El registro TCNT2 realiza el conteo. El registro OCR2 es usado para ser comparado con TCNT2 y generar eventos de coincidencia. El registro de control del temporizador es el TCCR2.

44

CAPÍTULO 3. Implementación del sistema 3.1

Descripción del sistema

El sistema a diseñar deberá medir la temperatura a través de un sensor, y a partir del valor deseado introducido por el operador, realizar las operaciones lógicas y aritméticas necesarias - en base al algoritmo PID descrito anteriormente - para determinar la salida PWM.

Figura 3.1. Diagrama del sistema a diseñar.

Se compone de cuatro entradas, tres entradas digitales y una entrada analógica las cuales se describen a continuación:

•

Up: Esta entrada digital se usa para incrementar el valor deseado de temperatura o alguno de los tres parámetros de sintonización. 45

•

Down: Esta entrada digital se usa para decrementar el valor deseado de temperatura o alguno de los tres parámetros de sintonización.

•

Config: Ésta entrada permite seleccionar entre los parámetros de sintonización o el valor deseado, para poder visualizarlos en los tres visualizadores de siete segmentos.

•

Sensor: Una entrada analógica que proviene del sensor de temperatura, y es la forma en la que el sistema mide la variable controlada de la planta.

El sistema también cuenta con cuatro salidas, tres salidas digitales y usa salida PWM, la cuales se explican a continuación: •

Actuador: La salida PWM es usada para realizar el control sobre el proceso térmico.

•

On: Si el sistema está energizado esta luz se mantiene encendida, al apagarse el sistema, la luz se apaga.

•

Display: Visualiza el valor deseado de temperatura (SP) o la temperatura del proceso (PV), según sea el caso.

•

Alarma: Esta salida se activa cuando la temperatura alcanza valores peligrosamente alto o peligrosamente bajos.

46

3.2

Diseño del sistema

A continuación se describe en la selección de cada uno de los elementos que integran el sistema, así como otras importantes decisiones de diseño con el fin de implementar el sistema de la figura 3.1.

3.2.1 Microcontrolador

Para escoger un microcontrolador a emplear en el diseño hay que tomar en cuenta una multitud de factores, como documentación, herramientas de desarrollo disponibles y su precio, también características del microcontrolador como tamaño de memoria, número de temporizadores, interrupciones, etc.

Para ésta aplicación en particular se tienen los siguientes requerimientos:

•

El microcontrolador deberá contar con herramientas de desarrollo gratuitas y una gran cantidad de documentación.

•

El microcontrolador deberá disponer de un convertidor analógico a digital, ya que se pretende utilizar un sensor de temperatura que tenga una salida analógica.

47

•

Son necesarios dos contadores, uno para fijar el tiempo de muestreo de la señal analógica y otro para contar el tiempo que hay que mantener encendido cada visualizador de siete segmentos.

3.2.2 Actuador

Para la implementación del sistema se optó por utilizar como actuador un conjunto de tres bombillos para proporcionar calor a los huevos, se descartó el uso de un calefactor tradicional debido a su alto costo. En la figura 3.2 se muestra los tres bombillos utilizados, se trata de dos bombillos incandescentes y uno halógeno.

Figura 3.2. Sistema calefactor.

48

Una manera de mejorar la confiabilidad de un sistema es introducir redundancia en tiempo (repetir una operación) o en recursos (tener otros elementos a disposición que puedan cumplir la función del elemento que falló) . En este sentido utilizar tres bombillos en lugar de uno tendrá como resultado un mejora significativa en la confiabilidad de todo el sistema, pues introduce redundancia en recursos. Para controlar la tasa de flujo de calor entregada por los tres bombillos se utilizó un relé conectado a la salida PWM del microcontrolador, según la configuración mostrada en la figura 3.3.

Figura 3.3. Manejo del sistema calefactor.

49

Nótese en la figura 3.3 la presencia de un LED conectado en paralelo a la señal PWM. Este LED se usó para efectos de pruebas y depuración en las últimas etapas de la implementación del prototipo.

3.2.3 Sensor

El sensor de temperatura seleccionado fue el LM35DT debido a su bajo costo, facilidad de uso y gran cantidad de documentación disponible.

Figura 3.4. Sensor de temperatura LM35DT.

El LM35DT tiene tres pines, dos para alimentarlo y uno que proporciona una salida en voltios proporcional a la temperatura en grados Celsius. Este sensor tiene una salida que equivale a 10 mV/ºC y una precisión de ±0.2 ºC. La siguiente tabla muestra algunas 50

equivalencias entre la salida del sensor en milivolts y el correspondiente valor en grados celsius.

Tabla 3. Equivalencia entre la salida del sensor LM35DT y la temperatura. Vout (mV)

Temperatura (ºC)

112

11.2

298

29.8

529

52.9

El LM35DT funciona con un rango de alimentación comprendido entre 4 V y 20 V. Y se pretende conectarlo al convertidor analógico a digital del microcontrolador.

3.2.4 Visualizador

El visualizador utilizado es el NTE3058 de ánodo común el cual se muestra en la figura 3.5; en total se utilizaron tres de éstos, para visualizar los tres dígitos requeridos de la temperatura.

51

Figura 3.5. Visualizador de siete segmentos de ánodo común NTE3058.

Se contaba con solamente diez pines para manejar los tres visualizadores, por ello se utilizó multiplexación de los visualizadores. En este tipo de conexión los visualizadores comparten las mismas líneas de datos pero tienen habilitadores por separado. De esta manera se utilizan solamente diez líneas para manejar los tres visualizadores, tal como se muestra en la figura 3.6.

52

Figura 3.6. Conexión de los visualizadores al microcontrolador.

Para utilizar este tipo de conexión se debe dividir el tiempo entre tres y mostrar durante unos pocos milisegundos el dígito correspondiente. Si se quiere mostrar el número “123” se debe habilitar el primer visualizador poniendo un uno en la línea del transistor correspondiente al primer visualizador y enviando el valor “1” al buffer de tercer estado 74HCT573. Después de un tiempo se coloca un uno en la base del transistor correspondiente al segundo visualizador y se envía un “2” al 74HCT573. Pasado el tiempo 53

se selecciona el tercer visualizador y se envía un “3” al buffer.

El tiempo que permanece encendido cada visualizador está determinado por el tiempo de refresco del ojo humano, que no reconoce más de 25 cuadros por segundo, por lo que el tiempo máximo de refresco de cada visualizador es el valor del tiempo en que se tiene que refrescar los tres visualizadores, dividido entre el número de visualizadores:

1 ⋅ segundo / 25 ⋅ cuadros = 13.3 3 ms 3 ⋅ visualizadores

(3-1)

3.2.5 Alarma

Para dar aviso de temperaturas peligrosas se utilizó un sistema de alarma. La idea es dar aviso de condiciones de temperatura totalmente fuera de los parámetros de incubación. Se utilizó un zumbador genérico de bajo costo y un transistor TIP122. El uso de un transistor PNP se debe a que se desconocía de antemano las exigencias de carga del zumbador.

54

Figura 3.7. Sistema de alarma.

3.2.6 Esquemático final del controlador

Se utilizó el puerto A y el puerto C del microcontrolador para manejar los tres dígitos de siete segmentos. Los pines del cero al seis del puerto A se conectaron a cada uno de los pines del 74HCT573 y de ahí a los segmentos de los visualizadores, y tres pines del puerto C se conectaron de forma alternada a los transistores habilitadores correspondientes a cada uno de los visualizadores. El pin siete del puerto A se dejó como una entrada analógica de la señal que proviene del sensor de temperatura. El pin siete del puerto C se utilizó para generar una señal PWM para manejar el relé, el cual a su vez enciende y apaga los bombillos. Los botones Up, Down y Config se conectaron al pin dos y tres del puerto D, y al pin dos del puerto B, respectivamente. Por último el pin cuatro del puerto C maneja el

55

transistor TIP122 del zumbador. La figura 3.8 corresponde al esquemático final del controlador:

Figura 3.8. Esquemático del controlador.

3.3

Implementación de la planta

Entre los materiales para la construcción de la incubadora se tenían dos opciones: la madera y el metal. El metal se descartó por su alto costo; en cambio se utilizó madera, que no es tan cara, y además ofrece excelentes cualidades de aislamiento térmico. Uno de los requerimientos de una incubadora de madera es que la misma no debe estar pintada ni barnizada, ya que estas sustancias emanan gases tóxicos que pueden perjudicar el proceso de incubación. El tamaño de una incubadora puede variar desde cámaras del tamaño de una habitación que pueden incubar varias decenas de miles de huevos hasta incubadoras pequeñas, del

56

tamaño de un microondas o un horno doméstico. La incubadora que se construyó es de dimensiones pequeñas, con capacidad para media docena de huevos. Para construir la incubadora se comenzó con una panera de madera ya construida, que tenían los requerimientos de espacio necesarios para albergar ésta pequeña cantidad de huevos. Para permitir una buena circulación del aire se instaló un ventilador y se realizaron pequeños orificios a los costados, esto porque la circulación de aire es un requerimiento importante, pues permite renovar el aire constantemente en el interior de la incubadora, algo fundamental para la correcta incubación de los huevos. También la ventilación busca homogenizar la temperatura del aire y así evitar fuertes gradientes de temperatura.

Figura 3.9. Proceso implementado. 57

3.4

Identificación del proceso

3.4.1 Obtención de la curva de reacción

Para poder aplicar cualquier método de sintonización es necesario conocer primero la dinámica del proceso. La obtención de la dinámica del proceso requiere que el mismo sea excitado con una señal escalón en su entrada y que su respuesta sea registrada. En el caso particular de la incubadora, el proceso se excita encendiendo los bombillos con una señal constante de 12 V. A los 5400 segundos se apagó la fuente de poder y se siguió registrando datos durante 1800 segundos más, manteniendo los bombillos apagados. Se utilizó un termómetro digital para medir la evolución de la temperatura en el interior de la incubadora y un cronómetro para medir el tiempo. Después de dos horas (7200 segundos) se obtuvieron los datos con los cuales se elaboró la siguiente gráfica.

Figura 3.10. Curva de reacción del proceso. 58

3.4.2 Obtención del modelo

La respuesta del sistema ante una entrada escalón permite determinar que el sistema es de primer orden y que el modelo más adecuado será también de primer orden. A partir de la medición directa de los parámetros sobre la curva de reacción se determinó la constante de tiempo y la ganancia, obteniéndose el modelo de la ecuación 3-2.

P( s) =

3.5

0.847 480.0 s + 1

(3-2)

Sintonización

El método de sintonización elegido fue analítico. Se pretende optimizar el desempeño del sistema para la respuesta en el valor deseado (servomecanismo). La dinámica de la planta está dada por la siguiente ecuación: P( s) =

Kp Ts + 1

(3-3)

Donde K P es la ganancia, y T es la constante de tiempo de la planta. Ambos parámetros ya fueron determinados utilizando identificación experimental. La ecuación del controlador PID ideal que se está implementando es:

59

C ( s) =

K c ⋅ (T d ⋅ s + 1) ⋅ (Ti ⋅ s + 1) Ti s

(3-4)

Donde K C es la ganancia proporcional, Td el tiempo derivativo, y Ti el tiempo integral. La función de transferencia de lazo abierto:

L( s ) = P ( s )C ( s ) =

K c ⋅ K p (Td ⋅ s + 1) ⋅ (Ti ⋅ s + 1) Ti s ⋅ (T ⋅ s + 1)

(3-5)

La solución más simple es hacer el tiempo integral igual a la constante de tiempo de la planta y el tiempo derivativo nulo, esto es:

T = Ti

(3-6)

Td = 0

(3-7)

Con lo que se obtiene la siguiente función de transferencias de lazo abierto:

L( s ) =

K p ⋅ Kc Ti ⋅ s

60

(3-8)

Y la siguiente función de transferencia de lazo cerrado:

M yr =

1 Ti ⋅ s +1 K p ⋅ Kc

(3.9)

Nótese en la función de transferencia de lazo cerrado que la ganancia es unitaria y que la constante de tiempo está determinada por la ganancia del controlador y el tiempo integral. La constante de tiempo de la respuesta en el servomecanismo queda entonces:

Tc =

T K p ⋅ Kc

(3.10)

Kc =

T K p ⋅ Tc

(3-11)

Despejando la ganancia proporcional:

En resumen se tienen los siguientes parámetros para el PID:

Ti = T

61

(3-12)

Td = 0 Kc =

T K p ⋅ Tc

(3-13) (3-14)

Como se puede ver, el único parámetro ajustable es la constante de tiempo de la respuesta del servomecanismo. Hacer este parámetro pequeño sería lo ideal, pero tendría el inconveniente de que salida del controlador analítico sería demasiado grande, y la salida del controlador real trabajaría en saturación. El valor de compromiso elegido para esta constante es: T = 300 s

(3-15)

Por lo tanto, los parámetros del controlador quedan como: Ti = 480.0

(3-16)

Td = 0.00

(3-17)

K c = 1.89

(3-18)

Un tiempo derivativo nulo implica un controlador PI, que es un caso particular del controlador PID ideal. Y los respectivos coeficientes del controlador discreto son: b0 = 1.90

(3-19)

b1 = 1.89

(3-20)

b2 = 0.00

(3-21)

62

3.6

Diagrama de flujo

EL microcontrolador cuenta con un conjunto de periféricos que permiten implementar el circuito de forma simple y eficaz. Los tres botones; éstos son: Up, Down y Config se conectaron a los pines del microcontrolador señalados como: INT0, INT1, INT2. Un evento de flanco positivo en estos pines tendrá como resultado una interrupción que hará al programa salir de su rutina principal y ejecutar la correspondiente subrutina de atención a interrupciones. La figura 3.11 corresponde a los diagramas de flujos de cada una de estas tres subrutinas:

Figura 3.11. Subrutinas de atención a interrupciones externas.

63

En la figura 3.11 se muestra las subrutinas correspondientes a cada unos de los eventos generados por los botones. Al presionar el botón Up, se generará un flanco positivo en la entrada del pin INT0 que llevará el flujo del programa a la subrutina de interrupción señalada como Interrupción Externa 0, a continuación el código de la subrutina deberá incrementar la variable que está mostrando el visualizador. De manera similar, el botón Down generará un flanco que tendrá como resultado el decremento de la variable

correspondiente en la subrutina Interrupción Externa 1. Algo diferente hace la subrutina correspondiente al botón Config, pues ésta deberá cambiar el valor actual en los visualizadores, por otro parámetro de sintonización, o el valor deseado, para así realizar las respectivas modificaciones a la variable. El muestreo de la señal analógica se hace cada T segundos, es por esa razón que se requirió de un temporizador cuyo único propósito sea contar éste tiempo, al terminar de contar, deberá generar un evento de sobreflujo que trasladará el flujo a una subrutina de atención a interrupciones llamada Sobreflujo en Temporizador 1, la cual utilizará el convertidor analógico a digital para tomar una muestra del voltaje analógico de salida del sensor, y asignará a la variable global Read_ADC el valor TRUE, con el fin de informar al programa principal de que ha sido tomada una nueva muestra.

64

Figura 3.12. Subrutina de interrupción de sobreflujo en temporizador 1.

Para manejar los tres visualizadores con el menor número de pines se utilizó una técnica conocida como multiplexación (ver sección 3.2.4). Ésto requiere un temporizador dedicado que interrumpa constantemente el flujo del programa, y ejecute una subrutina que encenderá un visualizador con el dígito correspondiente y apagará el que se encontraba encendido. La subrutina se llama Sobreflujo en Temporizador 0, y se muestra en la figura 3.13.

65

Figura 3.13. Subrutina de sobreflujo en temporizador 0.

La figura 3.14 corresponde a la rutina principal del programa. Ésta comienza con la configuración e inicialización de los periféricos, seguido de la obtención de los parámetros del controlador, a continuación el programa hace polling de la variable Read_ADC, esperando que la subrutina de sobreflujo en temporizador 1 tome una muestra y cambie el valor de ésta variable a TRUE. Una vez que ha sido tomada la muestra, la rutina sigue con la ejecución del código. El control debe realizarse si el valor deseado es mayor que la señal realimentada; si éste es el caso, se calcula la salida del controlador y este valor se escribe en

66

el registro OCR2 del temporizador 2, que se encarga de generar la señal PWM. Éste ciclo se repite de forma indefinida.

Figura 3.14. Diagrama de flujo de rutina principal. 67

3.7

Programación

La rutina principal comienza con la definición de los puertos, los cuales se definen en una función llamada port_define_IO(). En ésta función se configuran los pines de los puertos como entradas o salidas, según corresponda, a través del registro DDRx. Un “1” define un pin como salida, y un “0” como entrada.

void port_define_IO(void) //Definición de puerto I/O. { DDRA=0x7f; DDRB=0x01; DDRC=0xff; DDRD=0x80; }

Figura 3.15. Subrutina void port_define_IO(void).

A continuación se procede con la inicialización de los puertos con la función port_initiate().

68

void port_initiate(void) //Inicialización de puertos. { PORTA=0xff; PORTB=0x00; PORTC=DISPLAYOFF; }

Figura 3.16. Subrutina void port_initiate(void).

Las interrupciones se habilitan usando la función sei(), y a continuación se procede con el encendido de los temporizadores 0 y 1, a través de las funciones enc_timer0() y enc_timer1().

void enc_timer0(void) { TCCR0 = 0x02; //Preescala 8. TIFR = 0x01; //Pone en cero en la bandera de desborde del Reloj/Contador0. sbi(TIMSK,TOIE0); //Habilitación de la interrupción por desborde del Reloj/Contador0. }

Figura 3.17. Subrutina void enc_timer0(void).

69

void enc_timer1(void) { TCCR1A = 0x00;//Preescala 64. TCCR1B = 0x03; TIFR = 0x04; //Borra bandera de sobreflujo en timer1. sbi(TIMSK, TOIE1); //Habilita las interrupciones por sobreflujo en timer1. }

Figura 3.18. Subrutina void enc_timer1(void).

La función enc_timer0() configura el temporizador cero con una preescala de ocho, para obtener un retardo de 2,048 ms, y la función enc_timer1() con un preescala de 64 para obtener un retardo de 4.19 s. A continuación se habilitan las tres interrupciones externas que son configuradas para detección de eventos de flanco positivo en los pines, esto a través de las funciones enable_int0(), enable_int1() y enable_int2().

void enable_int0(void) { sbi(MCUCR,ISC00); //Flanco positivo. sbi(MCUCR,ISC01); sbi(GICR,INT0); //Habilita interrupción. sbi(GIFR,INTF0); //Limpio bandera. }

Figura 3.19. Subrutinas de interrupciones externas.

70

void enable_int1(void) { sbi(MCUCR,ISC10); //Flanco positivo. sbi(MCUCR,ISC11); sbi(GICR,INT1); //Habilita interrupción. sbi(GIFR,INTF1); //Limpio bandera. } void enable_int2(void) { cbi(MCUCSR,ISC2); //Flanco positivo. sbi(GICR,INT2); //Habilita interrupción. sbi(GIFR,INTF2); //Limpio bandera. }

Figura 3.19 (Continuación). Subrutinas de interrupciones externas.

En el apéndice A, específicamente en el archivo isr.h, se presentan éstas tres subrutinas, se puede ver que la interrupción INT0 tendrá como resultado un incremento en el valor deseado o algunos de los tres parámetros de sintonización b0 , b1 y b2 ; de la misma forma una interrupción INT1, tendrá como resultado una disminución del parámetro correspondiente. La interrupción INT2 se utiliza para cambiar el valor que actualmente se está visualizando en el conjunto de los tres visualizadores, para ello se utiliza la variable PV_SP que puede almacenar cuatro estados Display_SP, Display_b0, Display_b1, Display_b2 y Display_SP. La interrupción siempre tendrá como resultado el paso de un

71

estado al siguiente, y el estado correspondiente será usado por la subrutina de atención a interrupciones de sobreflujo en temporizador cero para mostrar el número correspondiente.

Después de cuatro funciones que convierten los parámetros de sintonización y el valor deseado en codificación BCD, se habilita la salida PWM a través de la función config_pwm().La configuración seleccionada es Fast PWM, y el valor del registro OCR2,

que es el registro que controla la modulación del ancho de pulso, es por defecto 0xff.

void config_pwm(void) //Configura el PWM. { TCCR2=0x6f; OCR2=0xff; }

Figura 3.20. Subrutinas config_pwm().

La sección siguiente de código en la rutina principal (ver Apéndice A) es un bucle que se repite indefinidamente y comienza revisando la variable Read_ADC, que es modificada por la subrutina de atención a interrupciones de sobreflujo en temporizador 1. La siguiente figura corresponde a ésta subrutina de atención a interrupciones.

72

SIGNAL(SIG_OVERFLOW1) // Sobreflujo en timer1. { apg_timer1(); // Se inhabilitan interrupciones y se borra la bandera de sobre flujo. Read_ADC=TRUE; sensor_adlar_0(); // Realiza conversión ADC. enc_timer1(); // Se habilitan interrupciones y se borra la bandera. }

Figura 3.21. Subrutina de sobreflujo en temporizador uno.

Cada 4.19 s se ejecuta ésta subrutina de atención de interrupciones que almacena en Read_ADC la constante TRUE, eso por una razón: para informar al programa principal de

que el convertidor analógico digital ha tomado una muestra almacenando el resultado de la conversión en el entero de 16 bits y_n. A continuación se convierte el valor de y_n en una estructura tipo bcd. La estructura tipo bcd está declarada en el archivo estructuras.h, el contenido de éste archivo se muestra a

continuación:

// Archivo: estructuras.h //-------------------------------------------------------// //---------------------Estructuras-----------------------// //-------------------------------------------------------// typedef struct { u08 decimales; u08 unidades; u08 decenas; } bcd;

Figura 3.22. Archivo estructuras.h.

73

La estructura bcd almacena un número en ésta misma codificación. Para ello se dispone de tres enteros de ocho bits cada uno, uno para unidades, otro para las decenas y otro para los decimales. Ésta estructura en conjunto con la función bcd binario_bcd(u16 numero) es usada intensamente por la subrutina de atención a interrupciones SIGNAL(SIG_OVERFLOW0) para desplegar los respectivos valores en los visualizadores. Ésta subrutina tiene cuatro estados, un estado inicial, que mantiene los tres visualizadores apagados, y los estados DISPLAY1, DISPLAY2 y DISPLAY3; en cada uno de estos estados se habilita un único

visualizador, y se escribe en el puerto el dígito correspondiente. Las secciones siguientes del código calculan la salida del controlador y revisan la temperatura del proceso, si la misma está fuera de las cotas asignadas, se enciende la alarma indicando al operador la presencia de temperaturas totalmente fuera de los rangos normales de operación para la incubación de huevos. El siguiente código calcula la salida del controlador:

u_0 =(b_0*e_0 - b_1*e_1 + b_2*e_2 + u_1);

Figura 3.23. Salida del controlador.

La figura 3.24 corresponde al código de alarma. 74

if( (y_n > 400) || (y_n < 200) ) {on_alarma();} else {off_alarma();} Figura 3.24. Encendido de la alarma.

Cada vez que el convertidor analógico toma una muestra se revisa que el valor no excede los 40ºC, y que no está por debajo de 20ºC, en caso contrario se enciende la alarma. Las funciones on_alarma() y off_alarma(), ponen un “1” y un “0” en el pin del puerto C, respectivamente; encendiendo y apagando

75

3.8

Prototipo final

La figura 3.25 muestra el circuito implementado en una “protoboard”; se muestran cada uno de los elementos que integran el sistema: tres botones, los visualizadores, el relé, el sensor de temperatura LM35, y la alarma.

Figura 3.25. Prototipo final.

Se puede ver un conjunto de cables con una cubierta protectora que van desde el conector hembra del puerto paralelo de la “protoboard” al microcontrolador, estos cables son usados para descargar el programa en la memoria flash del Atmega16. La aplicación 76

utilizada para descargar el programa en el microcontrolador se denomina uisp, y para compilarlo se utilizaron las respectivas librerías de gcc. Es importante hacer notar que ambas aplicaciones son software libre. Se realizaron un conjunto de pruebas para probar el funcionamiento del sistema como servomecanismo. Las pruebas se realizaron para valores de temperatura entre 35.5ºC y 38.5 ºC, pues éste es el rango de valores de temperatura de incubación de la mayoría de aves de corral. En la figura 3.26 se muestra la respuesta del sistema para un valor deseado de 36.5ºC.

Figura 3.26. Respuesta del sistema para un valor deseado de 36.5ºC.

Adjunto a cada punto en el gráfico está el valor de la medición de la temperatura en grados celsius. Nótese que la respuesta del sistema es de primer orden, y que presenta una 77

constante de tiempo de aproximadamente 300 segundos, ambas características son consistentes con el método de sintonización llevado a cabo.

Figura 3.27. Respuesta del sistema para un valor deseado de 38.5ºC.

La figura 3.27 presenta la respuesta del sistema para un valor deseado de 38.5ºC. En ésta figura y en la figura 3.26 el valor inicial de la temperatura fue 26.3ºC y 27.1ºC, ambas corresponden a la temperatura ambiente al momento de realizar las pruebas. La figura 3.28 y 3.29 corresponden a pruebas realizadas pero con una temperatura inicial en el interior de la incubadora distinta de la temperatura ambiente.

78

Figura 3.28. Respuesta del sistema para un valor deseado de 35.5ºC.

La figura 3.28 es una gráfica de la respuesta del sistema para un valor deseado de 35.5ºC y una temperatura inicial de 28.5ºC, nótese que aproximadamente a los cinco minutos la temperatura en el interior de la incubadora ya ha alcanzado el valor deseado, después de eso la temperatura se mantiene cercano a este valor, hasta finalizar la prueba pasados 14 minutos. La figura 3.29 es la última gráfica de temperatura versus tiempo, en este caso la temperatura de la incubadora al iniciar la prueba era de 32.4ºC y el valor deseado de 37.2ºC.

79

Figura 3.29. Respuesta del sistema para un valor deseado de 37.2ºC.

La temperatura de la incubadora tiene una respuesta rápida al inicio pues en los primeros 60 segundos pasa de 32.4 ºC a 33.8 ºC, un aumento de 1.4 ºC, al ir disminuyendo el error, la respuesta se hace más lenta, nótese que desde los 300 segundos hasta los 600 segundos, la temperatura en la incubadora aumenta apenas 1.0ºC, hasta alcanzar el valor deseado; punto desde el cual la temperatura se mantiene relativamente estable. Éste es comportamiento esperado para un sistema con una respuesta de primer orden.

80

CAPÍTULO 4: Conclusiones y recomendaciones Dentro de las principales conclusiones obtenidas a partir del desarrollo del proyecto y de los resultados del mismo se tiene:

•

Se realizó un análisis del proceso térmico desde la perspectiva de la red generalizada, considerando un capacitor generalizado para modelar el almacenamiento de calor dentro de la incubadora y una resistencia generalizada para modelar la pérdida de calor a través de las paredes de la incubadora, obteniéndose la ecuación que muestra la temperatura en el interior de la incubadora en función del calor proporcionado por el calefactor, la temperatura exterior, y las características constructivas de la planta.

•

Se obtuvo la dinámica del sistema empleando la curva de reacción del proceso, identificando el sistema con un modelo de primer orden a través de la medición directa de los parámetros, de ésta forma se obtuvo una constante de tiempo de 480 segundos y una ganancia de 0.847, a partir de los cuales se determinó la función de transferencia del proceso.

•

Para sintonizar el controlador se utilizó un método analítico cancelando el cero del modo integral con el polo de la planta obteniéndose la función de 81

transferencia de lazo abierto y la función de transferencia de lazo cerrado para el servomecanismo. Se determinaron los parámetros del controlador para una constante de tiempo de 300 segundos, para la cual se calculó una ganancia proporcional de 1.89, un tiempo derivativo igual a cero, y un tiempo integral igual a 480.0 segundos.

•

Se determinó que la acción del controlador debe ser de tipo inversa; ya que un aumento en la temperatura provocaría una disminución en la salida del controlador.

•

Se programó el controlador PID discreto en un microcontrolador Atmega16, para ello se utilizó el compilador gcc para obtener el programa objeto y el software uisp para descargarlo en la memoria flash del microcontrolador.

•

Se realizaron un conjunto de pruebas para probar el correcto funcionamiento del controlador. Se realizaron mediciones de temperatura contra tiempo para una entrada escalón en el valor deseado, esto se observa en las figuras 3.26, 3.27, 3.28, y 3.29.

82

Gracias al conocimiento y a las experiencias adquiridas durante este proyecto, se desea agregar un conjunto de recomendaciones que pueden resultar útiles para optimizaciones a este proyecto, o para futuros estudiantes interesados en proyectos similares:

•

Hay todo un conjunto de controladores más complejos que pueden ser implementados en tiempo discreto, también hay todo un conjunto de métodos de sintonización que pueden ser aplicados para optimizar diferentes criterios de desempeño.

•

Para futuros proyectos que sigan esta línea, se sugiere utilizar un filtro para disminuir el efecto del ruido, pues la señal realimentada proveniente del sensor de temperatura presenta pequeñas variaciones que afectan el funcionamiento del controlador, ya que trata de corregir supuestas bajas en la temperatura que corresponden al ruido del cable entre el sensor y el microcontrolador.

•

Durante el período de diseño e implementación del sistema de control se decidió utilizar un relé electromecánico debido a su bajo costo, el cual para las condiciones de operación tan abusivas de un elemento final de control verá su vida útil disminuida en forma significativa en comparación a un dispositivo de estado sólido, por eso se recomienda la utilización de algún otro dispositivo de 83

conmutación como un relé de estado sólido o un tiristor de potencia en lugar de un elemento electromecánico.

•

El sensor de temperatura LM35DT es relativamente barato, sin embargo con una inversión adicional se podría obtener un sensor con salida digital, como el DS18S20, que permitiría utilizar el convertidor analógico a digital del microcontrolador para otros propósitos como por ejemplo un sensor de dióxido de carbono o de oxígeno.

•

Es usual que los controladores comerciales incluyen varios tipos de salidas, así que una mejora de éste trabajo podría incluir salidas de voltaje y corriente, adicional a la salida de relé.

•

Un método de programación de los parámetros a través del protocolo RS-485 sería un mejora adicional a éste proyecto, lo cual daría la posibilidad de disponer de un método adicional de fijación de los parámetros del controlador.

84

BIBLIOGRAFÍA Libros

1. Katsuhiko, O. “Ingeniería de control moderna”, Tercera edición, Prentice Hall, Estados Unidos, 1998 2. Katsuhiko, O. “Sistemas de control en tiempo discreto”, Segunda edición, Prentice Hall, Estados Unidos, 2005. 3. Alfaro, V. “Apuntes del curso IE 0431: Sistemas de control”, Escuela de Ingeniería Eléctrica. Universidad de Costa Rica. 2005. 4. Alfaro, V. “Apuntes del curso IE 1032: Control e instrumentación de procesos industriales”. Escuela de Ingeniería Eléctrica. Universidad de Costa Rica.

2006.

Hojas del fabricante

1. Atmel. “8-bit AVR Microcontroller with 16 K Bytes In-System Programmable Flash. Atmega16A”.

2. NTE Electronics, Inc. “NTE3052 thru NTE3055 0.3” Single Digit Numeric Display, Seven Segment, Common Anode”.

3. STMicroelectronics. “TIP120/121/122/125/126/127. Power Darlington Transistors”.

85

Complementary

Silicon

4. National Semiconductor. “LM35. Precision Centigrade Temperature Sensors”, November 2000. 5. Fairchild Semiconductor. “DM74LS573. Octal D Latch with 3-STATE Outputs”, March 1998.

6. Motorola. “Amplifiers Transistors. NPN Silicon. BC546, B. BC547, A, B, C. BC548, A, B, C”.

7. Discrete POWER & Signal Technologies. “2N3904 / MMBT3904 / MMPQ3904 / PZT3904”.

86

Apéndice A: Código.

// Archivo: define.h #define IN 0 #define OUT 1 #define LOW 0 #define HIGH 1 #define FALLING 0 #define RISING 1 #define TRUE 1 #define FALSE 0 #define DISPLAY1 0x80 #define DISPLAY2 0x20 #define DISPLAY3 0x40 #define DISPLAYOFF 0x00 #define Display_SP 0x00 #define Display_b0 0x01 #define Display_b1 0x02 #define Display_b2 0x03 #define Display_PV 0xff //Valor deseado #define SetPoint 35.5 //Parámetros del PID. //Parámetros del controlador. //b_0 #define b0 1.90f //b_1

88

#define b1 1.88f //b_2 #define b2 0.00f //Tiempo de muestreo. #define T 4.194f

#define VAR #define BEGINCODE #define ENDCODE #define DDR(x) ((x)-1) /* address of data direction register of port x */ #define PIN(x) ((x)-2) /* address of input register of port x */

#ifdef AVR_ATmega103 #define AVR_MEGA 1 #else #ifdef AVR_ATmega603 #define AVR_MEGA 2 #else #ifdef AVR_ATmega161 #define AVR_MEGA 3 #else #define AVR_MEGA 0 #endif #endif #endif

// Archivo: estructuras.h //-------------------------------------------------------// //---------------------Estructuras-----------------------// //-------------------------------------------------------// typedef struct { u08 decimales; u08 unidades; u08 decenas;

} bcd;

// Archivo: include.h #include "define.h" #include "tipos.h" #include "estructuras.h" #include "variables.h" #include "prototipos.h" #include "isr.h"

// Archivo: isr.h //-------------------------------------------------------// //-------------------Interrupciones----------------------// //-------------------------------------------------------// SIGNAL(SIG_INTERRUPT0) // Incrementa la variable indicada { //por el botón Config. disable_int0(); switch(PV_SP) { case Display_SP: ++r_n; sp=binario_bcd(r_n); break; case Display_b0: b_0+=0.01f; function_b0(); break; case Display_b1: b_1+=0.01f; function_b1(); break; case Display_b2: b_2+=0.01f; function_b2();

break; case Display_PV: break; } enable_int0(); } SIGNAL(SIG_INTERRUPT1) // Decrementa la variable indicada { // por Config. disable_int1(); switch(PV_SP) { case Display_SP: --r_n; sp=binario_bcd(r_n); break; case Display_b0: b_0-=0.01f; function_b0(); break; case Display_b1: b_1-=0.01f; function_b1(); break; case Display_b2: b_2-=0.01f; function_b2(); break; case Display_PV: break; } enable_int1(); }

SIGNAL(SIG_INTERRUPT2) // Visualiza entre los distintos parámetros de { // configuración. disable_int2(); switch(PV_SP) { case Display_SP: PV_SP=Display_b0; break; case Display_b0: PV_SP=Display_b1; break; case Display_b1: PV_SP=Display_b2; break; case Display_b2: PV_SP=Display_PV; break; case Display_PV: PV_SP=Display_SP; break; } enable_int2(); } SIGNAL(SIG_OVERFLOW1) // Sobreflujo en timer1. { apg_timer1(); // Se inhabilitan interrupciones y se borra la bandera de sobre flujo. Read_ADC=TRUE; sensor_adlar_0(); // Realiza conversión ADC. enc_timer1(); // Se habilitan interrupciones y se borra la bandera. } SIGNAL(SIG_OVERFLOW0) // Subrutina encargada del manejo de los tres visualizadores

{ // de siete segmentos. apg_timer0(); switch(EstDisplay) { case DISPLAYOFF: switch(PV_SP) { case Display_SP: PORTA=numero_display(sp.decimales); break; case Display_PV: PORTA=numero_display(pv.decimales); break; case Display_b0: PORTA=numero_display(coef_b0.decimales); break; case Display_b1: PORTA=numero_display(coef_b1.decimales); break; case Display_b2: PORTA=numero_display(coef_b2.decimales); break; } PORTC=EstDisplay=DISPLAY1; break; case DISPLAY1: switch(PV_SP) { case Display_SP: PORTA=numero_display(sp.unidades); break; case Display_PV: PORTA=numero_display(pv.unidades);

break; case Display_b0: PORTA=numero_display(coef_b0.unidades); break; case Display_b1: PORTA=numero_display(coef_b1.unidades); break; case Display_b2: PORTA=numero_display(coef_b2.unidades); break; } PORTC=EstDisplay=DISPLAY2; break; case DISPLAY2: switch(PV_SP) { case Display_SP: PORTA=numero_display(sp.decenas); break; case Display_PV: PORTA=numero_display(pv.decenas); break; case Display_b0: PORTA=numero_display(coef_b0.decenas); break; case Display_b1: PORTA=numero_display(coef_b1.decenas); break; case Display_b2: PORTA=numero_display(coef_b2.decenas); break; } PORTC=EstDisplay=DISPLAY3;

break; case DISPLAY3: switch(PV_SP) { case Display_SP: PORTA=numero_display(sp.decimales); break; case Display_PV: PORTA=numero_display(pv.decimales); break; case Display_b0: PORTA=numero_display(coef_b0.decimales); break; case Display_b1: PORTA=numero_display(coef_b1.decimales); break; case Display_b2: PORTA=numero_display(coef_b2.decimales); break; } PORTC=EstDisplay=DISPLAY1; break; } enc_timer0(); }

// Archivo: main.c #include #include #include #include "include.h" //-------------------------------------------------------//

//-------------------------Main--------------------------// //-------------------------------------------------------// int main(void) { // Definicion de puertos E/S port_define_IO(); // Inicializacion de puertos E/S. port_initiate(); // Habilitacion de interrupciones globales. sei(); // Encendido del timer 1. enc_timer1(); // Encendido del timer 0. enc_timer0(); // Habilito interrupciones externas. enable_int0(); enable_int1(); enable_int2(); // Valor deseado. setpoint(); // Coeficientes. function_b0(); function_b1(); function_b2(); // Configuro PWM. config_pwm(); for(;;) { if(Read_ADC) {

Read_ADC=FALSE; pv=binario_bcd(y_n); // Escribe el valor en los puertos. if(r_n > y_n) { //Error. e_2=e_1; e_1=e_0; e_0=(float)( r_n - y_n ); //Salida. u_1=u_0; //Cálculo de la salida del controlador a través de //ecuación en diferencias. u_0 =(b_0*e_0 - b_1*e_1 + b_2*e_2 + u_1); //Se toma en cuenta la saturación al fijar la salida //del controlador. if(u_0 >= 255.0f) pwm(0xff); else if(u_0 400) || (y_n < 200) ) {on_alarma();} else {off_alarma();} } } return TRUE; } //-------------------------------------------------------//

//-----------------------Puertos-------------------------// //-------------------------------------------------------// void port_define_IO(void) //Definición de puerto I/O. { DDRA=0x7f; DDRB=0x01; DDRC=0xff; DDRD=0x80; } void port_initiate(void) //Inicialización de puertos. { PORTA=0xff; PORTB=0x00; PORTC=DISPLAYOFF; } //-------------------------------------------------------// //-------------------Temporizadores----------------------// //-------------------------------------------------------// void enc_timer0(void) { TCCR0 = 0x02; //Preescala 8. TIFR = 0x01; //Pone en cero en la bandera de desborde del Reloj/Contador0. sbi(TIMSK,TOIE0); //Habilitación de la interrupción por desborde del Reloj/Contador0. } void apg_timer0(void) { TCCR0 = 0x00; TIFR = 0x01; cbi(TIMSK, TOIE0); } void enc_timer1(void) { TCCR1A = 0x00;//Preescala 64. TCCR1B = 0x03; TIFR = 0x04; //Borra bandera de sobreflujo en timer1. sbi(TIMSK, TOIE1); //Habilita las interrupciones por sobreflujo en timer1. }

void apg_timer1(void) { TCCR1A = 0x00;//Stop. TCCR1B = 0x00; TIFR = 0x04; //Borra bandera de sobreflujo. cbi(TIMSK, TOIE1); //Inhabilita la interrupción. } //-------------------------------------------------------// //-----------------Interrupcion-Externa------------------// //-------------------------------------------------------// void enable_int0(void) { sbi(MCUCR,ISC00); //Flanco positivo. sbi(MCUCR,ISC01); sbi(GICR,INT0); //Habilita interrupción. sbi(GIFR,INTF0); //Limpio bandera. } void disable_int0(void) { cbi(GICR,INT0); //Inhabilita interrupción. sbi(GIFR,INTF0); //Limpio bandera. } void enable_int1(void) { sbi(MCUCR,ISC10); //Flanco positivo. sbi(MCUCR,ISC11); sbi(GICR,INT1); //Habilita interrupción. sbi(GIFR,INTF1); //Limpio bandera. } void disable_int1(void) { cbi(GICR,INT1); //Inhabilita interrupción. sbi(GIFR,INTF0); //Limpio bandera. } void enable_int2(void)

{ cbi(MCUCSR,ISC2); //Flanco positivo. sbi(GICR,INT2); //Habilita interrupción. sbi(GIFR,INTF2); //Limpio bandera. } void disable_int2(void) { cbi(GICR,INT2); //Deshabilito interrupción. sbi(GIFR,INTF2); //Limpio bandera. } //-------------------------------------------------------// //------------------------ADC----------------------------// //-------------------------------------------------------// void sensor_adlar_0(void) { u08 pv_h=0, pv_l=0; //Configuración del ADC. //Registro ADCSRA. ADCSRA=0xe6; //Registro ADMUX. ADMUX=0x07; //Registro SFIOR. SFIOR=0x00; //--------------------pv_l = ADCL; pv_h = ADCH; //--------------------y_n = convert_u08_u16(pv_h, pv_l); } //-------------------------------------------------------// //------------------------Display------------------------// //-------------------------------------------------------// // Esta sencilla función decodifica de bcd a código de siete // segmentos.

u08 numero_display(u08 numero) { switch(numero) { case 0: return 0x02; case 1: return 0x7a; case 2: return 0x14; case 3: return 0x50; case 4: return 0x68; case 5: return 0x41; case 6: return 0x21; case 7: return 0x5a; case 8: return 0x00; case 9: return 0x48; default: return 0x05; } } // Ésta función decodifica de binario a BCD. bcd binario_bcd(u16 numero) { bcd convert; convert.decimales=0x00; // Inicialización de convert.unidades=0x00; // la estructura. convert.decenas=0x00; while(numero>=100) { ++convert.decenas;

numero-=100; } while(numero>=10) { ++convert.unidades; numero-=10; } convert.decimales=numero; return convert; } //-------------------------------------------------------// //--------------------------PWM--------------------------// //-------------------------------------------------------// void config_pwm(void) //Configura el PWM. { TCCR2=0x6f; OCR2=0xff; } void pwm(u08 salida) //Salida del controlador. { OCR2=salida; } //-------------------------------------------------------// //--------------------------PID--------------------------// //-------------------------------------------------------// u16 convert_u08_u16(u08 _H, u08 _L) { return ( ( (u16)_H )