Anda di halaman 1dari 24

c  

 


c  

Profesor: ILDEBERTO DE LOS SANTOS RUIZ

ING. ELECTRONICA 8vo semestre


Gómez Valdez Jefferson Alberto
Rosales Salgado José Edgar
Pérez Alvarado Iván Yashir
Pola López Luis Alejandro


 


 cc 

Dado el amplio uso de los controladores PID en el ámbito industrial (control de potencia en motores de inducción,
control de nivel, caudal y presión en procesos químicos entre otros), el uso de microcontroladores para el desarrollo de
este tipo de aplicaciones ha tomado fuerza gracias a la incorporación de lenguajes de alto nivel que facilitan
ampliamente este tipo de implementaciones, además de los bajos costos de adquisición de estos dispositivos,
distribución de software de desarrollo gratuito y amplia información en la Internet.

Este trabajo tiene como propósito mostrar al lector un método de diseño práctico y sencillo en el desarrollo de
controladores digitales PID implementados en microcontroladores PIC. Para tal fin, se tomara como ejemplo un sistema
de calefacción (LM35) al cual se le realizara inicialmente un modelamiento basado en el método de curva de reacción,
calculo de parámetros y/o constantes de control PID mediante técnica de sintonización ZieglerʹNichols usando matlab y
por último se mostrara la metodología de implementación de este controlador en un microcontrolador PIC18F4520A,
utilizando como herramienta de validación el software de simulación ISIS Proteus, y el programa MATLAB.

c  c

c!"#$cc  % c%  c & %


% %  &'$

a  El LM35 es un sensor de temperatura con una precisión calibrada de 1ºC y un rango que abarca desde -55º
a +150ºC.

El sensor se presenta en diferentes encapsulados pero el mas común es el to-92 de igual forma que un típico transistor
con 3 patas, dos de ellas para alimentarlo y la tercera nos entrega un valor de tensión proporcional a la temperatura
medida por el dispositivo. Con el LM35 sobre la mesa las patillas hacia nosotros y las letras del encapsulado hacia arriba
tenemos que de izquierda a derecha los pines son: VCC - Vout - GND.
La salida es lineal y equivale a 10mV/ºC por lo tanto:

]Y +1500mV = 150ºC
]Y +250mV = 25ºC
]Y -550mV = -55ºC

  
  : Para hacernos un termómetro lo único que necesitamos es
un voltímetro bien calibrado y en la escala correcta para que nos muestre el
voltaje equivalente a temperatura. El funciona en el rango de alimentación
comprendido entre 4 y 30 voltios.

Podemos conectarlo a un conversor Analógico/Digital y tratar la medida


digitalmente, almacenarla o procesarla con un µControlador o similar.

 : El sensor de temperatura puede usarse para compensar un dispositivo de medida sensible a la temperatura
ambiente, refrigerar partes delicadas del robot o bien para loggear temperaturas en el transcurso de un trayecto de
exploración.

c&  

Un PID (Proporcional Integral Derivativo) es un mecanismo de control por realimentación que calcula la
desviación o error entre un valor medido y el valor que se quiere obtener, para aplicar una acción correctora
que ajuste el proceso. El algoritmo de cálculo del control PID se da en tres parámetros distintos: el
proporcional, el integral, y el derivativo. El valor Proporcional determina la reacción del error actual. El Integral
genera una corrección proporcional a la integral del error, esto nos asegura que aplicando un esfuerzo de
control suficiente, el error de seguimiento se reduce a cero. El Derivativo determina la reacción del tiempo en
el que el error se produce. La suma de estas tres acciones es usada para ajustar al proceso vía un elemento de
control como la posición de una válvula de
control o la energía suministrada a un
calentador, por ejemplo. Ajustando estas tres
variables en el algoritmo de control del PID,
el controlador puede proveer un control
diseñado para lo que requiera el proceso a
realizar. La respuesta del controlador puede
ser descrita en términos de respuesta del
control ante un error, el grado el cual el
controlador llega al "set point", y el grado de oscilación del sistema. Nótese que el uso del PID para control no
garantiza control óptimo del sistema o la estabilidad del mismo. Algunas aplicaciones pueden solo requerir de
uno o dos modos de los que provee este sistema de control. Un controlador PID puede ser llamado también
PI, PD, P o I en la ausencia de las acciones de control respectivas. Los controladores PI son particularmente
comunes, ya que la acción derivativa es muy sensible al ruido, y la ausencia del proceso integral puede evitar
que se alcance al valor deseado debido a la acción de control.

"(  
Para el correcto funcionamiento de un controlador PID que regule un proceso o sistema se necesita, al menos:

1.Y Un sensor, que determine el estado del sistema (termómetro, caudalímetro,manómetro, etc).
2.Y Un controlador, que genere la señal que gobierna al actuador.
3.Y Un actuador, que modifique al sistema de manera controlada (resistencia eléctrica, motor, válvula, bomba, etc).
El sensor proporciona una señal analógica o digital al controlador, la cual representa el   

 en el que
