El controlador PID es uno de los controles mas utilizados actualmente en la industria devido a

su facil sintonia y robustez en los diferentes procesos existentes. Este es utilizado para llevar
una variable fsica (Nivel, temperatura, velocidad, presin, etc) a un punto de operacin
especifico (set point). Al final del post hay un video explicativo de toda esta entrada.
Una vez termines de estudiar todo el contenido de este post puedes ver un segundo
ejemplo de PID en pic en un proceso real para una planta MOTOR GENERADOR danco
click aca

En esta entrada, vamos a aprender como podemos programar nuestro propio controlador PID
en nuestro microcontrolador. Para eso debemos tener claro, como es una estructura clasica
de control. Asi, que en la siguiente figura se muestra un lazo de control en malla cerrada
donde C es el controlador (en este caso el PID) y P es nuestro proceso.

donde r(k) es nuestra seal de referencia o set point, e(k) es nuestra seal de error (La resta
entre r(k) y y(k)), C(z) es nuestro controlador PID discreto, u(k) es nuestra seal de control
(Ley de control), P(z) es nuestra planta o proceso en representacin discreta, y(k) es nuestra
variable de salida a controlar.

La ley de control PID puede representarse por la siguiente ecuacin:

y en dominio de s es representado por:

El control PID posee tres parmetros (

) ganancia proporcional, tiempo integral y
tiempo derivativo respectivamente. Existen numerosas tcnicas y autores que tratan como
sintonizar o ajustar dichos parmetros. En esta entrada, les voy a ensear TRES formas
diferentes de sintonizar este controlador. Para eso y antes que nada, debemos conocer el
modelo matemtico o el comportamiento de nuestro proceso que queremos controlar (en el
diagrama de arriba seria el bloque P(z)).

Tipicamente, todo proceso industrial es representado por funciones de transferencia de primer

o segundo orden. A continuacin es expuesto un modelo de primero orden sobre el cual
vamos a trabajar para poder modelar el comportamiento de nuestra planta.

El modelo est representado en su forma continua, es decir en el dominio de Laplace.

donde
es la ganancia del sistema, es la constante de tiempo del proceso y es el retardo
del proceso.

Para entender como obtener estos tres parmetros de nuestro proceso, vamos a hacerlo
directamente en el ejemplo, para que aprendamos de manera practica a modelar un proceso
rpidamente y posteriormente poder sintonizar o ajustar nuestro controlador PID para que
pueda controlar dicho proceso.

Ejemplo
En este ejemplo vamos a programar un controlador PID en nuestro PIC, para controlar la
temperatura de un horno y poderla mantener en el punto de operacin deseado, en este caso
se le pide al ingeniero de control que el horno debe mantener su temperatura constante en
torno de los 150.0C. Se pide adems al ingeniero, que adapte un LCD 420 para poder
visualizar la temperatura actual del horno, y el setpoint.

Antes que nada vamos a necesitar los siguientes componentes en el PROTEUS para poder
simular nuestro proceso: PIC16F887, IRFZ44N, LM044L, CELL, RES, OVEN.

Comencemos primero con nuestro proceso (El horno de temperatura), vamos a buscar el
horno en proteus (OVEN) y vamos a darle doble click para configurarle sus parmetros:

Temperatura ambiente: 25C

Temperature coefficient (V/C): da una idea de la temperatura que alcanzar el horno

segn la tensin aplicada. Valor: 1V/C.

Oven Time Constant (sec): es la constante de tiempo del horno. Para evitar una
simulacin muy larga, vamos a colocarlo en 10 segundos.

Heater time constant (sec): es la constante de tiempo del calefactor. Para evitar
simulaciones largas la ponemos en 1 segundo.

Thermal resistence to ambient (C/W): resistencia trmica horno ambiente. Valor por
defecto 0.7.

