DISEO CONTROLADOR PID PARA PLANTA DE VELOCIDAD

PROYECTO

UNIVERSIDAD SURCOLOMBIANA

CONTROL DIGITAL

NEIVA HUILA

OBJETIVOS
 Conocer e identificar el funcionamiento de la planta de
velocidad para poder relacionar la salida de dicho sistema con
los posteriores sistemas de control que se puedan implementar
en base al comportamiento de esta planta.

Determinar y analizar la funcin de transferencia de la planta

de velocidad basndose en los datos obtenidos
experimentalmente. Para crear su respectivo controlador segn
la respuesta de la planta, estableciendo el tiempo
establecimiento, mximo sobre impulso y tiempo de muestreo
adecuado a los parmetros obtenidos.

Utilizar de manera eficaz las herramientas de programacin

como Matlab para la adecuacin de la funcin de transferencia
mediante la eliminacin del retardo del sistema.

INTRODUCCION

El control de velocidad de un motor constituye uno de los principales

procesos que se realizan a diario por su gran aplicabilidad en los
procesos industriales.

Para entender el funcionamiento de la planta de velocidad del motor

encontraremos la funcin de transferencia y a partir de esta
podremos obtener un comportamiento exacto del motor que nos
describa el funcionamiento de dicho sistema.

A continuacin se describe el proceso de toma de datos de la planta,

igualmente se deduce la funcin de transferencia del sistema y por
ltimo se arregla dicha funcin con la ayuda de Matlab, todo esto
apoyado en un marco terico sobre las principales caractersticas de
los motores de corriente continua, y de conceptos acerca de
velocidad, torque del motor entre otros.
 MARCO TERICO

Un PID (Proporcional Integral Derivativo) es un mecanismo de control

por realimentacin que calcula la desviacin o error entre un valor
medido y el valor que se quiere obtener, para aplicar una accin
correctora que ajuste el proceso. El algoritmo de clculo del control
PID se da en tres parmetros distintos: el proporcional, el integral, y el
derivativo. El valor Proporcional determina la reaccin del error actual.
El Integral genera una correccin 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
reaccin del tiempo en el que el error se produce. La suma de estas
tres acciones es usada para ajustar al proceso va un elemento de
control como la posicin de una vlvula de control o la energa
suministrada a un calentador, por ejemplo. Ajustando estas tres
variables en el algoritmo de control del PID, el controlador puede
proveer un control diseado para lo que requiera el proceso a realizar.
La respuesta del controlador puede ser descrita en trminos de
respuesta del control ante un error, el grado el cual el controlador
llega al "set point", y el grado de oscilacin del sistema. Ntese 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 tambin PI, PD, P o I en la ausencia
de las acciones de control respectivas. Los controladores PI son
particularmente comunes, ya que la accin derivativa es muy sensible
al ruido, y la ausencia del proceso integral puede evitar que se
alcance al valor deseado debido a la accin de control
 PROCEDIMIENTO

En primera instancia se entendi el manejo de velocidad del motor de

la planta, luego con la ayuda del programa Boris (una herramienta
visual) nos representa de forma grfica el comportamiento de la
planta. Recopilamos datos de voltaje del sensor respecto al tiempo
ya que describe la variacin de velocidad del motor, con una
diferencia en el voltaje de set-point.

Ahora con estos datos se obtiene la grafica que mejor describe el

proceso en un principio aumentando la velocidad hasta lograr una
velocidad constante, para posteriormente sacar nuestra funcin de
transferencia.
 ANALISIS DE DATOS

Los datos arrojados por la planta son ledos por el programa Boris, el
cual nos muestra la siguiente respuesta del sistema:

Con los datos obtenidos hacemos la identificacin de la planta,

usando las reglas para la obtencin experimental del modelo de una
k es T r

planta de primer orden con retardo de la forma G(s )= .

s+1

0=Nivel inicial de entrada

f =Nivel final de entrada

y 0=Nivel inicial de salida

y f =Nivel final de salida

t 0=Tiempo de cambio de u

t =Tiempo en que la salida

comienza a responder
 y y0
^
K= f ^ =t 63t
Parmetros de la transferencia estimada: f 0 , ,

T^r =t t 0

Realizamos la grfica en Matlab leyendo el archivo velocidad.txt que

contiene los vectores de tiempo y voltaje de la respuesta de la planta.

[x,y]=textread('velocidad.txt'); % leemos los datos del archivo y los

