Control PID

Profesor: ILDEBERTO DE LOS SANTOS RUIZ

ING. ELECTRONICA 8vo semestre

Integrantes:Gómez Valdez Jefferson AlbertoRosales Salgado José EdgarPérez Alvarado Iván YashirPola López Luis Alejandro

09 de Diciembre de 2010

INTRODUCCION

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.

MARCO TEORICO

PIC 18F4520 CARACTERISTICAS PRINCIPALES

SENSOR TEMPERATURA LM35

Descripción: 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:

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

Funcionamiento: 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.

Usos: 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.

CONTROLADOR PID

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.

Funcionamiento

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

1. Un sensor, que determine el estado del sistema (termómetro, caudalímetro,manómetro, etc).2. Un controlador, que genere la señal que gobierna al actuador.3. 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 punto actual 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 Proporcional, acción Integral y acción Derivativa. 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.

Proporcional

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

Integral

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 error es integrado, lo cual tiene la función de promediarlo o sumarlo por un período determinado; Luego es multiplicado por una constante I. 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).

Derivativo

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 error es la desviación existente entre el punto de medida y el valor consigna, o "Set Point".

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

Las constantes

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:

SINTONIZACION DE CONTROLADOR MEDIANTE ZIEGLER-NICHOLS 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:

CONTROLADOR DIGITAL PID

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:

ALGORITMO DE PROGRAMACION EN MICROCONTROLADOR 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.

MODELAMIENTO DEL SISTEMA DE CALEFACCION (Ejemplo)

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:

IMPLEMENTACION DE CONTROLADOR DIGITAL PID EN MICROCONTROLADOR (Ejemplo) 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.

DIAGRAMA ESQUEMATICO CON EL SIMULACION PROTEUS

PIC USB

PIC ADC TERMOMETRO

Desarrollo de la práctica

MODELADO DEL SISTEMA

IDENTIFICANDO LA FUNCIÓN DE TRANSFERENCIA DEL SISTEMA

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

Tiempo en segundos: 0,10,20,30,40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200,210Temperatura: 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.

/*-------------------------- CODIGO MATLAB -------------------------------------*/

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:

G (s )= Kp1+Tp1∗s

FUNCIÓN DE TRANSFERENCIA DEL SISTEMA

G (s )= 13.3421+113.96∗s

/*---------------------------- CODIGO MATLAB ---------------------------------------*/

H = tf(13.342,[113.96 1])

H= .1171s+.008775

%Ya definido la función de transferencia y asignado a una variable procederemos nuevamente a la llamada de un toolbox “SISOTOOL” con que cuenta MATLAB para el modelo del compensador que será programado en nuestro microcontrolador.

Sisotool

/*--------------------------------------------- -------------- CODIGO MATLAB ---------------------------------------------------------*/

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

C= .1+ .77 ss

CD=c2d(C,1/100)

.77 z−.769z−1

Tiempo de Muestreo: 0.01

TRANSFORMADA INVERSA Z

U (Z)E(Z)

= .77 Z−.769Z−1

U (Z )∗(Z−1 )=E (Z )∗( .77 Z−.769)

(Z−1 ) ¿¿

CODIGO DEL PIC USB

#include "PIC USB.h"#include <usb_cdc.h> // declaro librerias USB

// Descriptores del dispositivo USB.//*********************** configuracion y declaraciones ****************int8 KP, KI, Referencia, Temperatura;

/* Funciones */void Inicializar_Variables();void Inicializar_Funciones();void Verificar_USB();void Recepcion();

#int_RDAvoid RDA_isr(void) { char dato = getc(); switch(dato) { case 'D': //output_low(PIN_D4); Temperatura = getc(); usb_cdc_putc(Temperatura); Referencia = getc(); usb_cdc_putc(Referencia); KP = getc(); usb_cdc_putc(KP); KI = getc(); usb_cdc_putc(KI); //output_low(PIN_D4); break; }}

void Inicializar_Funciones(){ usb_init(); usb_task(); usb_wait_for_enumeration();}