Heating Power (W): es la potencia del horno. A fin de que nuestro sensor de
temperatura no sobrepase los 5 voltios de tensin, vamos a colocar este parmetro en 52
W.
Como sensor de temperatura se pueden usar termopares, termocuplas, RTD, etc. Ahora,
como el dispositivo OVEN tiene un terminal que dice T, el cual nos indica la temperatura del
horno en grados CELCIUS. Para esto es conveniente utilizar un divisor de voltaje por 100 para
obtener la seal del horno en milivoltios. Asi, 25C corresponderan a 250mV.
Listo, una vez configurado nuestro horno, vamos a proceder a identificar el modelo
matemtico que mas o menos represente la dinmica de nuestra variable de proceso (La
temperatura). Note que en nuestro diagrama, estamos alimentando el horno con una batera
de 12V, para poder determinar nuestro modelo matemtico, vamos a tener que hacer una
identificacin off-line. Para eso necesitamos estimular nuestro horno y almacenar los datos
que este nos da, para poder graficar su comportamiento. Asi, estimulamos nuestro horno con
un valor del 10% al 20% de nuestro valor nominal que son 12V. Entonces vamos a energizar
el horno con 2V y graficar la curva que genera.

(En el video de youtube, les explicar como obtener esa grfica desde el proteus)
Miremos entonces la respuesta que obtuvimos de nuestra grfica:

Vemos que la grfica comienza en 25C y llega hasta 132C y que para conseguir esta
respuesta tuvimos que alimentar la resistencia con 2V. As podemos obtener la ganancia del
proceso con la siguiente formula:

Observemos que la temperatura en la grfica, se comienza a estabilizar mas o menos a los 40

segundos (Linea Roja), as podemos obtener la constante de tiempo de la variable
temperatura con la siguiente formula:

Osea que el
, esto era de esperar, pues nosotros mismos ya habamos colocado una
contaste de tiempo de 10 en los parmetros del horno.
Si te est sirviendo de algo la informacin de la pagina, podras invitarme a un caf y
ayudarme a seguir manteniendo en pie el sitio WEB. Solo cuesta $2USD y me ayudaras
enormemente a seguir con mi trabajo. Muchas Gracias por tu visita.

Por ultimo, solo nos falta averiguar el valor del retardo, para eso tenemos que ver cuanto se
demora en responder el horno una vez energizamos. Vemos que el responde
instantaneamente osea que podra tener un retardo nulo. Para efectos prcticos, vamos a
colocar un retardo bien pequeo para la tcnica de control por Ziegler y Nichols
y un
retardo de
para las otras dos tcnicas que voy a ensearles.
As que en trminos generales, nuestro proceso del horno est representado por la siguiente
funcin de transferencia:

Con nuestro proceso identificado podemos calcular los parmetros del controlador (
para eso utilizamos cualquiera de estas tres tcnicas:

Control PI por asignacin de 2 polos reales

En esta sintonia solo utilizamos nuestra parcela Proporcional y integral, colocando la accin
derivativa en cero. La idea bsica de este diseo es asignarle polos a nuestro proceso para
que acte de la manera como nosotros deseamos.

),

1.

Seleccionamos una constante de tiempo deseada. Es decir el tiempo en que

queremos que se estabilice la temperatura, por ejemplo, seleccionamos una constante de
tiempo de 4 para que se estabilice el proceso en mas o menos 16 segundos
.
2.
Calculamos la frecuencia natural de nuestro sistema de forma que no tenga
sobreimpulso (Como son polos iguales los que estamos asignano este sistema se conoce

3.

4.

como criticamente amortiguado)

Calculamos el polinomio deseado el cual contiene los dos polos iguales que estamos
asignando al sistema:

Por ultimo calculamos el parametro kc y ti con las siguientes formulas:

Control PI por Cancelacin de Polos

La idea bsica de este control es cancelar el polo de la planta (click aqui para ver una
explicacin del funcionamiento del controlador por cancelacinde polos) con el
parmetro integral del controlador. (este controlador principalmente es para fines acadmicos
y de simulacin, no es muy recomendable aplicarlo a nivel profesional)
1.
Seleccionamos una constante de tiempo deseada. Es decir el tiempo en que
queremos que se estabilice la temperatura, por ejemplo, seleccionamos una constante de
tiempo de 4 para que se estabilice el proceso en mas o menos 16 segundos
.
2.
3.