se encuentra el proceso o sistema. La señal puede representar ese valor en tensión eléctrica, intensidad de
corriente eléctrica o frecuencia. En este último caso la señal es de corriente alterna, a diferencia de los dos
anteriores, que son con corriente continua.

El controlador lee una señal externa que representa el valor que se desea alcanzar. Esta señal recibe el
nombre de punto de consigna (o punto de referencia), la cual es de la misma naturaleza y tiene el mismo
rango de valores que la señal que proporciona el sensor. Para hacer posible esta compatibilidad y que, a su
vez, la señal pueda ser entendida por un humano, habrá que establecer algún tipo de interfaz(HMI-Human
Machine Interface), son pantallas de gran valor visual y fácil manejo que se usan para hacer más intuitivo el
control de un proceso.

El controlador resta la señal de punto actual a la señal de punto de consigna, obteniendo así la señal de error,
que determina en cada instante la diferencia que hay entre el valor deseado (consigna) y el valor medido. La
señal de error es utilizada por cada uno de los 3 componentes del controlador PID. Las 3 señales sumadas,
componen la señal de salida que el controlador va a utilizar para gobernar al actuador. La señal resultante de
la suma de estas tres se llama variable manipulada y no se aplica directamente sobre el actuador, si no que
debe ser transformada para ser compatible con el actuador que usemos.

Las tres componentes de un controlador PID son: parte roporcional, acción ntegral y acción erivativa. El
peso de la influencia que cada una de estas partes tiene en la suma final, viene dado por la constante
proporcional, el tiempo integral y el tiempo derivativo, respectivamente. Se pretenderá lograr que el bucle de
control corrija eficazmente y en el mínimo tiempo posible los efectos de las perturbaciones.

 )  

La parte proporcional consiste en el producto entre la señal de error y la constante proporcional como para
que hagan que el error en estado estacionario sea casi nulo, pero en la mayoría de los casos, estos valores solo
serán óptimos en una determinada porción del rango total de control, siendo distintos los valores óptimos
para cada porción del rango. Sin embargo, existe también un valor límite en la constante proporcional a partir
del cual, en algunos casos, el sistema alcanza valores
superiores a los deseados. Este fenómeno se llama
sobreoscilación y, por razones de seguridad, no debe
sobrepasar el 30%, aunque es conveniente que la parte
proporcional ni siquiera produzca sobreoscilación. Hay una
relación lineal continua entre el valor de la variable
controlada y la posición del elemento final de control (la
válvula se mueve al mismo valor por unidad de desviación).
La parte proporcional no considera el tiempo, por lo tanto, la
mejor manera de solucionar el error permanente y hacer que
el sistema contenga alguna componente que tenga en cuenta
la variación respecto al tiempo, es incluyendo y configurando
las acciones integral y derivativa.

La fórmula del proporcional esta dada por:

El error, la banda proporcional y la posición inicial del elemento final de control se expresan en tanto por uno.
Nos indicará la posición que pasará a ocupar el elemento final de control
Ejemplo: Cambiar la posición de una válvula (elemento final de control) proporcionalmente a la desviación de
la temperatura (variable) respeto al punto de consigna (valor deseado).



El modo de control Integral tiene como propósito disminuir y eliminar el error en estado estacionario,
provocado por el modo proporcional. El control integral actúa cuando hay una desviación entre la variable y el
punto de consigna, integrando esta desviación en el tiempo y sumándola a la acción proporcional. El   es
integrado, lo cual tiene la función de promediarlo o sumarlo por un período determinado; Luego es
multiplicado por una constante . Posteriormente, la respuesta integral es adicionada al modo Proporcional
para formar el control P + I con el propósito de obtener una respuesta estable del sistema sin error
estacionario.

El modo integral presenta un desfasamiento en la respuesta


de 90º que sumados a los 180º de la retroalimentación (
negativa ) acercan al proceso a tener un retraso de 270º,
luego entonces solo será necesario que el tiempo muerto
contribuya con 90º de retardo para provocar la oscilación
del proceso. <<< la ganancia total del lazo de control debe
ser menor a 1, y así inducir una atenuación en la salida del
controlador para conducir el proceso a estabilidad del
mismo. >>> Se caracteriza por el tiempo de acción integral
en minutos por repetición. Es el tiempo en que delante una
señal en escalón, el elemento final de control repite el
mismo movimiento correspondiente a la acción
proporcional.

El control integral se utiliza para obviar el inconveniente del offset (desviación permanente de la variable con
respecto al punto de consigna) de la banda proporcional.

La formula del integral esta dada por:

Ejemplo: Mover la válvula (elemento final de control) a una velocidad proporcional a la desviación respeto al
punto de consigna (variable deseada).

 