plot(x,y,x,5); % graficamos con un escaln de 5
axis([0 45 0 8]); % que fue la entrada de la muestra

RESPUESTA DE LA PLANTA MODELADA EN MATLAB

A travs de la inspeccin de la grfica en Matlab obtuvimos los

siguientes datos:

0=0 v , f =5 v , y 0=0 v , y f =6.6 v

t 0=0 s ,t =0 s ,t 63=0.9 s

Con lo cual obtenemos los siguientes valores para la funcin de

transferencia:
 ^ 6.60
K= =1.32, ^ =0.90=0.9, T^r =0
50

^ ( s )= 1.32 = 1.467
G
0.9 s+1 s+1.111

RESPUESTA DE LA PLANTA IDENTIFICADA EN MATLAB

COMPARACION RESPUESTA MATLAB CON LOS DATOS DEL

BORIS
Con lo cual vemos que el sistema modelado se asemeja a las
caraceristicas de la planta real; ahora disearemos un controlador
PID, para que la planta responda de acuerdo a unas consideraciones.

Primero discretizamos la funcin de transferencia de la planta usando

T = 0.08 seg.
k=1.467; % numerador correspondiente al valor de K
polo=[1 1.111]; % denominador s+1.111
Gp=tf(k,polo); % funcin transferencia de los valores anteriores
Gpz=c2d(Gp,0.08,'zoh') % planta discretizada con T = 0.08 seg

RESPUESTA A UN STEP DE 5
 Step Response
7

4
Amplitude

0
0 1 2 3 4 5 6 7
Time (seconds)

0.1123
Con lo cual obtenemos : Gpz=
z0.915
 DISEO DE CONTROLADOR PID

Debido a que la funcin de transferencia es de primer orden ya que

solo tiene un polo, entonces ser necesario agregar un polo y cero de
manera que no afecten a los polos dominantes y se pueda modelar la
planta como un sistema de segundo orden, para ello le agregamos un
^
retardo muy pequeo a la funcion de transferencia ( T r =0.001 s eg).
Entonces la planta queda de la siguiente forma.
T = 0.08; % Tiempo de muestreo
kv = 5; % Constante de velocidad
k=1.467; % numerador correspondiente al valor de K
polo=[1 1.111]; % denominador s+1.11
G=tf(k,polo); % funcin transferencia de los valores
[n,d]=pade(0.0001,1); % retardo con Tr = 0.0001 seg
r=tf(n,d); % funcin del retardo
Gs=G*r % Planta en s
Gz=c2d(Gs,T,'zoh') % planta discretizada con T = 0.08 seg

1.467 s +29340 0.1122 z +0.0001342

Gs= 2 4
Gz= 2 16
s +210 s+ 22220 z 0.915 z +1.01610

Usamos la linea de cdigo Gz=minreal(Gz)para que Matlab elimine

polos y ceros que no afecten la respuesta, para reducir la funcion de
transferencia; obtenemnos la siguiente respuesta:

0.1122 z +0.0001342 0.11216(z +0.001197)

Gz= =
z 20.915 z z ( z0.915)

Para mejorar la respuesta podemos usar como parametros una

constante de velocidad Kv = 5

(1 z 1 )Gla
k v lim lim Gla * k i
z 1 T z 1

0.11216 ( z 0.001197)
k v lim * ki 1.3221288 * ki
z 1 z ( z 0.915)
k i 3.7817

Por cancelacin de polos y ceros podemos hallar las constantes A, B y

K del controlador para hallar kp y kd, Igualando obtenemos:

z 2 Az B z ( z 0.915) z 2 Az B z 2 0.915 z

Entonces tenemos A = - 0.915 y B = 0; luego hallamos las constantes

del PID:
clear
clc
T = 0.08;
A = -0.9150;
B = 0;
ki = 3.7817;
syms kp kd
A1 = (ki*T^2 - 2*kp*T - 4*kd)/(ki*T^2 + 2*kp*T + 2*kd);% ecuacion de A
B1 = 2*kd/(ki*T^2 + 2*kp*T + 2*kd); % ecuacion de B
[kd,kp] = solve(A1==A,B1==B); % se encuentran Kp y Ki
kp= eval(kp) % Kp
kd= eval(kd) % Ki
k = (ki*T^2+2*kp*T+2*kd)/(2*T) % K

kp = 3.4080 ; kd = 0; k= 3.5592

MODELO EN SIMULINK

Implementando el sistema en simulink, con el controlador y la planta

