Simulacin de un motor de DC, diseo y aplicacin de controlador PID

La funcin de transferencia de un Motor de DC, en el dominio de Laplace est definida como

sigue:

Iniciamos el modelado en MATLAB de la funcin de transferencia del motor con los siguientes
parmetros:

J = 0.01;
b = 0.1;
K = 0.01;
R = 1;
L = 0.5;
s = tf('s');
P_motor = K/((J*s+b)*(L*s+R)+K^2);

Del cual, la respuesta al escaln es como sigue:

En la respuesta al escaln se observa una sobre elongacin muy grande, que en algunos casos
puede daar al sistema en cuestin, adems se observa tambin un error en estado estable muy
grande. Por estos motivos es necesario aplicar control al sistema.
El diagrama de bloques del sistema con control en lazo cerrado es:

Los criterios de diseo para el controlador sern:

Eliminar la sobre elongacin, como proteccin al sistema.

Un error en estado estable menor al 2%

Con un control proporcional podemos disminuir el error en estado estable, pero tambin el
control proporcional a menudo resulta en el aumento de la sobre elongacin, por lo tanto, los
requerimientos del sistema no se podrn cubrir solo con un controlador proporcional y
optaremos por diseo de un controlador PID

La funcin de transferencia de un controlador PID es:

La adicin de un trmino integral eliminar el error de estado estacionario y un trmino

derivativo a menudo reducir la sobre elongacin. Vamos a tratar con un controlador PID con Ki
y Kd pequeas
Kp = 75;
Ki = 1;
Kd = 1;

C = pid(Kp,Ki,Kd);
sys_cl = feedback(C*P_motor,1);
step(sys_cl,[0:1:200])
En la respuesta anterior al escaln del sistema con control PID con Ki y Kd pequeas podemos
observar que, en efecto, la sobre elongacin desaparece y el error en estado estable se aproxima a
cero, pero el tiempo de asentamiento se incrementa demasiado.

Ajustando las ganancias

En este caso, grfico de respuesta es debido al hecho de que la ganancia integral es pequea y,
por lo tanto, se necesita mucho tiempo para la accin integral para construir y eliminar el error
de estado estable. Este proceso se puede acelerar aumentando el valor de Ki.
Kp = 100;
Ki = 200;
Kd = 1;
C = pid(Kp,Ki,Kd);
sys_cl = feedback(C*P_motor,1);
step(sys_cl, 0:0.01:4
Como se esperaba, el error en estado estable desapareci mucho ms rpido que antes. Sin
embargo, la ganancia Ki tan grande ha aumentado la sobre elongacin. Ahora incrementemos la
ganancia Kd en un intento por reducir la sobre elongacin.
Kp = 100;
Ki = 200;
Kd = 10;
C = pid(Kp,Ki,Kd);
sys_cl = feedback(C*P_motor,1);
step(sys_cl, 0:0.01:4)

Como se esperaba, el incremento de la ganancia Kd redujo la sobre elongacin resultante. Ahora

sabemos que si usamos un controlador PID con ganancias
Kp = 100, Ki = 200, and Kd = 10

Todos los requerimeitnos de nuesto diseo sern cumplidos.

Simulacin en tiempo real

La simulacin de la funcin de transferencia en tiempo real se realiz mediante el software
MATLAB y la adquisicin de datos (funcin escaln) as como la salida (respuesta al escaln
del sistema) se realizaron por medio de la tarjeta de desarrollo Arduino MEGA 2560.
El cdigo necesario para la simulacin en tiempo real es el siguiente:
%%Limpieza de variables y cierre de figuras previas
clc; close all;
clear all;

%%Conexion con la placa Arduino mediante puerto serial

ar=arduino('COM4');

%%Frecuencia de muestreo de la seal de entrada

Fs=50;
%%Numero de muestras por visualizacin
N=1000;
%Inicializacion de los vectores de muestras en cero
u=zeros(N,1);
y=zeros(N,1);
y_pid=zeros(N,1);
y_pid_pwm=zeros(N,1);

%%Definicion de la variable de timpo en intervalos de 1/Fs

t=linspace(0,(N-1)/Fs,N);

%%Declaracion de las lineas del grafico de simulacin

l1=line(nan,nan,'Color','r', 'LineWidth',1);
l2=line(nan,nan,'Color','b', 'LineWidth',1.5);
l3=line(nan,nan,'Color','g', 'LineWidth',1.5);
l4=line(nan,nan,'Color','y', 'LineWidth',1);

%%Establecimiento de los limites del grafico en amplitud y eje de tiempo

ylim([-2 7])
xlim([0 (N-1)/Fs])

grid
%%Condicin de paro para el bucle de simulacin
Stop=1;

%%Definicin de la funcion de transferencia.

J = 0.01;
b = 0.1;
K = 0.01;
R = 1;
L = 0.5;
s = tf('s');
H = K/((J*s+b)*(L*s+R)+K^2);

%%Aplicacion del control PID al motor en lazo cerrado

Kp = 100;
Ki = 200;
Kd = 10;
C = pid(Kp,Ki,Kd);
H_pid= feedback(H,1);

%%Discretizacin de la funcin de transferencia para utilizar mtodo de

%%diferencias finitas para su visualizacin
Hd=c2d(H,1/Fs);
a=Hd.den{1};
a1=a(2); a2=a(end);
b=Hd.num{1};
b1=b(2); b2=b(end);
Hd_pid=c2d(H_pid,1/Fs);
c=Hd_pid.den{1};
c1= c(2); c2=c(end);
d=Hd_pid.num{1};
d1= d(2); d2=d(end);

%%Interfaz de usuario con botn de paro para detener la simulacin,

adquisicin y escritura de datos.
uicontrol('Style','Pushbutton','String','Detener','Callback','Stop=0;')

%%Inicializacin del contador de tiempo

tic;
%%Bucle infinito de simulacin
while Stop
%Condicion de timepo para el periodo de muestreo
if toc>1/Fs
tic;
%%Intercambio de muestras
u(1:end-1)=u(2:end);
y(1:end-1)=y(2:end);
y_pid(1:end-1)=y_pid(2:end);
y_pid_pwm(1:end-1)=y_pid_pwm(2:end);

%%Calculo de los valores mediante el mtodo de diferencias finitas.

y(end)= -a1*y(end-1)-a2*y(end-2)+b1*u(end-1)+b2*u(end-2);
y_pid(end)= -c1*y_pid(end-1)-c2*y_pid(end-2)+d1*u(end-1)+d2*u(end-2);

%%Adquisicin de datos desde la placa Arduino

u(end)=ar.analogRead(0)*5/1023;

%%Definicin del ciclo de trabajo de la seal PWM usada para tener

%%una seal analgica que pueda ser filtrada con a fin de mostrarse
%%en el osciloscopio Valores entre 0 y 255
if (round(y_pid(end)*51)<0)
dutty = 0;
else
if(round(y_pid(end)*51)>255)
dutty = 255;
else
dutty= round(y_pid(end)*51);
end
end
%%Escritura de la seal analgica PWM
ar.analogWrite(9,dutty);

%%Graficas de la simulacin
set(l1,'XData',t,'YData',u); %%Seal escalon proveniente del exterior
set(l2,'XData',t,'YData',y); %% Respuesta del Motor de DC sin PID
set(l3,'XData',t,'YData',y_pid); %%Respuesta del Motor despus del PID
drawnow
end
end