17. Control PID con microcontrolador PIC Microcontroladores (PIC) Add commentsFeb152016 CALIFICA EL POSTEl 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.

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.

Malla cerrada controlador

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:

u(t)=k_pe(t)+\dfrac{k_p}{t_i}\int_{0}^{t}e(t)dt+k_pt_d\dfrac{de(t)}{dt}

y en dominio de s es representado por:

u(s)=k_p\left [ 1+\dfrac{1}{t_is}+t_ds \right ]e(s)

El control PID posee tres parmetros (k_p,t_i,t_d) 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.

P(s)=\dfrac{Ke^{-\theta s}}{\tau s +1}

El modelo est representado en su forma continua, es decir en el dominio de Laplace. donde K es la ganancia del sistema, \tau es la constante de tiempo del proces

o y \theta 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.

EjemploEn 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.

Control PID con PIC

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:

Control PID Horno con PICTemperatura ambiente: 25CTemperature 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.

Malla Abierta

(En el video de youtube, les explicar como obtener esa grfica desde el proteus)

Miremos entonces la respuesta que obtuvimos de nuestra grfica:

Grafica escaln

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:

K=\dfrac{Y_{final}-Y_{inicial}}{U_{final}-U_{inicial}}

K=\dfrac{132-25}{2-0}=53.5

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:

T_{establecimieto}=4\tau

Osea que el \tau=10, esto era de esperar, pues nosotros mismos ya habamos colocado una contaste de tiempo de 10 en los parmetros del horno.

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 \theta=1 y un retardo de \theta=0 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:

P(s)=\dfrac{53.5e^{-1 s}}{10 s +1}

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

Control PI por asignacin de 2 polos realesEn 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.

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 TsMA=4.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 como criticamente amortiguado)W_n=\dfrac{3}{TsMA}=\dfrac{3}{4}=0.75Calculamos el polinomio deseado el cual contiene los dos polos iguales que estamos asignando al sistema:(s+W_n)^2=s^2+p_1s+p_2=s^2+(W_n+W_n)s+(Wn*W_n)p_1=(W_n+W_n)=(0.75+0.75)=1.5p_2=(W_n*W_n)=(0.75*0.75)=0.5625Por ultimo calculamos el parametro kc y ti con las siguientes formulas:k_p=\dfrac{P_1\tau-1}{K}=\dfrac{1.5*10-1}{53.5}=0.2616t_i=\dfrac{k_p*K}{P_2*\tau}=\dfrac{0.2616*53.5}{0.5625*10}=2.48Control PI por Cancelacin de Polos

La idea bsica de este control es cancelar el polo de la planta con el parmetro integral del controlador. (este controlador principalmente es para fines acadmicos y de simulacin, no es muy recomendable aplicarlo a nivel profesional)

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 TsMA=4.se calcula el parametro kp: k_p=\dfrac{\tau}{K*TsMA}=\dfrac{10}{53.5*4}=0.04se calcula el parametro ti: t_i=\tauControl por Ziegler y NicholsZiegler y Nichols propusieron unas tablas de sintonia de controladores PID a partir de funciones de transferencias de primer orden con retardo.

Sintonia por Ziegler y Nichols

Controlador PID discretoComo 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:

T

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.

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.

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 o colocndole algn 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 BYTES). 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.

Cdigo

#INCLUDE #DEVICE ADC=10#USE DELAY(CLOCK=4000000)#FUSES XT,NOPROTECT,NOWDT,NOBROWNOUT,PUT,NOLVP#include //Configura direccion de memoria de los puertos A,B,C,D#BYTE PORTA= 5#BYTE PORTB= 6#BYTE PORTC= 7#BYTE PORTD= 8int 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 RTCCRELOJ(){

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) //Saturo la accion de control 'uT' en un tope maximo y minimo u = 1000.0; if (u

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; //Tiempo deseado en Lazo Cerrado kp=(tao)/(TsMA*k); //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);

}}12345678910

111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970

7172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130

131132133134135136137#INCLUDE #DEVICE ADC=10#USE DELAY(CLOCK=4000000)#FUSES XT,NOPROTECT,NOWDT,NOBROWNOUT,PUT,NOLVP#include //Configura direccion de memoria de los puertos A,B,C,D#BYTE PORTA= 5#BYTE PORTB= 6#BYTE PORTC= 7#BYTE PORTD= 8int 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 RTCCRELOJ(){ 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) //Saturo la accion de control 'uT' en un tope maximo y minimo u = 1000.0; if (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); //Configurar modulo CCP1 en modo PWM set_pwm1_duty(0); //Dejo en cero la salida PWM setup_adc_ports(sAN0); //Configurar ADC (Lectura de temperatura) setup_adc(adc_clock_internal); //Reloj interno para la conversion analoga digital) set_adc_channel(0); //Seleccionar Canal 0 para sensor de Temperatura SET_RTCC(246); //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); //Habilito las interrupciones a nivel global LCD_INIT(); //Inicializo el LCD LCD_PUTC("\f"); //Limpio el LCD //*************************************************************************// //************* DISEO POR ASIGNACIN DE 2 POLOS REALES ****************// //*************************************************************************// /* TsMA=4; //Tiempo deseado en Lazo Cerrado Wn=3/(TsMA); //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; //Tiempo deseado en Lazo Cerrado kp=(tao)/(TsMA*k); //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); }}