podemos mirar la respuesta del sistema:
RESPUESTA DEL SISTEMA
Con lo cual obtenemos la siguiente funcin de transferencia del
controlador PID:
2
3.5592(z 0.915z)
G( z)=
z 2z

Pasndolo a tiempo discreto:

U (z ) 3.5592 ( 10.915 z 1 )
=
E ( z) 1z1

U ( z ) ( 1z 1 )=3.5592 E( z )(10.915 z1)

U ( z )U ( z) z1 =3.5592 E( z ) 3.256668 z1 E( z )

U ( k )=3.5592 E(k )3.256668 E(k1 )+U (k1)

IMPLEMENTACION DEL CONTROLADOR

La seal de entrada de la planta se implementa tambin en el

microcontrolador y se recibe a travs de las revoluciones por minuto
(rpm).
 TABLA DE RPM A PARTIR DE VOLTAJE

Voltaje (V) RPM Voltaje (V) RPM

0,5 5 5,5 1445
1 6 6 1670
1,5 116 6,5 1811
2 291 7 1959
2,5 436 7,5 2139
3 591 8 2334
3,5 775 8,5 2478
4 915 9 2673
4,5 1115 9,5 2856
5 1271 10 3029

Se expone en la tabla los valor en revoluciones por minuto del motor

a diferentes valores de voltaje, siendo 3029 el valor maximo en RPM y
10 en voltajes.

Los datos son montados en excel, para sacar la grafica y ecuacin

lineal que representa el comporatamiento de la planta.

GRAFICA DEL COMPORTAMIENTO DE LA PLANTA DE

VELOCIDAD

3500

3000
f(x) = 334x - 357.74
2500

2000

1500 Linear ()
1000

500

0
0 2 4 6 8 10 12
Se obtienen las siguientes ecuaciones para el valor en RPM y Voltaje.

RPM = 334V - 357,47

RPM +357,47
V=
334

V = 0,003*RPM + 1,07

SIMULACION DEL CONTROLADOR

Se realiz la simulacin en PROTEUS del acondicionamiento del

controlador. Donde se implement un conversor D/A, que tiene un
integrado 0808 que entrega una seal negativa a su salida, por lo que
se adiciona un inversor, que recibe y entrega a la planta un rango de
voltaje de 0 a 10 voltios. De all se acopla un adaptador de nivel que
permite a su salida un rango de 0 a 5 voltios, que va conectado a la
entrada ADC del microcontrolador.
 CODIGO EN PIC C

#INCLUDE <16F877A.h>
#DEVICE ADC=10
#FUSES NOWDT,XT,NOPROTECT,NODEBUG,NOLVP
#USE

DELAY(CLOCK=4000000)
#INCLUDE <stdlib.h>

// define los pines del

puerto b para el lcd