La acción derivativa se manifiesta cuando hay un cambio en el valor absoluto del error; (si el error es
constante, solamente actúan los modos proporcional e integral).

El   es la desviación existente entre el punto de medida y el valor consigna, o "   ".

La función de la acción derivativa es mantener el error al mínimo corrigiéndolo proporcionalmente con la


misma velocidad que se produce; de esta manera evita que el error se incremente.
Se deriva con respecto al tiempo y se multiplica por una constante y luego se suma a las señales anteriores
(P+I). Es importante adaptar la respuesta de control a los cambios en el sistema ya que una mayor derivativa
corresponde a un cambio más rápido y el controlador puede responder acordemente.

La fórmula del derivativo esta dada por:

El control derivativo se caracteriza por el tiempo de acción derivada en minutos de anticipo. La acción
derivada es adecuada cuando hay retraso entre el movimiento de la válvula de control y su repercusión a la
variable controlada.

Cuando el tiempo de acción derivada es grande, hay


inestabilidad en el proceso. Cuando el tiempo de acción
derivada es pequeño la variable oscila demasiado con
relación al punto de consigna. Suele ser poco utilizada debido
a la sensibilidad al ruido que manifiesta y a las complicaciones
que ello conlleva.

El tiempo óptimo de acción derivativa es el que retorna la


variable al punto de consigna con las mínimas oscilaciones

Ejemplo: Corrige la posición de la válvula (elemento final de


control) proporcionalmente a la velocidad de cambio de la
variable controlada.

La acción derivada puede ayudar a disminuir el rebasamiento de la variable durante el arranque del proceso.
Puede emplearse en sistemas con tiempo de retardo considerables, porque permite una repercusión rápida
de la variable después de presentarse una perturbación en el proceso.

& 
P constante de proporcionalidad: se puede ajustar como el valor de la ganancia del controlador o el
porcentaje de banda proporcional. Ejemplo: Cambia la posición de la válvula proporcionalmente a la
desviación de la variable respecto al punto de consigna. La señal P, mueve la válvula siguiendo fielmente los
cambios de temperatura multiplicados por la ganáncia.

I constante de integración: indica la velocidad con la que se repite la acción proporcional.

D constante de derivación: hace presente la respuesta de la acción proporcional duplicándola, sin esperar a
que el error se duplique. El valor indicado por la constante de derivación es el lapso de tiempo durante el cual
se manifestará la acción proporcional correspondiente a 2 veces el error y después desaparecerá. Ejemplo:
Mueve la válvula a una velocidad proporcional a la desviación respeto al punto de consigna. La señal I, va
sumando las áreas diferentes entre la variable y el punto de consigna repitiendo la señal proporcional según el
tiempo de acción derivada (minutos/repetición).

Tanto la acción Integral como la acción Derivativa, afectan a la ganancia dinámica del proceso. La acción
integral sirve para reducir el error estacionario, que existiría siempre si la constante Ki fuera nula. Ejemplo:
Corrige la posición de la válvula proporcionalmente a la velocidad de cambio de la variable controlada. La
señal d, es la pendiente (tangente) por la curva descrita por la variable.

La salida de estos tres términos, el proporcional, el integral, y el derivativo son sumados para calcular la salida
del controlador PID. Definiendo u (t) como la salida del controlador, la forma final del algoritmo del PID es:


%  *c  c&   * +& , c-&%

En lazo abierto, muchos procesos pueden definirse según la siguiente función de transferencia:

Donde los coeficientes K0 , T0 y Y0 se obtienen de la respuesta del sistema en lazo abierto a una entrada escalón. Se
parte del sistema estabilizado en y(t) =y 0 para u(t)=u 0 . Se aplica una entrada escalón de u0 a u1 (el salto debe
estar entre un 10% y un 20% del valor nominal) y se registra la respuesta de la salida hasta que se estabilice en el
nuevo punto de operación [2].

Los parámetros se pueden obtener de la respuesta mostrada en la Figura 1:









Según Ziegler-Nichols, la relación de estos coeficientes con los parámetros del controlador son:
c&  + &

La función de transferencia para el controlador PID digital se convierte en [3]:

La función de transferencia discreta (6), también puede ser representada como [2]:

Donde:

Existen distintas posibilidades de la realización práctica de un controlador PID, una de las mas habituales es la realización
en paralelo:

&+   +c   cc& 



El algoritmo utilizado para programar el PIC se muestra en la Figura 3. El muestreo (T) debe ser mayor que el tiempo
de establecimiento del sistema en lazo abierto. En el modelo Ziegler-Nichols se toma un valor T < ʏ0/4 .

Para la simulación del controlador PID se utilizara el software ISIS Proteus. Este software ofrece el modelo
esquemático de un sistema de calefacción denominado OVEN, al cual se le pueden variar sus características
funcionales tales como: Temperatura Ambiente de trabajo, resistencia térmica, constante de tiempo de
establecimiento, constante de tiempo de calentamiento, coeficiente de temperatura y Potencia de calentamiento.
 &  &% %  c& "cc . /) 0