se calcula el parametro kp:

se calcula el parametro ti:

Control por Ziegler y Nichols

Ziegler y Nichols propusieron unas tablas de sintonia de controladores PID a partir de
funciones de transferencias de primer orden con retardo.

Controlador PID discreto

Como vamos a implementar el PID en nuestro microcontrolador PIC, debemos colocar la ley
de control en tiempo discreto con un tiempo de muestreo (T) adecuado. Ziegler y Nichols
propusieron determinar el tiempo de muestreo rpidamente de dos formas distintas:

1.
2.
Para nuestro caso del horno escogeremos un
menor que .
El control discreto PID viene dado por:

donde:

que corresponde a 100mS y siendo

Con esto, la ley de control que vamos a ingresar a nuestro PIC sale del control PID discreto
(Despejando u(k))

aplicando transformada inversa Z obtenemos la ecuacion en diferencias:

As, u(k) quiere decir la ley de control actual, u(k-1) es la ley de control un instante de
muestreo atrs, e(k) es el error actual (Referencia temperatura), e(k-1) es el error un
instante de muestreo atrs, e(k-2) es el error dos instantes de muestreo atrs.

Implementacin
Para implementar el control, debemos hacer uso de un MOSFET de potencia que sea capaz
de aguantar la corriente del horno (4,3A), para eso se selecciono el MOSFET de combate
IRFZ44N, el cual en el GATE ser activado por una seal PWM a fin de poder regular la
potencia del Horno (click aqui para ver entrada de PWM).

Para garantizar el tiempo de muestreo de 100mS, podemos hacer uso de la

instruccin delay_ms(100), pero en este caso, como yo quera mayor precisin, emplee el uso
del TIMER0, como lo habiamos visto en entradas pasadas (click aqui para ver entrada de
TIMER).

Por ltimo, quiero resaltar que el set-point o referencia ser fija a 150C, queda abierto el
cdigo para que tu puedas modificar ese parmetro haciendo por ejemplo una comunicacin
serial (click aqui para ver entrada de Comunicacion Serial) o colocndole algn teclado
matricial (click aqui para ver entrada de teclado matricial).
En el video explico detalladamente todos los pasos y procedimientos a tener en cuenta para
implementar el control PID, como por ejemplo el trabajar siempre de manera estandarizada las
seales (En este caso, trabajo todo en milivoltios). Tambien explico el cdigo y como se hace
la identificacin off-line. No olviden compartir este post si les gust, delen me gusta y
suscribanse a mi canal de Youtube.
Una vez termines de estudiar todo el contenido de este post puedes ver un segundo
ejemplo de PID en pic en un proceso real para una planta MOTOR GENERADOR danco
click aca

Cdigo de Implementacin:

A continuacin se presenta el cdigo para que lo copies y lo pegues en tu compilador y

puedas reproducirlo. Recuerda que para ver el cdigo debes compartir el contenido de este
blog para que ms personas se beneficien de esta informacin.

#INCLUDE <16F887.h>
#DEVICE ADC=10
#USE DELAY(CLOCK=4000000)
#FUSES XT,NOPROTECT,NOWDT,NOBROWNOUT,PUT,NOLVP
#include <lcd420.c>
//Configura direccion de memoria de los puertos A,B,C,D
#BYTE PORTA= 5
#BYTE PORTB= 6
#BYTE PORTC= 7
#BYTE PORTD= 8
int veces=39,seg=0;
int16 adc,control=0;
float yM=0,R=1500.0,e=0.0,e_1=0.0,e_2=0.0,u=0.0,u_1=0.0;
float kp,ti,td,q0,q1,q2,T=0.1;
float k=53.5,tao=10.0,theta=1.0;
float TsMA,Wn,P1,P2;

//Con esta rutina de desbordamiento del timer 0