//***************************************************************
#define LCD_RS_PIN PIN_B1
#define LCD_RW_PIN PIN_B2
#define LCD_ENABLE_PIN PIN_B3
#define LCD_DATA4 PIN_B4
#define LCD_DATA5 PIN_B5
#define LCD_DATA6 PIN_B6
#define LCD_DATA7 PIN_B7
#INCLUDE<LCD.C>
//*****************************************************************
// parametros del teclado
//******************************************************************
char d,*p;
int16 t=250; // Antirebote y retardo de teclado.
int puerto=0x08; // puerto usado para el treclado (puerto D)
int16 rpm = 0;
float step; // step en voltios
float Ek; // entrada de error
float Uk; // salida del controlador
float Uk1 = 0; // salida anterior del controlador
float Ek1 = 0; // entrada de error anterior
float Yk; // salida del sistema
int sal_binaria = 0;// salida del controlador en binario
float sal_float;
int16 adc;
//-----------------------------------------------------------------
// FUNCION PARA TECLADO
//--------------------------------------------------------
char teclado (int16 R,t) // R corresponde a la direccion del registro del
//puerto usado para
{ // el teclado, por ejemplo para el puerto D es
//0x08 o 8 en decimal
char teclas[4][4]={{'1','2','3','/'}, // valores correspondientes al
{'4','5','6','*'}, //teclado matricial
{'7','8','9','-'},
{'C','0','=','+'}};
int i,k;
while(1)
{
for(i=0;i<4;i++)
{
output_high(R*8+4+i);
for(k=0;k<4;k++)
{
delay_us(1000); // retardo para no recargar al proteus
if(input(R*8+k))
{
while(input(R*8+k)==1);
output_low(R*8+4+i);
delay_ms(t);
return teclas[k][i];
}
}
output_low(R*8+4+i);
}
}
}
//--------------------------------------------------------
void pide_rpm()
{
p = &d; // puntero a d
int i = 0;
int16 dato[]= {0,0,0,0};

while(true){
d = teclado(puerto,t); // llama al teclado y se recoge la tecla en d

// si la tecla pulsada es un numero, entonces se convierte a entero debido a que

est en ASCII
if((i!=4)&&((d=='0')||(d=='1')||(d=='2')||(d=='3')||(d=='4')||(d=='5')||(d=='6')||
(d=='7')||(d=='8')||(d=='9'))){

dato[i] = atoi(p);

if(i==0){rpm = dato[0];}
if(i==1){rpm = dato[0]*10 + dato[1];}
if(i==2){rpm = dato[0]*100 + dato[1]*10 + dato[2];}
if(i==3){rpm = dato[0]*1000 + dato[1]*100 + dato[2]*10 + dato[3];}

lcd_putc('\f');
lcd_gotoxy(1,1);
printf(lcd_putc,"CONTROL DE VEL.");
lcd_gotoxy(1,2);
printf(lcd_putc,"Ingrese RPM: ");
 lcd_gotoxy(13,2);
printf(lcd_putc,"%Lu",rpm);
i++;

}
if((d=='C')&&(i!=0)){
return;
}

}
}
//*******************************************************************
void proceso() {

Ek = 0; // entrada de error
Uk = 0; // salida del controlador
Uk1 = 0; // salida anterior del controlador
Ek1 = 0; // entrada de error anterior
Yk = 0; // salida del sistema
int i =0;

while(true){
set_adc_channel(0); // seleccionamos el canal por donde se recibe la seal
adc =read_adc();
delay_us(30);
Yk = adc*5.0/512.0;

Ek = step - Yk;
Uk = 3.5592*Ek - 3.256668*Ek1 + Uk1;
if(Uk > 10)
{ Uk = 10;}
if(Uk < 0 )
{ Uk = 0; }

Ek1 = Ek;
Uk1 = Uk;

sal_float = Uk*25.5;
sal_binaria = sal_float;
output_c(sal_binaria);

output_high(PIN_D4);
if(input(PIN_D3)==1){
output_c(0);
return;
}

i++;

if(i==10)
{
lcd_putc('\f');
lcd_gotoxy(1,1);
printf(lcd_putc,"I: %f O: %f",Yk,Uk);
lcd_gotoxy(1,2);
printf(lcd_putc,"R: %Lu S: %f",rpm,step);
i = 0;

}
 }
}
//*******************************************************************
void main()
{
output_c(0);
lcd_init();
setup_adc_ports(AN0); // configuramos AN0 como entrada analgica
setup_adc(ADC_CLOCK_INTERNAL);// Escogemos el reloj interno RC para el
//conteo

while(true){
lcd_putc('\f');
lcd_gotoxy(1,1);
printf(lcd_putc,"CONTROL DE VEL.");
lcd_gotoxy(1,2);
printf(lcd_putc,"Ingrese RPM: ");

pide_rpm();
step = 0.003*rpm + 1.07; // rpm a voltios
proceso();
}
}

CONCLUSIONES

Siguiendo las reglas para la obtencin experimental de modelos

podemos identificar los parmetros de la respuesta de la planta a
un step y con ello encontrar la funcin de transferencia de la
planta.
 El diseo del controlador a travs de PID proporciona una ventaja
al poder obtener unos parmetros que se pueden variar, si la
respuesta an no cumple con los criterios establecidos.

En algunos casos cuando la funcin de transferencia no tiene la

forma adecuada para disearla a travs de algn mtodo, se hace
necesario aplicar redundancia para hacer mas sencillo el trabajo;
en este caso se aplic un retardo muy pequeo para pasar la
funcin de transferencia de primer a segundo orden y poder
aplicar el mtodo de cancelacin de polos y ceros.

El diseo de sistemas de control en digital proporciona ms

comodidad y mejor desempeo en el uso de las interfaces de
usuarios y de la manipulacin de los datos para el procesamiento.

BIBLIOGRAFIA

Ingeniera de control moderna, 3. Edicin, Katsuhiko Ogata.

Sistemas de control automtico, 7. Edicin, Benjamin C. Kuo.

Generadores y motores de c.c, Ruben Andrade