Para facilidades de simulación se establecerán los siguientes valores de parámetros funcionales del modelo OVEN:

Temperature Ambient (°C)= 25


Thermal Resistence to Ambient (°C/W)= 0.7
Oven Time Constant (sec)= 10
Heater Time Constant (sec)= 1
Temperature coefficient (V/°C)= 1
Heating Power (W)= 120

El modelo esquemático OVEN contiene un terminal sensor T que entrega un voltaje proporcional a la
temperatura del sistema. De acuerdo a los parámetros establecidos anteriormente, este terminal entregara
1V/°C, es decir, que para una temperatura de 100°C, el terminal T entregara 100V.

Para obtener la respuesta del sistema en lazo abierto ante una entrada escalón (curva de reacción), se utiliza el sistema
de análisis interactivo de ISIS Proteus Interactive Analysis (Graph Mode Tool), el cual interactúa con el sistema OVEN
mediante el uso de un Voltage Probe 1 OV1(T), según se muestra en la Figura 4. Observar que para realizar la entrada
escalon de 0V a 2V se utiliza un interruptor SW1.

De la recta de máxima pendiente se deducen los parámetros 0 0 ,ɶ ʏ y 0 k definidos por el análisis en lazo
abierto de Ziegler-Nichols.
Por tanto el modelo del sistema de calefacción queda definido así:

Los parámetros K p , T i y T d se calculan según la Regla de Sintonización de Ziegler-Nichols basada en la


respuesta al escalon [1]:

Reemplazando los valores de K p , T i y T d en las ecuaciones dadas en (8), y estableciendo un periodo de muestreo
T=0.1s según criterio 4 / 0 ʏ< T , los parámetros del controlador discreto son:



 &  c  c&  + &   cc& . /) 0

Consideraciones Preliminares

ƒ Se requiere de un conversor Análogo/Digital para ingresar el voltaje entregado por el sensor T del modelo OVEN.
Dado que dicho terminal entrega 1V/°C, se utiliza un divisor de voltaje para adecuar la señal del sensor a
niveles permitidos por el conversor A/D; en este caso se utiliza un divisor de voltaje con factor 100, es decir, que para
una temperatura de 100°C (100V) el conversor recibirá 1V.

ƒ El control se realiza mediante una señal PWM proporcional a la señal generada por el controlador. Por tanto el uso
del microcontrolador PIC18F4520 es pertinente para la aplicación descrita.
 
+ %1  cc &% &c   %

c%2










 
c c  


 
  
)3
 &  &% % 

 " c &"c 4 %"  c  &% % 