//Hago el conteo del tiempo de muestreo
#INT_RTCC //Rutina de interrupcin por RTCC
RELOJ()
{

VECES--;

//Decremento variable veces

SET_RTCC(246);

//Cargo el timer con 243

IF(VECES==0)

//La variable veces se carga con 30 y el timer con 243

//para que entre a la interrupcion cada 100 milisegundos

VECES=39;
seg++;

//y incremente el contador 'seg'

}
if(seg==1)
{
seg=0;
output_toggle(pin_d0);
//Comienzo la ley de control

e=R-yM;
// Controle PID
u = u_1 + q0*e + q1*e_1 + q2*e_2; //Ley del controlador PID discreto

if (u >= 1000.0)
minimo

//Saturo la accion de control 'uT' en un tope maximo y

u = 1000.0;

if (u <= 0.0)
u = 0.0;

control=u;

//Retorno a los valores reales

e_2=e_1;

e_1=e;
u_1=u;

//La accion calculada la transformo en PWM

set_pwm1_duty(control);

}
}
void main()
{
set_tris_c(0);
set_tris_d(0);
setup_timer_2(t2_div_by_4,249,1); //Configuracion de Timer 2 para
establecer frec. PWM a 1kHz
setup_ccp1(ccp_pwm);
set_pwm1_duty(0);

setup_adc_ports(sAN0);
setup_adc(adc_clock_internal);
digital)
set_adc_channel(0);
Temperatura

SET_RTCC(246);

//Configurar modulo CCP1 en modo PWM

//Dejo en cero la salida PWM

//Configurar ADC (Lectura de temperatura)

//Reloj interno para la conversion analoga
//Seleccionar Canal 0 para sensor de

//Cargo el TIMER0 con 243

SETUP_COUNTERS(RTCC_INTERNAL, RTCC_DIV_256); //Configuro el TIMER0

con prescaler 256

ENABLE_INTERRUPTS(INT_RTCC); //Habilito interrupcion por TIMER0

enable_interrupts(GLOBAL);

LCD_INIT();

//Habilito las interrupciones a nivel global

//Inicializo el LCD

LCD_PUTC("\f");

//Limpio el LCD

//*************************************************************************//
//************* DISEO POR ASIGNACIN DE 2 POLOS REALES
****************//
//*************************************************************************//
/*
TsMA=4;
Wn=3/(TsMA);

//Tiempo deseado en Lazo Cerrado

//Frecuencia natural del sistema

//Ubicacin de 2 Polos reales

P1=Wn+Wn;
P2=Wn*Wn;

kp=(P1*tao-1)/k;

//Calculo de Kc

ti=(k*kp)/(P2*tao);

//Calculo de ti

*/
//*************************************************************************//
//***************** DISEO POR CANCELACIN DE POLOS
*******************//
//*************************************************************************//
/*
TsMA=1;
kp=(tao)/(TsMA*k);

//Tiempo deseado en Lazo Cerrado

//Calculo de Kc

ti=tao;

//Calculo de Ti (Igual a la constante de tiempo)

td=0;
*/
//*************************************************************************//
//***************** SINTONIA POR ZIEGLER y NICHOLS

*******************//

//*************************************************************************//

kp=(1.2*tao)/(k*theta);
ti=2*theta;
td=0.5*theta;

//*************************************************************************//

// Calculo do controle PID digital

q0=kp*(1+T/(2*ti)+td/T);
q1=-kp*(1-T/(2*ti)+(2*td)/T);
q2=(kp*td)/T;

while(1)
{

adc=read_adc(); //Leer ADC

yM=adc*5000.0/1024.0;

//Muestra mensajes en LCD

lcd_gotoxy(1,1);
printf(lcd_putc,"Temp: %f",yM/10);
lcd_gotoxy(1,2);
printf(lcd_putc,"SetPoint: %2.2f C ",R/10);
lcd_gotoxy(1,3);
printf(lcd_putc,"Error: %2.2f C ",e/10);
lcd_gotoxy(1,4);
printf(lcd_putc,"u(ley Con): %ld ",control);

}
}