void Verificar_USB(){int KPM,KIM,Referencia;char dato; if(usb_enumerated()) // PicWinUSB ha sido enumerado { if (usb_cdc_kbhit()) // Existen datos { dato = usb_cdc_getc(); switch(dato) { case 'A': //output_high(PIN_D4); Referencia = usb_cdc_getc(); putc('A'); putc(Referencia); //output_low(PIN_D4); break; case 'B': //output_high(PIN_D4); KPM= usb_cdc_getc(); putc('B'); putc(KPM); //output_low(PIN_D4); break; case 'C': //output_high(PIN_D4); KIM = usb_cdc_getc(); putc('C'); putc(KIM);

//output_low(PIN_D4); break; case 'D': //output_high(PIN_D4); putc('D'); //output_low(PIN_D4); break; } } }}

void main(){ enable_interrupts(INT_RDA); enable_interrupts(GLOBAL); //output_high(PIN_D4); //TODO: User Code Inicializar_Funciones(); while(!usb_cdc_connected()){} while(TRUE){ usb_task(); Verificar_USB();}}

CODIGO DEL PIC PID

#include "Termometro.h"#include "kbd_lib.c"#use fast_io(A)#use fast_io(B)#use fast_io(D)#include <LCD.c>

/*----------------- Variables Globales ---------------------------------------*/unsigned int numero = 0;char tecla;int Referencia = 30;int16 Temperatura;float E, E1=0, U, U1=0,Temp,KP=.769,KI=.001;/*----------------------------------------------------------------------------*/

/*---------------------- Funcion de Control ----------------------------------*/#int_TIMER0void TIMER0_isr(void){set_timer0(63536);E = Referencia*10.23 - Temp*10.23;U = (U1 + ((KP+KI)*E) - (KP*E1));U = U>1023?1023:(U<0?0:U);set_pwm2_duty((int16)(U));U1 = U;E1 = E;}/*----------------------------------------------------------------------------*/

void ADC(){set_adc_channel(0); delay_us(20);Temperatura=read_adc();Temp = Temperatura/10.24;}

void Imprimir_Pantalla(){printf(lcd_putc,"\f Referencia : %d\n Temperatura : %1.3f",Referencia,Temp);delay_ms(200);}

/*---------------- Control Referencia ----------------------------------------*/void Lectura_Referencia(){char tecla;

int32 valor[3],valor_total;int k,tecla_valor,x=7;inicio: valor[0]=0; //Asigna 0 al arreglo valor valor[1]=0; valor[2]=0; for (k=1;k<4;k++) { tecla=kbd_getc(); tecla_valor=tecla-48; //Convierte el valor de la tecla if (tecla_valor>=0 && tecla_valor<=9) //Compara que la tecla sea un número { lcd_gotoxy(5,1); printf(lcd_putc,"Grados C:"); lcd_gotoxy(x,2); printf(lcd_putc,"%d",tecla_valor); //Imprime el número en el LCD valor[2]=valor[1]; //Realiza un recorrido de los números valor[1]=valor[0]; valor[0]=tecla_valor; x++; } else { if (tecla == '#') goto aceptar; k--; } }

aceptar: x=7; valor_total=(valor[2]*100+valor[1]*10+valor[0]); if (valor_total>100) { printf(lcd_putc,"\f Dato no valido");//Imprime el mensaje en el LCD delay_ms(300); lcd_putc('\f'); } else { printf(lcd_putc,"\f Nueva Referencia\n %ld",valor_total); Referencia=valor_total; delay_ms(300); lcd_putc('\f'); } }/*----------------------------------------------------------------------------*/

/*------------------------------ Control KP ----------------------------------*/void Lectura_KP(){char tecla;int k,tecla_valor,x=7;int32 valor_total,valor[5];float valor_KP;inicio: valor[0]=0; //Asigna 0 al arreglo valor valor[1]=0; valor[2]=0; valor[3]=0; valor[4]=0; for (k=1;k<6;k++) { tecla=kbd_getc(); tecla_valor=tecla-48; //Convierte el valor de la tecla if (tecla_valor>=0 && tecla_valor<=9) //Compara que la tecla sea un número { lcd_gotoxy(1,1); printf(lcd_putc," Dato en Milesimas:");

lcd_gotoxy(x,2); printf(lcd_putc,"%d",tecla_valor); //Imprime el número en el LCD valor[4]=valor[3]; //Realiza un recorrido de los números valor[3]=valor[2]; valor[2]=valor[1]; valor[1]=valor[0]; valor[0]=tecla_valor; x++; } else { if (tecla == '#') goto aceptar; k--; } }

aceptar: x=7; valor_total=(valor[4]*10000+valor[3]*1000+valor[2]*100+valor[1]*10+valor[0]); valor_KP=valor_total/1000.0; if (valor_KP>10) { printf(lcd_putc,"\f Dato no valido");//Imprime el mensaje en el LCD delay_ms(300); lcd_putc('\f'); } else { printf(lcd_putc,"\f Gain Proportional\n KP = %1.3f",valor_KP); KP=valor_KP; delay_ms(300); lcd_putc('\f'); }}/*----------------------------------------------------------------------------*//*------------------------------ Control KI ----------------------------------*/void Lectura_KI(){char tecla;int k,tecla_valor,x=7;int32 valor_total,valor[5];float valor_KI;inicio: valor[0]=0; //Asigna 0 al arreglo valor valor[1]=0; valor[2]=0; valor[3]=0; valor[4]=0; for (k=1;k<6;k++) { tecla=kbd_getc(); tecla_valor=tecla-48; //Convierte el valor de la tecla if (tecla_valor>=0 && tecla_valor<=9) //Compara que la tecla sea un número { lcd_gotoxy(5,1); printf(lcd_putc,"Dato en Milesimas:"); lcd_gotoxy(x,2); printf(lcd_putc,"%d",tecla_valor); //Imprime el número en el LCD valor[4]=valor[3]; valor[3]=valor[2]; valor[2]=valor[1]; //Realiza un recorrido de los números valor[1]=valor[0]; valor[0]=tecla_valor; x++; } else { if (tecla == '#')

goto aceptar; k--; } }

aceptar: x=7; valor_total=(valor[4]*10000+valor[3]*1000+valor[2]*100+valor[1]*10+valor[0]); valor_KI=valor_total/1000.0; if (valor_KI>10) { printf(lcd_putc,"\f Dato no valido");//Imprime el mensaje en el LCD delay_ms(300); lcd_putc('\f'); } else { printf(lcd_putc,"\f Gain Integral\n KI = %1.3f",valor_KI); KI=valor_KI; delay_ms(300); lcd_putc('\f'); }}/*----------------------------------------------------------------------------*/

/*----------------- Habilitacion del Teclado ---------------------------------*/void Teclado(){ int16 contador; contador=0; while(1) {/*----------------------------------------------------------------------------*/

/*---------------------------------- Teclado----------------------------------*/ if(input(pin_a4)) { while(input(pin_a4)); if(numero<100) { numero++; lcd_putc("\f"); do { tecla=kbd_getc(); } while(tecla=='\0'); switch(tecla) { case 'A': Lectura_Referencia(); break; case 'B': Lectura_KP(); break;

case 'C': Lectura_KI(); break; } } contador=0; } /*----------------------------------------------------------------------------*//*----------------------------------------------------------------------------*/ else if(contador == 100) { break; } contador++; delay_us(10);

}}/*----------------------------------------------------------------------------*/

/*------------------ Leer Datos Del Puerto Serie -----------------------------*/#int_RDAvoid RDA_isr(void) { int KPM,KIM; char dato = getc(); switch(dato) { case 'A': Referencia = getc(); break; case 'B': KPM= getc(); KP = KPM * .03906; break; case 'C': KIM = getc(); KI = KIM * .03906; break; case 'D': //output_high(PIN_C5); putc((int8)(Temperatura>>2)); putc(Referencia); putc((int8)(KP*25.6)); putc((int8)(KI*25.6)); //output_low(PIN_C5); break; }}/*----------------------------------------------------------------------------*//*---------------Contador De Eventos------------------------------------------*/#int_CCP1void CCP1_isr(void) {ADC();}/*----------------------------------------------------------------------------*/void main(){ setup_adc_ports(AN0|VSS_VREF); setup_adc(ADC_CLOCK_INTERNAL); CCP_1=2000; setup_timer_0(RTCC_INTERNAL); setup_timer_1(T1_INTERNAL|T1_DIV_BY_1); setup_timer_2(T2_DIV_BY_16,255,1); setup_timer_3(T3_DISABLED|T3_DIV_BY_1); setup_ccp1(CCP_COMPARE_RESET_TIMER); setup_ccp2(CCP_PWM); lcd_init(); kbd_init(); enable_interrupts(INT_TIMER0); enable_interrupts(INT_RDA); enable_interrupts(INT_CCP1); enable_interrupts(GLOBAL); //output_low(PIN_C5); while(TRUE){Teclado();Imprimir_Pantalla();}}

CODIGO FUENTE DE LA ADQUICISION Y COMUNICACIÓN DE DATOS DEL PIC CON MATLAB

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 sdelete(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

INTERFAZ GRAFICA (GUI) CONTROLADOR PID

BOTON LEER: Al activarlo se inicia la lectura del puerto serial , instante en el cual el pic obtiene los valores del LM35, los cuales son enviados por puerto usb matlab. BOTON SALIR: Cierra el puerto serial y después cierra el programaSLIDER REFERENCIA: Este cambia el valor actual de temperatura en el programaSLIDER KP: Cambia el valor de la ganancia KP del controladorSLIDER KI: Cambia el valor de la ganancia KI del controladorGRAFICA TEMPERATURA: Muestra el valor actual de la temperatura que esta siendo sensada por el LM35GRAFICA REFERENCIA: Muestra gráficamente el valor actual de la Referencia.

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

BIBLIOGRAFIA

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