1.- Como primer paso necesito determinar la función de transferencia del sistema para eso se ha de tomar las siguientes
mediciones:

) (
 0,10,20,30,40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200,210
)( 15,16,18,20,22,24,26,28,29,31,33,34,36,37,38,40,41,42,43,44,44,45

2.- Al obtener los datos pertinentes, procederemos a utilizar MATLAB para la obtención del modelo matemático.

56,,,,,,,,,,,,,,,,,,,,,,,,,,c +&2,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65


t = [0,10,20,30,40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200,210];
v = 5*ones(size(t));
T = [15,16,18,20,22,24,26,28,29,31,33,34,36,37,38,40,41,42,43,44,44,45];

% Graficamos nuestro sistema en función del tiempo y la temperatura obtenida.


xlabel('Tiempo (Seg) ')
ylabel('Temperatura ( °C)')
title('Comportamiento del Sistema')
plot(t,T)



3.- Una vez obtenido los datos pertinentes procederemos a utilizar un toolbox que se encuentra en MATLAB ͞IDENT͟
para la identificación de sistemas.
Modelado de salida

Respuesta transitoria

Se obtendrá la función de transferencia del sistema con la estructura siguiente, que pertenece a función de primer
orden:

;  
   


"c 4 %"  c  &% % 



 
;  
   

56,,,,,,,,,,,,,,,,,,,,,,,,,,,,c +&2,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65

H = tf(13.342,[113.96 1])

Â
  

V 
7
  7(8
 7 9 
  (  ) 
  (   

 (
  : ;% %&<   =( ( &2 )  
 
  )
 =( 3 ) 
  ( 
   
>
%  








56,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, ,,,,,,,,,,,,,,c +&2,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65

C=tf([7.7 1],[1 0])*.1



  
5


c ?
.c@50

   


) 
( >

%"  A %*

¨   
 
  

¨ 
     
 

 ¨    






 
c + & c%2 putc('C');
putc(KIM);
 //output_low(PIN_D4);
winclude "PIC USB.h" break;
winclude <usb_cdc.h> // declaro librerias USB case 'D':
//output_high(PIN_D4);
putc('D');
// Descriptores del dispositivo USB. //output_low(PIN_D4);
//*********************** configuracion y declaraciones break;
**************** }
int8 KP, KI, Referencia, Temperatura; }
}
}
/* Funciones */
void Inicializar_Variables(); void main()
void Inicializar_Funciones(); {
void Verificar_USB(); enable_interrupts(INT_RDA);
void Recepcion(); enable_interrupts(GLOBAL);
//output_high(PIN_D4);
wint_RDA //TODO: User Code
void RDA_isr(void) Inicializar_Funciones();
{ while(!usb_cdc_connected()){}
char dato = getc(); while(TRUE){
switch(dato) { usb_task();
case 'D': Verificar_USB();
//output_low(PIN_D4); }
Temperatura = getc(); }
usb_cdc_putc(Temperatura);
Referencia = getc();
usb_cdc_putc(Referencia);
c + & c 
KP = getc(); 
usb_cdc_putc(KP); B(
C  >DC
KI = getc(); B(
CE
F>C
usb_cdc_putc(KI); B(7F .0
//output_low(PIN_D4); B(7F .20
break; B(7F . 0
} B(
G&c >H
} 
56,,,,,,,,,,,,,,,,,A+ ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65
void Inicializar_Funciones() (
( ?I
{ DI
usb_init(); 7?'I
usb_task(); J)(I
usb_wait_for_enumeration(); 7  @ ?@@?@)@K ?>LJ@K ?>I
} 56,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65

void Verificar_USB() 56,,,,,,,,,,,,,,,,,,,,,,"( 
c  ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65
{ BF  
int KPM,KIM,Referencia;  
  F. 
0
char dato; M
if(usb_enumerated()) // PicWinUSB ha sido enumerado F.J'$'J0I
{ ?76>',)6>'I
if (usb_cdc_kbhit()) // Existen datos ?.N..K NK 06 0,.K 6 00I
{ ?H'O'.GO0I
dato = usb_cdc_getc(); F)PF
(9..J0.00I
switch(dato) { ?I
case 'A': ? I
//output_high(PIN_D4); Q
Referencia = usb_cdc_getc(); 56,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65
putc('A'); 
putc(Referencia);  
 c.0M
//output_low(PIN_D4); F
FD.0I
break;
9F(.0I
case 'B': )(?
F
.0I
//output_high(PIN_D4); )?)(5>#I
KPM= usb_cdc_getc(); Q
putc('B'); 
putc(KPM);  
 )F .0M
//output_low(PIN_D4); )7.
F)(@CR7    7  V
R    )( 
break; V>'7C@7@)0I
case 'C':
9F.0I
//output_high(PIN_D4); Q
KIM = usb_cdc_getc(); 
56,,,,,,,,,,,,,,,,c  7,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65 M
 
&(F7.0M 
F  :9.@0I
DI )7.
F)(@C  C0I
' S'T@ F I 
F  :9.:@0I
E@F @:?LI )7.
F)(@CV
C@F 0I      55 )  V   
  &c 
  S#T? S'TI55 ( 

 V 
 ST?I55    S'T? STI
 ST?I  ST? STI
 ST?I  ST? STI
7 .E?IEG#IENN0  ST?F I
M :NNI
?E
F.0I Q
F ?,#!I55c  
 
7.F H?UU F G?055c )=(   ( M
V  7.??WBW0
M   )I

F  :9.$@0I E,,I
)7.
F)(@C+
cC0I Q

F  :9.:@0I Q
)7.
F)(@CV
C@F 0I      55 )  V    
&c  )
 ST? STI55 ( 

 V  :?LI
 ST? STI 
 ST?F I  F ?. S#T6N S'T6N ST6N ST6N
:NNI ST0I
Q  FK ? F 5>I
 7. FK H0
M M
7.??WBW0 )7.
F)(@CR7   
C0I55 )/&c 
  )I 
9F.'0I
E,,I 
F)(.WR7W0I
Q Q
Q 
 M
) )7.
F)(@CR7+  )  RK ?V>'7C@ FK 0I
:?LI K ? FK I
 F ?. ST6N ST6N ST0I 
9F.'0I
7. F H0 
F)(.WR7W0I
M Q
)7.
F)(@CR7   
C0I55 )/&c  Q

9F.'0I 56,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65

