Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Diseno y Construccion de Un Sistema de C PDF
Diseno y Construccion de Un Sistema de C PDF
Facultad de Ingeniería
Escuela de Ingeniería Eléctrica
Por:
Por:
de la Facultad de Ingeniería
_________________________________
Ing. Ismael Mazón
Profesor Guía
_________________________________ _________________________________
Ing. Teodoro Willink Ing. Felipe Córdoba
Profesor lector Profesor lector
DEDICATORIA
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
BIBLIOGRAFÍA .................................................................................................................. 85
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
KP Ganancia de la planta.
P Controlador proporcional.
s Variable compleja.
proceso, a partir del cual se obtuvieron los parámetros de sintonización del controlador. Se
funcionamiento.
CAPÍTULO 1: Introducción
industriales. Entre las áreas de aplicación del control automático en procesos industriales, el
temperatura para una incubadora de huevos de aves de corral. Las incubadoras de huevos
depende una tasa alta de eclosión y por lo tanto una producción exitosa que conlleve a
contará con un sensor para medir la temperatura y un actuador para modificar el flujo de
primero diseñar el sistema, adquirir todos los elementos, materiales y circuitos integrados
1
1.1 Objetivos
incubadora.
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
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.
deseada a través de botones o alguna clase de teclado y observar la temperatura del proceso
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
particular cuente con una alarma sonora que se active cuando la temperatura alcanza
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
3
identificar el proceso y escoger el método de sintonización que considere más adecuado
1.3 Metodología
flujo de calor que proporcione una respuesta rápida ante un cambio en el valor
deseado de temperatura.
respuesta en el servomecanismo.
4
• El sistema se construyó sobre un microcontrolador Atmega16, el código se
implementación.
microcontrolador para medir la salida de tensión del sensor, una salida PWM, y
el microcontrolador.
5
CAPÍTULO 2: Desarrollo teórico
6
la variable controlada R(s ) , la señal a la salida del controlador U (s ) y la perturbación
D (s ) .
Se incluye el elemento final de control que es el elemento físico que finalmente realiza
una señal que es transferida al controlador. Los modos de control que utilizan un algoritmo
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,
Y (s) C ( s) ⋅ P( s)
M yr ( s ) = = (2-1)
R( s) 1 + C ( s) ⋅ P( s)
Y (s) P( s)
M yd ( s ) = = (2-2)
D( s ) 1 + C ( s ) ⋅ P ( s )
ecuación:
L( s ) = C ( s ) ⋅ P ( s ) (2-3)
8
2.1.2 Característica estática
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
9
La relación entre la variable controlada C y la variable manipulada M se llama
La característica dinámica hace referencia a la respuesta del sistema ante una señal en
dinámica.
respuesta de la planta aplicándole una excitación particular y a partir de esto determinar los
identificación. Una vez establecido el modelo de la planta, el segundo paso es llevar a cabo
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
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
1 t de(t )
u (t ) = K c ⋅ e(t ) + ⋅ ∫ e(τ )dτ + Td ⋅ (2-5)
Ti 0 dt
1
U ( s ) = K c ⋅ (1 + Td ⋅ s ) ⋅ 1 + ⋅ E ( s ) (2-6)
T s
i
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 .
K Kd
U ( s) = K p + i + ⋅ E ( s) (2-7)
s α ⋅ K d ⋅ s + 1
12
2.1.5.3 Controlador PID serie
T '⋅s + 1 Td '⋅s + 1
U ( s ) = K c '⋅ i ⋅ ⋅ E ( s ) (2-8)
i T '⋅ s α ⋅ Td '⋅s + 1
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
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
T '⋅s + 1 T '⋅s + 1
U ( s ) = K c '⋅ i ⋅ R ( s ) − d ⋅ Y ( s ) (2-9)
Ti '⋅s α ⋅ Td '⋅s + 1
Se puede ver que se tienen dos controladores, uno PI que se denomina el compensador
compara con el PID serie es fácil comprobar que el comportamiento del lazo de control es
deseado.
14
Figura 2.5. Controlador PID industrial.
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:
16
Figura 2.7. Red generalizada del proceso térmico.
Del análisis de la figura 2.7 se desprende la función de transferencia del proceso, dada
17
Rt 1
T ( s ) = ⋅ qi ( s ) + ⋅ Ta ( s ) (2-10)
Rt ⋅ Ct ⋅ s + 1 Rt ⋅ Ct ⋅ s + 1
Rt
T ( s ) = ⋅ qi ( s ) (2-11)
Rt ⋅ Ct ⋅ s + 1
1
T ( s ) = ⋅ Ta ( s ) (2-12)
R
t ⋅ C t ⋅ s + 1
18
2.2 Sistemas de control en tiempo discreto
Un sistema de control en tiempo discreto es similar al caso continuo, salvo por el hecho
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
19
Figura 2.6. Sistema de control en tiempo discreto.
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
y (t ) de la figura 2.8
20
Figura 2.7. Señal discreta.
21
d n y (t ) dy (t ) d mu (t ) du (t )
an ⋅ n
+ ... + a1 ⋅ + a 0 ⋅ y (t ) = bm ⋅ m
+ ... + b1 ⋅ + b0 ⋅ u (t ) (2.10)
dt dt dt dt
diferencias:
y k − n → z − n ⋅ Y (z ) (2.12)
Y ( z ) bm ⋅ z − m + ... + b1 ⋅ z −1 + b0
= (2.13)
U ( z ) a n ⋅ z − n + ... + b1 ⋅ z −1 + b0
Para diseñar un regulador discreto hay básicamente dos enfoques: El primero es diseñar
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
pendiente de la recta que pasa por dos muestras consecutivas, con lo cual se tiene:
dy (t ) y − y k −1
→ k (2.14)
dt T
1 − z −1
s ⋅ Y ( s) → ⋅ Y (z) (2.15)
T
1 − z −1
suficiente con sustituir las s por .
T
continua:
U ( s) 1
= K ⋅ 1 + + s ⋅ Td (2.16)
E ( s) Ti ⋅ s
1 − z −1
Sustituyendo las s por y resolviendo, se obtiene la función de transferencia del
T
PID discreto:
T T T −1 Td
K ⋅ 1 + + d − 1 + 2 ⋅ d ⋅z + ⋅ z −2
U ( z) Ti T T T
= −1
(2.17)
E ( z) 1− z
23
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 (2.19)
Ti T
T (2.20)
b1 = − K ⋅ 1 + 2 ⋅ d
T
Td (2.21)
b2 = K ⋅
T
24
2.3 Microcontrolador Atmega16
Atmega16.
posee un conjunto reducido de instrucciones (RISC) y tiene memoria separada para datos e
que le permiten interactuar con el mundo exterior, como lo son un convertidor analógico a
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
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
conforman.
nótese que están nombrados de R0 a R31 y están divididos en dos partes de 16 registros
direccionamiento indirecto de memoria. Cuando se usan con este propósito estos punteros
sus siglas en inglés: program counter) el cual sigue la ejecución del programa. Una vez
28
2.3.3.3 Registro de banderas (SREG)
El registro de banderas (SREG por sus siglas en inglés: Status Register) contiene
la CPU. Esta información puede ser usada para alterar el flujo corriente del programa a
Ésta bandera habilita las interrupciones globales de la máquina. Un uno en esta bandera
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
Ésta bandera indica un acarreo del bit 3 al bit 4 en algunas operaciones aritméticas. Ésta
S: Bandera de signo.
La bandera de signo es siempre una OR exclusiva entre las banderas N y V. Estas dos
V: Bandera de sobreflujo.
a dos.
N: Bandera de Negativo.
aritméticas.
30
Z: Bandera de cero.
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
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.
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
32
Figura 2.14. Mapa de memoria.
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
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
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).
35
Para atender una interrupción la bandera I del registro de banderas (SREG) debe estar en
bajo, para no permitir que otras interrupciones puedan ser atendidas. El flujo del programa
por el vector de interrupción. La subrutina termina con la instrucción RETI la cual recupera
2.3.6 Periféricos
encapsulado y accesibles desde el exterior del microcontrolador. Cada uno de estos pines
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
El convertidor analógico a digital del Atmega16 tiene una resolución de 10 bits, posee
37
Figura 2.17. Convertidor analógico a digital del Atmega16.
Los voltajes de referencia externos se introducen mediante los pines AREF y AVCC.
38
2.3.6.3 Temporizadores
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
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:
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
OCFn.
cambio en esas terminales tendrá como resultado una lectura del registro
ICFn.
De la misma forma existen tres formas de detectar eventos con el fin de actuar en base a
ellos:
40
• Interrupción: Para que los eventos generen interrupciones, éstos se deben
interrupciones globales.
ejemplo.
Temporizador/Contador 0
control TCCR0.
Temporizador/Contador 1
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.
Temporizador/Contador 2
43
El registro TCNT2 realiza el conteo. El registro OCR2 es usado para ser comparado con
TCCR2.
44
CAPÍTULO 3. Implementación del sistema
valor deseado introducido por el operador, realizar las operaciones lógicas y aritméticas
PWM.
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
45
• Down: Esta entrada digital se usa para decrementar el valor deseado de
El sistema también cuenta con cuatro salidas, tres salidas digitales y usa salida PWM, la
cuales se explican a continuación:
46
3.2 Diseño del sistema
sistema, así como otras importantes decisiones de diseño con el fin de implementar el
3.2.1 Microcontrolador
Para escoger un microcontrolador a emplear en el diseño hay que tomar en cuenta una
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
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,
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
Para controlar la tasa de flujo de calor entregada por los tres bombillos se utilizó un relé
figura 3.3.
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
3.2.3 Sensor
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.
112 11.2
298 29.8
529 52.9
3.2.4 Visualizador
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
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
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
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
1 ⋅ segundo / 25 ⋅ cuadros
= 13.3 3 ms (3-1)
3 ⋅ visualizadores
3.2.5 Alarma
Para dar aviso de temperaturas peligrosas se utilizó un sistema de alarma. La idea es dar
PNP se debe a que se desconocía de antemano las exigencias de carga del zumbador.
54
Figura 3.7. Sistema de alarma.
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
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:
madera y el metal. El metal se descartó por su alto costo; en cambio se utilizó madera, que
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
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
algo fundamental para la correcta incubación de los huevos. También la ventilación busca
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
segundos) se obtuvieron los datos con los cuales se elaboró la siguiente gráfica.
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
0.847
P( s) = (3-2)
480.0 s + 1
3.5 Sintonización
Kp
P( s) = (3-3)
Ts + 1
59
K c ⋅ (T d ⋅ s + 1) ⋅ (Ti ⋅ s + 1)
C ( s) = (3-4)
Ti s
K c ⋅ K p (Td ⋅ s + 1) ⋅ (Ti ⋅ s + 1)
L( s ) = P ( s )C ( s ) = (3-5)
Ti s ⋅ (T ⋅ s + 1)
T = Ti (3-6)
Td = 0 (3-7)
K p ⋅ Kc
L( s ) = (3-8)
Ti ⋅ s
60
Y la siguiente función de transferencia de lazo cerrado:
1
M yr = (3.9)
Ti
⋅ s +1
K p ⋅ Kc
constante de tiempo está determinada por la ganancia del controlador y el tiempo integral.
T
Tc = (3.10)
K p ⋅ Kc
T
Kc = (3-11)
K p ⋅ Tc
Ti = T (3-12)
61
Td = 0 (3-13)
T
Kc = (3-14)
K p ⋅ Tc
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
constante es:
T = 300 s (3-15)
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
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
interrupciones. La figura 3.11 corresponde a los diagramas de flujos de cada una de estas
tres subrutinas:
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
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
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
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
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
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
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
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”
DDRA=0x7f;
DDRB=0x01;
DDRC=0xff;
DDRD=0x80;
port_initiate().
68
void port_initiate(void) //Inicialización de puertos.
PORTA=0xff;
PORTB=0x00;
PORTC=DISPLAYOFF;
enc_timer1().
void enc_timer0(void) {
TCCR0 = 0x02; //Preescala 8.
TIFR = 0x01; //Pone en cero en la bandera de desborde del Reloj/Contador0.
69
void enc_timer1(void) {
TCCR1A = 0x00;//Preescala 64.
TCCR1B = 0x03;
TIFR = 0x04; //Borra bandera de sobreflujo en timer1.
La función enc_timer0() configura el temporizador cero con una preescala de ocho, para
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
void enable_int0(void)
{
sbi(MCUCR,ISC00); //Flanco positivo.
sbi(MCUCR,ISC01);
70
void enable_int1(void)
{
sbi(MCUCR,ISC10); //Flanco positivo.
sbi(MCUCR,ISC11);
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.
se puede ver que la interrupción INT0 tendrá como resultado un incremento en el valor
una interrupción INT1, tendrá como resultado una disminución del parámetro
está visualizando en el conjunto de los tres visualizadores, para ello se utiliza la variable
71
estado al siguiente, y el estado correspondiente será usado por la subrutina de atención a
que es el registro que controla la modulación del ancho de pulso, es por defecto 0xff.
72
SIGNAL(SIG_OVERFLOW1) // Sobreflujo en timer1.
{
apg_timer1(); // Se inhabilitan interrupciones y se borra la bandera de sobre flujo.
Read_ADC=TRUE;
Read_ADC la constante TRUE, eso por una razón: para informar al programa principal de
A continuación se convierte el valor de y_n en una estructura tipo bcd. La estructura tipo
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.
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
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
del controlador:
74
if( (y_n > 400) || (y_n < 200) )
{on_alarma();}
else
{off_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,
75
3.8 Prototipo final
uno de los elementos que integran el sistema: tres botones, los visualizadores, el relé, el
Se puede ver un conjunto de cables con una cubierta protectora que van desde el
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
servomecanismo. Las pruebas se realizaron para valores de temperatura entre 35.5ºC y 38.5
corral.
En la figura 3.26 se muestra la respuesta del sistema para un valor deseado de 36.5ºC.
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
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
La figura 3.28 y 3.29 corresponden a pruebas realizadas pero con una temperatura inicial
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
minutos.
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,
80
CAPÍTULO 4: Conclusiones y recomendaciones
Dentro de las principales conclusiones obtenidas a partir del desarrollo del proyecto y de
81
transferencia de lazo abierto y la función de transferencia de lazo cerrado para el
• Se determinó que la acción del controlador debe ser de tipo inversa; ya que un
controlador.
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
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
83
conmutación como un relé de estado sólido o un tiristor de potencia en lugar de
un elemento electromecánico.
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,
84
BIBLIOGRAFÍA
Libros
2006.
Flash. Atmega16A”.
2. NTE Electronics, Inc. “NTE3052 thru NTE3055 0.3” Single Digit Numeric
85
4. National Semiconductor. “LM35. Precision Centigrade Temperature Sensors”,
November 2000.
BC548, A, B, C”.
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
//Valor deseado
//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
#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----------------------//
//-------------------------------------------------------//
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();
}
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();
}
Read_ADC=TRUE;
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 <avr/io.h>
#include <avr/interrupt.h>
#include <compat/deprecated.h>
#include "include.h"
//-------------------------------------------------------//
//-------------------------Main--------------------------//
//-------------------------------------------------------//
int main(void) {
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;
//Salida.
u_1=u_0;
//Temperaturas peligrosas.
}
}
return TRUE;
}
//-------------------------------------------------------//
//-----------------------Puertos-------------------------//
//-------------------------------------------------------//
void enc_timer0(void) {
TCCR0 = 0x02; //Preescala 8.
TIFR = 0x01; //Pone en cero en la bandera de 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.
//-------------------------------------------------------//
//-----------------Interrupcion-Externa------------------//
//-------------------------------------------------------//
void enable_int0(void)
{
sbi(MCUCR,ISC00); //Flanco positivo.
sbi(MCUCR,ISC01);
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);
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) {
pv_l = ADCL;
pv_h = ADCH;
//---------------------
//-------------------------------------------------------//
//------------------------Display------------------------//
//-------------------------------------------------------//
default:
return 0x05;
}
}
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--------------------------//
//-------------------------------------------------------//
//-------------------------------------------------------//
//--------------------------PID--------------------------//
//-------------------------------------------------------//
u16 convert_u08_u16(u08 _H, u08 _L)
{
void setpoint(void)
{
r_n=(u16)(SetPoint*10);
sp=binario_bcd(r_n);
return;
}
void function_b0(void)
{
coef_b0=binario_bcd( (u16)(b_0*100) );
return;
}
void function_b1(void)
{
coef_b1=binario_bcd( (u16)(b_1*100) );
return;
}
void function_b2(void)
{
coef_b2=binario_bcd( (u16)(b_2*100) );
return;
}
//-------------------------------------------------------//
//-------------------------Alarma------------------------//
//-------------------------------------------------------//
//-------------------------------------------------------//
//----------------------Prototipos-----------------------//
//-------------------------------------------------------//
// Archivo: tipos.h
// Archivo: variables.h
//-------------------------------------------------------//
//-----------------Variables-Globales--------------------//
//-------------------------------------------------------//
volatile bcd sp, pv, coef_b0, coef_b1, coef_b2;