F)(.WR7W0I 56,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,c  K ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65
Q  
&(FK .0M
 DI
M E@F @:?LI
)7.
F)(@CR7(7RV
C@ F 0I ' F @ S$TI
7? F I 7  FK I

9F.'0I  

F)(.WR7W0I 
Q  ST?I55  
Q  ST?I
56,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65  ST?I
  S'T?I
56,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,c  K ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65  S#T?I
 
&(FK .0M 7 .E?IEGJIENN0
DI M
E@F @:?LI ?E
F.0I
' F @ S$TI F ?,#!I55c  

7  FK I 7.F H?UU F G?055c )=(   (
  V 
 M
 ST?I55   
F  :9.$@0I
 ST?I )7.
F)(@C  C0I
 ST?I 
F  :9.:@0I
 S'T?I )7.
F)(@CV
C@F 0I      55 )  V   
 S#T?I &c 
7 .E?IEGJIENN0  S#T? S'TI
M  S'T? STI
?E
F.0I  ST? STI55 ( 

 V 
F ?,#!I55c  
  ST? STI
7.F H?UU F G?055c )=(   (  ST?F I
V  :NNI
Q M
 EI
M Q
7.??WBW0  
NNI
  )I 
9F(.0I
E,,I Q
Q Q
Q 56,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65
 
) 56,,,,,,,,,,,,,,,,,,&    ( %,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65
:?LI BF 
  
 F. 
0
 F ?. S#T6N S'T6N ST6N ST6N M
ST0I K @K I
 FK ? F 5>I D
 ?.0I
7. FK H0 PD.
 0M
M WW
)7.
F)(@CR7   
C0I55 )/&c  7?.0I

9F.'0I EI

F)(.WR7W0I W2W
Q K ?.0I
 K ?K 6>'JI
M EI
)7.
F)(@CR7+ RK ?V>'7C@ FK 0I WcW
K ? FK I K ?.0I

9F.'0I K ?K 6>'JI

F)(.WR7W0I EI
Q W W
Q 55 ()(FDD. Fc$0I
56,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65 )(..!0.)(HH00I
 )(.70I
56,,,,,,,,,,,,,,,,,- 

,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65 )(..!0.K 6$>J00I
 

.0M )(..!0.K 6$>J00I
J 
I 55 ()(F P. Fc$0I
 
?I EI
PD.0 Q
M Q
56,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65 56,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65
 56,,,,,,,,,,,,,,,c 
   ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65
56,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65 BFcc 
7.)(.)F#00  
cc F. 
0
M M
PD.)(.)F#00I  c.0I
7.( G0 Q
M 56,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65
( NNI  
.0M

F)(.CR7C0I ()F
F) .XA%%FA "0I

 ()F
. cFc&cKF  &0I
M cc F?I
?E
F.0I ()FF.ccF  &0I
Q ()FF.F  &XF AF2 F0I
PD.??WRW0I ()FF.F AF2 FJ@$$@0I
PD.0 ()FF'.'F %2& X'F AF2 F0I
M ()F).cc Fc  F % F  0I
WW ()F).cc F Y0I
&(F7.0I 
F.0I
EI E
F.0I
 F(). F  0I
W2W F(). F 0I
&(FK .0I F(). Fcc 0I
EI F().+&2&0I
 55 ()(F P. Fc$0I
WcW 
&(FK .0I PD. 0M
EI 
.0I
Q )F .0I
Q Q
 
?I Q
Q

56,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65
56,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,65
7. 
??0
c +"   & 1 c %  c cc 4  % & cc&2

function control
h1 = figure(...
'Units','characters',...
'PaperUnits','centimeters',...
'MenuBar','none',...
'Name','Termometro',...
'NumberTitle','off',...
'PaperPosition',get(0,'defaultfigurePaperPosition'),...
'PaperSize',[20.98404194812 29.67743169791],...
'PaperType','A4',...
'Position',[103.714285714286 24.65 100.714285714286 36.8],...
'Resize','off',...
'Tag','figure1',...
'UserData',[],...
'Visible','on');
movegui(h1,'center')
handles.Referencia = uicontrol(...
'Parent',h1,...
'Units','characters',...
'Callback',@Referencia_Callback,...
'Max',100,...
'Position',[3.2 10.0307692307692 10.2 23.1538461538462],...
'String',{ 'Slider' },...
'Style','slider',...
'SliderStep',[0.1 0.01],...
'Tag','Referencia');
handles.Gain_KP = uicontrol(...
'Parent',h1,...
'Units','characters',...
'Callback',@Gain_KP_Callback,...
'Max',256,...
'Position',[19.6 9.95384615384616 10.2 23.1538461538462],...
'String',{ 'Slider' },...
'Style','slider',...
'SliderStep',[0.01 0.01],...
'Tag','Gain_KP');
handles.Gain_KI = uicontrol(...
'Parent',h1,...
'Units','characters',...
'Callback',@Gain_KI_Callback,...
'Max',64,...
'Position',[37 10.0307692307692 10.2 23.1538461538462],...
'String',{ 'Slider' },...
'Style','slider',...
'SliderStep',[0.01 0.01],...
'Tag','Gain_KI');

%-------------------------------- etiquetas ------------------------------%


handles.text1 = uicontrol(...
'Parent',h1,...
'Units','characters',...
'FontWeight','bold',...
'Position',[-0.2 34.2615384615385 18.2 1.15384615384615],...
'String','Referencia',...
'Style','text',...
'Tag','text1');
set(h1,'Color',get(handles.text1,'BackgroundColor'))

handles.text2 = uicontrol(...
'Parent',h1,...
'Units','characters',...
'FontWeight','bold',...
'Position',[17 34.2615384615385 15.8 1.15384615384615],...
'String','Gain KP',...
'Style','text',...
'Tag','text2');

handles.text3 = uicontrol(...
'Parent',h1,...
'Units','characters',...
'FontWeight','bold',...
'Position',[35.6 34.3384615384616 14.2 1.15384615384615],...
'String','Gain KI',...
'Style','text',...
'Tag','text3');

handles.text7 = uicontrol(...
'Parent',h1,...
'Units','characters',...
'FontWeight','bold',...
'Position',[55.2 34.1076923076923 17.4 1.38461538461539],...
'String','Temperatura',...
'Style','text',...
'Tag','text7');

handles.text8 = uicontrol(...
'Parent',h1,...
'Units','characters',...
'FontWeight','bold',...
'Position',[77.4 33.8769230769231 20.2 1.61538461538462],...
'String','Referencia',...
'Style','text',...
'Tag','text8');
%-------------------------------------------------------------------------%
%--------------------------- Textos dinamicos ---------------------------%
handles.Valor_REF = uicontrol(...
'Parent',h1,...
'Units','characters',...
'FontWeight','bold',...
'Position',[-0.2 7.95384615384615 18.2 1.30769230769231],...
'String','0',...
'Style','text',...
'Tag','Valor_REF');

handles.Valor_KP = uicontrol(...
'Parent',h1,...
'Units','characters',...
'FontWeight','bold',...
'Position',[19.8 7.03076923076923 10.4 2.07692307692308],...
'String','0',...
'Style','text',...
'Tag','Valor_KP');

handles.Valor_KI = uicontrol(...
'Parent',h1,...
'Units','characters',...
'FontWeight','bold',...
'Position',[36.2 7.87692307692308 10.8 1.38461538461539],...
'String','0',...
'Style','text',...
'Tag','Valor_KI');
%-------------------------------------------------------------------------%
%----------------------- Grafica de Temperatura---------------------------%
handles.Grafica_TEMP = axes(...
'Parent',h1,...
'Units','characters',...
'Position',[56 9.72307692307692 17.4 23.2307692307692],...
'CameraPosition',[0.5 0.5 9.16025403784439],...
'CameraPositionMode',get(0,'defaultaxesCameraPositionMode'),...
'Color',[0.831372549019608 0.815686274509804 0.784313725490196],...
'ColorOrder',get(0,'defaultaxesColorOrder'),...
'LooseInset',[14.3 3.38461538461539 10.45 2.30769230769231],...
'XColor',get(0,'defaultaxesXColor'),...
'YColor',get(0,'defaultaxesYColor'),...
'ZColor',get(0,'defaultaxesZColor'),...
'Tag','Grafica_TEMP');
%-------------------------------------------------------------------------%
%----------------------- Grafica de Referencia ---------------------------%
handles.Grafica_REF = axes(...
'Parent',h1,...
'Units','characters',...
'Position',[79.8 9.72307692307692 17.4 23.1538461538462],...
'CameraPosition',[0.5 0.5 9.16025403784439],...
'CameraPositionMode',get(0,'defaultaxesCameraPositionMode'),...
'Color',[0.831372549019608 0.815686274509804 0.784313725490196],...
'ColorOrder',get(0,'defaultaxesColorOrder'),...
'LooseInset',[14.3 3.85 10.45 2.625],...
'XColor',get(0,'defaultaxesXColor'),...
'YColor',get(0,'defaultaxesYColor'),...
'ZColor',get(0,'defaultaxesZColor'),...
'Tag','Grafica_REF');
%-------------------------------------------------------------------------%
%--------------------------Boton Salir -----------------------------------%
handles.Salir = uicontrol(...
'Parent',h1,...
'Units','characters',...
'Callback',@Salir_Callback,...
'Position',[65.4 2.10769230769231 32.2 3.92307692307692],...
'String','Salir',...
'Tag','Salir');
%-------------------------------------------------------------------------%
global s
delete(instrfind)
s = serial('COM15');
set(s,'BaudRate',19200);
s.FlowControl = 'software';
fopen(s);
t = timer('ExecutionMode','fixedRate','Period',5,...
'TasksToExecute',inf,'TimerFcn',@timer1s);
%start(t)
%-------------------------------------------------------------------------%
function timer1s(objeto,evento)
fwrite(s,'D');
while s.BytesAvailable < 4
end
x = fread(s,4);
%---------------------- Lectura de la Temperatura ------------------------%
Temp = x(1)/2.560;
axes(handles.Grafica_TEMP)
bar(0,Temp)
ylim([0,100])
%----------------------- Lectura de la Referencia ------------------------%
Referencia = x(2);
axes(handles.Grafica_REF)
bar(0,Referencia)
ylim([0,100])
set(handles.Referencia,'value',Referencia);
set(handles.Valor_REF,'String',Referencia),
%------------------------------ Dato KP ---------------------------------%
KP = x(3);
set(handles.Gain_KP,'value',KP);
KPM = round(KP);
Gain_KP_F = KPM*.03906;
set(handles.Valor_KP,'string',Gain_KP_F);
%------------------------------ Dato KI ---------------------------------%
KI = x(4);
set(handles.Gain_KI,'value',KI);
KIM = round(KI);
Gain_KI_F = KIM*.03906;
set(handles.Valor_KI,'string',Gain_KI_F);
%------------------------------------------------------------------------%
end
%----------------------------Enviar Referencia----------------------------%
function Referencia_Callback(hObject, eventdata)
Referencia = get(handles.Referencia,'value');
Referencia = round(Referencia);
set(handles.Valor_REF,'string',Referencia);
%s.RequestToSend = 'on'
fwrite(s,'A');
fwrite(s,Referencia);
%s.RequestToSend = 'off'
end
%-------------------------------------------------------------------------%
%--------------------------------Enviar KP--------------------------------%
function Gain_KP_Callback(hObject, eventdata)
Gain_KP = get(handles.Gain_KP,'value');
KPM = round(Gain_KP);
Gain_KP_F = KPM*.03906;
set(handles.Valor_KP,'string',Gain_KP_F);
KPM = round(Gain_KP);
%s.RequestToSend = 'on'
fwrite(s,'B');
fwrite(s,KPM);
%s.RequestToSend = 'off'
end
%-------------------------------------------------------------------------%
%--------------------------------Enviar KI--------------------------------%
function Gain_KI_Callback(hObject, eventdata)
Gain_KI = get(handles.Gain_KI,'value');
KPI = round(Gain_KI);
Gain_KI_F = KPI*.03906;
set(handles.Valor_KI,'string',Gain_KI_F);
KPI = round(Gain_KI);
%s.RequestToSend = 'on'
fwrite(s,'C');
fwrite(s,Gain_KI);
%s.RequestToSend = 'off'
end
%-------------------------------------------------------------------------%
%-----------------------------Salir del Evento----------------------------%
function Salir_Callback(objeto,evento)
stop(t)
delete(t)
delete(gcf)
end
%-------------------------------------------------------------------------%
end



 
 "*+" c.+ 0c&  






2&  (
)( @() 
  
&'$@ ( 
) )( (>
2%& c)( 9
)(Z) 
%&  "  c   (
)() 
%& K c 
K 
  

%& K c 
K 
  

+" c  ( (
)(=(

) 
&'$
+" c "  c (37 (
7>

 
cc&%  %

El uso de lenguajes de programación de alto nivel; como es el caso del compilador C CCS Compiler,
facilita ampliamente la implementación de controladores PID u otro tipo de esquema de
controlador sobre dispositivos microcontrolados, abriendo así una alternativa de desarrollo de
sistemas de control a bajo costo, dado que este lenguaje permite fácilmente adicionar
periféricos para ingreso de datos y supervisión de variables de estado del sistema
controlado; como por ejemplo teclados matriciales y LCD͛s respectivamente, y además la
implementación de sistemas de comunicación tales como USB, CAN, Ethernet, Bluetooth entre
otros, ya son soportados por algunas gamas de microcontroladores y pueden ser
administrados fácilmente a través de este tipo de compiladores.

Como ya se explico, la tarea fundamental para el diseño de un controlador PID esta en la


obtención de los parámetros del sistema que se desea controlar (planta), dado que a partir
de estos parámetros se utilizan reglas de sintonización para hallar las constantes del
controlador K p , T i y T d . Una vez calculadas estas constantes podrá utilizar como
condiciones del código fuente expuesto, y solo requerirá reemplazar el valor de las constantes
del controlador PID y por supuesto el respectivo valor de Periodo de Muestreo, el cual esta en
términos de solamente un retardo.

2 2& +" 

[1] Ogata, Katsuhiko. Ingeniería de Control Moderna. Controles PID e introducción al


control robusto. Tercera edición. Pagina 669. Editorial Prentice Hall. 1998.

[2] Garcia, Eduardo. Compilador C CCS y simulador Proteus para microcontroladores PIC.
Editorial AlfaOmega. Pagina 154. 2008.

[3] Ogata, Katsuhiko. Sistemas de control en tiempo discreto. Segunda edición. Pagina
116. Editorial Prentice Hall. 1996.

[4] Canovas, Andrés. Manual de usuario del compilador PCW de CCS. Disponible en
internet en http://www.cursos.ucv.cl/eie48700/referencias/CCS_C_Manual.pdf.

[5] C Compiler Reference Manual March 2009. Disponible en internet en


http://www.ccsinfo.com/downloads/ccs_c_manual.pdf.