MATLAB

• Programa orientado al cálculo y operaciones con matrices

• Funcionamiento en línea de comandos y con ficheros de instrucciones o
programas Matlab

Fundamentos:

» a=4/3

a=

1.3333

Almacena en la variable a el valor 1.3333 y lo saca por pantalla

a=4/3;

Lo mismo que en el caso anterior. Almacena el valor pero no lo saca por

pantalla (por el ;)

Se pueden utilizar variables que ya tienen un valor en expresiones.

» b=1.34*37;
» c=b-a

c=

48.2467

Para recordar órdenes previas y corregir letras dentro de una orden utilizamos
las teclas de los cursores.
Las variables pueden tener como máximo 19 caracteres ( a-z, A-Z, 0-9, _ ), y la
primera debe ser una letra.
MATLAB es sensible a las mayúsculas y minúsculas (las distingue).
Cualquier cosa que venga después del carácter % se interpreta como un
comentario
Borrado de variables:
• clear: borramos TODAS del espacio de trabajo.
 • clear a b c: borramos las variables a b c
Guardar en disco el espacio de trabajo.
• File / Save Workspace As
• save :
Cargar en Memoria.
• File / Load Workspace
• load fichero
Forma de trabajo:
En MATLAB podemos trabajar bien con las instrucciones en la línea de
comandos, o bien creando unos ficheros *.m, programados en un lenguaje
interpretado propio de MATLAB.

Matrices y vectores

A=[1 2 3; 4 5 6; 7 8 9]

A=

1 2 3
4 5 6
7 8 9

Separar los elementos por espacios o comas específica elementos en

diferentes columnas; separar elementos por puntos y comas específica
elementos en filas diferentes.

B=[-1.3 sqrt(3) 3^2.5]

B=

-1.3000 1.7321 15.5885

Los elementos de una matriz o vector pueden ser expresiones.

» C=A*B
??? Error using ==> *
Inner matrix dimensions must agree.

Las dos matrices no se pueden multiplicar pues B debería ser un vector

columna y es un vector fila. Con ‘ calculamos la transpuesta.
B=

-1.3000 1.7321 15.5885

» B'

ans =

-1.3000
1.7321
15.5885

Luego podemos hacer

» C=A*B'

C=

48.9295
96.9910
145.0525

Selleción de elementos en matrices

» D=A(1:2,:)

D=

1 2 3
4 5 6

Forma una matriz D con las dos primeras filas de A y todas sus columnas

» E=A(2:3,1:2)

E=

4 5
7 8

Forma matriz E con las filas 2 y 3 y las columnas 1 y 2 de A.

» A(:,[1 3])
ans =

1 3
4 6
7 9

Forma una matriz con las columnas 1 y 3 de A.

» 1:10

ans =

1 2 3 4 5 6 7 8 9 10

Crea un vector de 10 con los valores de 1 a 10

» 1:0.2:2

ans =

1.0000 1.2000 1.4000 1.6000 1.8000 2.0000

En este caso a:i:b especifica el uso del incremento i

» logspace(1,2,10) %Crea vector de 10 elementos entre 10^1 y 10^2

Columns 1 through 7

10.0000 12.9155 16.6810 21.5443 27.8256 35.9381 46.4159

Columns 8 through 10

59.9484 77.4264 100.0000

» who

Your variables are:

A C E ans c
B D a b

Muestra el valor de las variables inicializadas presentes en la memoria.

El comando help nos muestra las toolbox instaladas de las que podemos
solicitar ayuda. Nos indica el directorio donde se encuentran. Si escribimos
help control por ejemplo nos muestra todas las funciones disponibles en la
toolbox de control.

» help control

Control System Toolbox.

Version 4.2 (R11) 15-Jul-1998

What's new.
Readme - New features and enhancements in this version.

Creation of LTI models.

tf - Create a transfer function model.
zpk - Create a zero/pole/gain model.
ss - Create a state-space model.
…….

Demonstrations.
ctrldemo - Introduction to the Control System Toolbox.
jetdemo - Classical design of jet transport yaw damper.
diskdemo - Digital design of hard-disk-drive controller.
milldemo - SISO and MIMO LQG control of steel rolling mill.
kalmdemo - Kalman filter design and simulation.

Podemos obtener ayuda de alguna función en particular.

» help sqrt

SQRT Square root.

SQRT(X) is the square root of the elements of X. Complex
results are produced if X is not positive.

See also SQRTM.

Overloaded methods
help sym/sqrt.m

Escribiendo doc funcion nos da documentación sobre el manejo de la funcion.

Ej doc sqrt

Veamos algunas funciones para construir matrices

» zeros(2,3)

ans =
 0 0 0
0 0 0

Crea una matriz de 2*3 de ceros

» ones(4,2)

ans =

1 1
1 1
1 1
1 1

Matriz 4+2 de unos

» eye(5)

ans =

1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

Matriz identidad 5*5

» rand(10,2)

ans =

0.9501 0.6154
0.2311 0.7919
0.6068 0.9218
0.4860 0.7382
0.8913 0.1763
0.7621 0.4057
0.4565 0.9355
0.0185 0.9169
0.8214 0.4103
0.4447 0.8936

Matriz 10*2 de números aleatorios entre 0 y 1.

% Operaciones con matrices.

A = [1 2 3]; B = [1 0 -1];
A+B % Suma de vectores
A + 100 % El 100 se suma a cada elemento
A * B' % Producto escalar
A' * B % El producto externo es una matriz
A .* B % Utilizar “.” Para especificar producto de elementos
[1:10] .^ 2 % Eleva cada número al cuadrado
D = rand(5,3) % Crea vector de números aleatorios
sum(D) % Suma las columnas de D
sum(D(:)) % Suma todos los elementos de D
help elfun % Lista todas las funciones elementales
(exp,round,etc...)

Operadores relacionales

< menor que

<= menor o igual que
> mayor que
>= mayor o igual que
== igual que
~= distinto de
~ not

% Más funciones

det(x) % Determinate de la matriz x

trace(x) % Suma de los elementos de la diagonal

Los polinomios se representan como vectores. Así x2+3x+1 se puede

representar por el vector [1 3 1].

polyval(p,1) % Devuelve el resultado de evaluar el polinomio p para x=1

» p=[1 3 1];
» polyval(p,1)

ans =

roots(p) % calcula las raíces del polinomio p

» roots(p)

ans =
 -2.6180
-0.3820

poly(A) % Si A es una matriz devuelve el polinomio |λI-A|

% Si A es un vector el polinomio de las raices (x-r1)(x-r2)(x-r3)…

» poly([1 2])

ans =

1 -3 2
% Es el producto de (x-1)(x-2)

conv(p1,p2) % Producto de polinomios p1 y p2

[q,r]=deconv(p1,p2) % Divide dos polinomios y calcula cociente (q) y resto (r)

Otras funciones

sin(a) % Seno de a (en radianes)

cos(a) % Coseno de a (en radianes)
tan(a) % Tangente de a (en radianes)
asin(x) % Arco seno de x
acos(x) % Arcos coseno de x
atan(x) % Arco tangente de x
log(x) % Logaritmo neperiano de x
log10(x) %logaritmo decimal de x

abs(x) % Valor absoluto de x. Si x es complejo se obtiene el módulo

» abs(3+4*i)

ans =

angle(x) % Si x es complejo devuelve la fase en radianes

» angle(3+4*i)

ans =

0.9273
real(x) % Parte real de un numero x
imag(x) % Parte imaginaria de x

Búsqueda de elementos:
>>A=[8 2 -3; 4 -5 6];
>>[i,j]=find(A>5) % Devuelve los índices de los elementos de A mayores de
5
>>max(A) % Devuelve el máximo de cada columna
>>min(A) % Devuelve el mínimo de cada columna

Control de flujo:
MATLAB posee una serie de sentencias que nos permiten alterar el flujo
secuencial de una función. En el editor las instrucciones de los bucles aparecen
de color azul.
Bucle For
for i=1:5
ordenes
end
También pueden anidarse varios bucles.
Estructura if
if expr1
ordenes1
elseif expr2
ordenes2
else
ordenes3
end

Bucle while
while expresion
ordenes
end

break
Sentencia que nos permite saltar o salir de un bucle while o for. Si hay bucles
anidados, únicamente se abandona el bucle más interno.
Introducción de valores por teclado:
a=input('número de manzanas: ')
número de manzanas: 3
Para visualizar un determinado texto por pantalla:
disp(‘Introducir los siguientes datos :’)
fprintf(‘adios\n\n’)
Las cadenas de caracteres se deben escribir entre comitas ‘ ‘, y en el editor
aparece en rojo.

Creación de funciones

Otra forma de utilización de los archivos *.m: En el caso que deseemos realizar
cálculos donde utilizamos varias órdenes y deseamos cambiar el valor de
alguno de los argumentos, en lugar de volver a escribir cada vez estas órdenes
en la línea de comandos, MATLAB nos proporciona la capacidad de agrupar
todas las órdenes dentro de un archivo que debe cumplir las siguientes
características:
* El archivo debe crearse con un editor de tipo ASCII
* La extensión del archivo debe ser *.m (mifunción.m)
* El archivo debe encontrarse en un directorio conocido por MATLAB.
* El nombre del archivo no debe coincidir con algún comando de
MATLAB, ya que estos tienen prioridad y el programa no se ejecutará.
En cuanto a la escritura del código de la función dentro del archivo deberemos
tener en cuenta los siguientes puntos:
* La primera línea debe declarar el archivo como de tipo función, y se
deben indicar los argumentos de dicha función y sus valores devueltos.
Los valores devueltos pueden ser uno o varios, en cuyo caso deben
escribirse entre corchetes.
function [res1,res2,...]=mifuncion(arg1,arg2,...)
* La segunda línea debe ser de comentario (se denomina línea H1), y en
ella se debe dar una breve descripción de lo que hace la función. Esta
línea es examinada por la orden de búsqueda de ayuda lookfor.
%MIFUNCION esta es mi maravillosa función
Así cuando desde la línea de comandos ejecutemos la orden lookfor
obtendremos lo siguiente:
>>lookfor maravillosa
MIFUNCION esta es mi maravillosa función
* A partir de la segunda línea de comentario el resto de líneas que sean
 de comentario hasta la primera línea de no comentario, serán las
mostradas cuando pidamos ayuda de la función con el comando
>>help mifuncion.
* Las variables creadas dentro de la función son locales, y se destruyen
al abandonar la función.
* Los argumentos que recibe la función son pasados por referencia a
menos que se alteren dentro de la función, en cuyo caso se pasa una
copia (para no alterar el valor).
* El número de parámetros pasados a la función está disponible en la
variable llamada nargin; esto puede tener utilidad para establecer
valores por defecto.
El número de variables de salida está disponible en la variable nargout.

Ejemplos de funciónes:

% Incicializa matriz con suma de índices

% El símbolo “%” indica comienzo de comentario en la línea

function M=inicializa(m,n)
for k=1:m
for l=1:n
M(k,l)=k+l;
end
end

%Funcion amort(M)
% Determina el coeficiente de amortiguamiento a partir del sobrepico
% Argumentos:
% M: Sobrepico

function [] = amort(M)
c=- log(M) / sqrt((log(M)^2)+pi^2)

%Funcion spico(c)
% Determina el sobrepico a partir el coeficiente de amortiguamiento
% Argumentos:
% c: coefieciente de amortiguamiento

function [] = spico(c)

Mp=exp(-pi*c/sqrt(1-c*c))
Creando dibujos

plot(v) ; % dibuja vector v

plot(x,y); % dibuja vector y (ordenadas) frente a vector x (abcisas)

plot(x1,y1,x2,y2,x2,y3); % dibuja 3 gráficos en una pantalla

plot(X,Y) % Si X e Y son matrices, dibuja tantos graficos como columnas de

% X frente a las columnas de Y

% Construimos un ejemplo:
>> t=[0:0.2:2*pi];
>> x=sin(t);
>> y=cos(t);
>> figure(1);
>> plot(t, x, '+', t, y, '*')
>> figure(2)
>> plot(t, x, 'r+', t, y, 'm*')

1 1

0.8 0.8

0.6 0.6

0.4 0.4

0.2 0.2

0 0

-0.2 -0.2

-0.4 -0.4

-0.6 -0.6

-0.8 -0.8

-1 -1
0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7

FIGURE (1) FIGURE (2)

Otras funciones relacionadas son:

>>xlabel(‘string’)
>>text(x,y,’string’)
>>title(‘string’)
>>gtext % Permite poner textos en posiciones específicas
>>axis[xmin xmax ymin ymax]
>>grid % crea regilla
>>subplot(m,n,p) % crea ventana mxn y elige zona p para dibujar
>>hold on % La siguiente figura se imprime enciam de la anterior
>>polar(teta, ro) %dibuja en coordenadas polares
>>semilogx % igual que plot pero el ejex está en escala logarítmica
>>bar
>>stairs

Ejemplo

>>subplot(211),plot(1:3),subplot(212),(plot(sin(1:3));

Dibujos en tres dimensiones

» [X,Y] = meshgrid(-2:.2:2, -2:.2:2);

»Z = X .* exp(-X.^2 - Y.^2);
»mesh(Z)
» figure
» contour(Z)

Funciones de Control

Y(s)= G(s)= . 18(s+20) .

U(s) (s+15)(s+25)(s+0.4)

» num=18*[1 20];
» den=conv(conv([1 15],[1 25]),[1 0.4]);
» printsys(num,den)

num/den =

18 s + 360
----------------------------
s^3 + 40.4 s^2 + 391 s + 150
» wn=2;
» damping=0.707;
» [num,den]=ord2(wn,damping);
» printsys(num,den,'s')

num/den =

1
-----------------------
s^2 + 2.828 s + 4

Construyendo sistemas

s+1
(s+3)(s+5)

» ngo=[1 1];
» dgo=conv([1 3],[1 5]);
» [ngc1,ngc2]=cloop(ngo,dgo);

s+1
(s+3)(s+5)
s+6
(s+10)

» ngo=[1 1];
» dgo=conv([1 3],[1 5]);
» nh=[1 6];
» dh=[1 10];
» [ngc2,dgc2]=feedback(ngo,dgo,nh,dh);
» printsys(ngc2,dgc2,'s')

num/den =

s^2 + 11 s + 10
-------------------------------------
s^3 + 19 s^2 + 102 s + 156

para bloques funciones: series, parallel, blkbuild,connect

Lugar de las raices

G(s)=(s+2)/)(s2+6s+10)

» num=[1 2];
» den=[1 6 10];
» rlocus(num,den)

0.8

0.6

0.4

0.2
Imag Axis

-0.2

-0.4

-0.6

-0.8

-1
-5 -4 -3 -2 -1 0 1 2
Real Axis

» [k,polos]=rlocfind(num,den)
Select a point in the graphics window

selected_point =

-3.3065 + 0.5322i

k=

0.6195

polos =

-3.3097 + 0.5335i
-3.3097 - 0.5335i

0.8

0.6

0.4

0.2
Imag Axis

-0.2

-0.4

-0.6

-0.8

-1
-5 -4 -3 -2 -1 0 1 2
Real Axis
Se puede especificar nº complejo próximo al lugar de las raices en vez de
seleccionar con el ratón.

[r,k]=rlocfind(num,den,p);

Ceros y Polos

G(s)=(3s4+3s3+5s2+4s+6)/(s5+3s4+4s3+2s2+7s+2)

» num=[3 2 5 4 6];
» den=[1 3 4 2 7 2];
» [z,p,k]=tf2zp(num,den)

z=

0.4019 + 1.1965i
0.4019 - 1.1965i
-0.7352 + 0.8455i
-0.7352 - 0.8455i

p=

-1.7680 + 1.2673i
-1.7680 - 1.2673i
0.4176 + 1.1130i
0.4176 - 1.1130i
-0.2991

k=

Función de transferencia a partir de ceros y polos

» z=[0; 0; 0; -1];
» p=[-1+i -1-i -2 -3.15+2.63*i -3.15-2.63*i];
» k=2;
» [num,den]=zp2tf(z,p',k)

num =

0 2 2 0 0 0
den =

1.0000 10.3000 48.0394 109.1576 126.2364 67.3576

Respuesta temporal

Escalón

» grid on
» step(num,den)

Step Response
From: U(1)
0.15

0.1

0.05
Amplitude
To: Y(1)

-0.05

-0.1
0 0.5 1 1.5 2 2.5 3 3.5

Time (sec.)

se puede especificar el tiempo:

» step(num,den,0:0.1:10)

se puede obtener los valores para luego tratarlos

» [y,x,t]=step(num,den,0:0.1:10);
» plot(t,y);

Impulso:

» impulse(num,den)

Entradas arbitrarias

» [num,den]=zp2tf([-2],[-1 -0.2+10*i -0.2-10*i],100);

» t=[0:0.1:20];
» u=exp(-t);
» lsim(num,den,u,t)

Si se quiere ver la salida con la entrada

» y=lsim(num,den,u,t);
» plot(t,u,t,y)

1.5

0.5

-0.5
0 2 4 6 8 10 12 14 16 18 20

Cálculo de tiempo de pico, sobrepico, tiempo de subida y tiempo de

establecimiento.

% Función para el cálculo de los parámetros característicos de

% la respuesta temporal de un sistema a un escalón unitario
% Formato de llamada: paso(num,den)
% num: numerador de la función de transferencia
% den: denominador de la función de transferencia

function [] = paso(num,den)
[numexp,denexp]=cloop(num,den)
step(numexp,denexp)
pause
valorfinal=polyval(numexp,0)/polyval(denexp,0)
[y,x,t]=step(numexp,denexp);
[Y,kexp]=max(y);
tiempopico=t(kexp)
sobrepaso=100*(Y-valorfinal)/valorfinal

n=1;
while y(n)<0.1*valorfinal, n=n+1; end

m=1;
while y(m)<0.9*valorfinal, m=m+1; end
tiempo_subida=t(m)-t(n)

l=length(t);
while (y(l)>0.98*valorfinal)&(y(l) < 1.02*valorfinal)
l=l-1;
 end
tiempo_establecimiento=t(l)

» paso(num,den)
numexp =
0 0 1
denexp =
1 1 2
valorfinal =
0.5000
tiempopico =
2.4294
sobrepaso =
30.4117
tiempo_subida =
0.8834
tiempo_establecimiento =
7.7300

Dibujos en el dominio de la frecuencia

» num=[5.9 53,.8 197.3 388.6];

» den=[1 13 58 306 260];
» bode(num,den)
» gris

Bode Diagrams

From: U(1)
30

20
Phase (deg); Magnitude (dB)

10

-10

-100
To: Y(1)

-200

-300

-400
10-1 100 101 102

Frequency (rad/sec)

» subplot(211),nyquist(num,den)
» z=[-2 -2+5*i -2-5*i];
» p=[-1 -5 -7 -1+7*i -1-7*i];
» k=30;
» subplot(211),nyquist(num,den)
» subplot(212),axis([-360 0 -40 30]);
» nichols(num,den)
» ngrid

Nyquist Diagrams
From: U(1)
20

Imaginary Axis
10

To: Y(1)
0

-10

-20
-8 -6 -4 -2 0 2 4 6 8

Real Axis
Nichols Charts
From: U(1)
30
Open-Loop Gain (dB)
20
To: Y(1)
10

-10
-400 -350 -300 -250 -200 -150 -100 -50 0

Open-Loop Phase (deg)

Obteniendo información

» num=10*[1 1];
» den=conv([1 -1+5*i],[1 -1-5*i]);
» bode(num,den)
» [mag,phase,w]=bode(num,den);
» [Mp,k]=max(mag)

Mp =

5.0767

k=

29

» wp=w(k)

wp =

5.1784

» n=1;
» while 20*log10(mag(n))>=-3,n=n+1;end
» anchobanda=w(n)

anchobanda =

0.1000

Margen de fase y margen de ganancia

» [Gm,Pm,Wcg,Wcp]=margin(num,den)
Gm =

0.2000

Pm =

73.7398

Wcg =

5.2915

Wcp =

12.0000

Bode Diagrams

Gm=-13.979 dB (at 5.2915 rad/sec), Pm=73.74 deg. (at 12 rad/sec)

20

10
Phase (deg); Magnitude (dB)

-10

-20

300

200

100

-100

-200
10-1 100 101 102

Frequency (rad/sec)

Ejemplo función:

%Funcion mibode(num,den,d1,d2)
% Dibuja diagrama de bode en un ranfo de frecuencias
function [] = mibode(num,den,d1,d2)
w=logspace(d1,d2,d2-d1*100);
[mag,fase,w]=bode(num,den,w);
semilogx(w,20*log10(mag));
ylabel('Ganancia dB');
xlabel('Frecuencia (rad/seg)');
grid
axis tight
figure
semilogx(w,fase);
ylabel('Fase en grados');
xlabel('Frecuencia (rad/seg)');
grid

» mibode(num,den,-1,2)

Representación mediante objetos

» num=1;
» den=[1 1 1];
» sys=tf(num,den)

Transfer function:
1
---------------

s^2 + s + 1

» sys1=zpk(z,p,k)

Zero/pole/gain:
29 (s+2) (s^2 + 4s + 29)
---------------------------------
(s+1) (s+5) (s+7) (s^2 + 2s + 50)

Funciones similares a las vistas: bode(sys), rlocus(sys), …

Operaciones más sencillas

2 bloques en serie

» sys*sys1

Zero/pole/gain:
29 (s+2) (s^2 + 4s + 29)
-----------------------------------------------
(s+1) (s+5) (s+7) (s^2 + s + 1) (s^2 + 2s + 50)

dos bloques en paralelo

» sys*sys1

Zero/pole/gain:
29 (s+2) (s^2 + 4s + 29)
-----------------------------------------------
(s+1) (s+5) (s+7) (s^2 + s + 1) (s^2 + 2s + 50)

» feedback(sys1,sys)

Zero/pole/gain:
29 (s+2) (s^2 + s + 1) (s^2 + 4s + 29)
---------------------------------------------------------------------------
(s+6.81) (s+5.292) (s+1.334) (s^2 + 0.5767s + 1.434) (s^2 + 1.988s + 49.79)

Programa compensación en Adelanto:

% Compensacion en adelanto
% Formato: adelanto(num,den,tipo)
% tipo: 'alfa' Red adelanto alfa min
% 'vertical' Red adelanto polo en vertical
% 'compen' Red de adelanto por compensación
% 'pd' P
function [numct,denct] = adelanto (num,den,tipo)

capa=input('Introduce coef amortiguamiento ');

wn=input('Introduce frecuencia natural ');

% Polos Dominantes

s1=-capa*wn+wn*sqrt(1-capa*capa)*i

ang=angle(polyval(num,s1)/polyval(den,s1))*180/pi

% Contribucion angular Compensador

if ang<0
printf('No necesita compensar\n');
exit(1);
else
cang=180-ang
end

if(nargin == 2), %Por defecto alfa min

tipo='alfa';
end

n=1;

%%%%%%%%% RED DE ADELANTO %%%%%%%%%%%%%%%%%

if tipo(1) == 'a'

echo on
% Red adelanto alfa min
echo off

if cang > 60
pause % Dos controladores en cascada
n=2;
cang=cang/2;
cang
end

theta=180-angle(s1)*180/pi
gamma=0.5*(180-theta-cang)
zc=sin(gamma*pi/180)*wn/sin((180-theta-gamma)*pi/180);
pc=sin((gamma+cang)*pi/180)*wn/sin((180-theta-gamma-cang)*pi/180);

numc=[1 zc];
denc=[1 pc];
kc=abs(polyval(den,s1))*abs(polyval(denc,s1))^n/((abs(polyval(num,s1))
*abs(polyval(numc,s1))^n));

pause
if(n==2)
kc=sqrt(kc)
printsys(numc,denc,'s'); printsys(numc,denc,'s');
else

kc=kc
printsys(numc,denc,'s');
end
end

%%% Fin red de adelanto %%%%%%

%%% Compensador por cancelación

if (tipo(1)=='c')
echo on
% Compensación por cancelación
echo off
zc=input('Introduce posición del polo a cancelar ');

if cang > 60
pause % Dos controladores en cascada
n=2;
cang=cang/2;
cang
end

numc=[1 -zc];

angnum=angle(polyval([1 -zc],s1))*180/pi;
zp=-real(s1)+imag(s1)/tan((angnum-cang)*pi/180);
denc=[1 zp];
kc=abs(polyval(den,s1))*abs(polyval(denc,s1))^n/((abs(polyval(num,s1))
*abs(polyval(numc,s1))^n));
kc=abs(kc);

if(n==2)
kc=sqrt(kc)
printsys(numc,denc,'s'); printsys(numc,denc,'s');
else

kc=kc
printsys(numc,denc,'s');
end
end
%% Fin compensador de cancelación

%% Compensador enla vertical

if (tipo(1)=='v')
echo on
% Compensación en la vertical
echo off

if cang > 60
pause % Dos controladores en cascada
n=2;
cang=cang/2;
cang
end

zc=-real(s1)

numc=[1 zc];

angnum=angle(polyval([1 zc],s1))*180/pi;
zp=-real(s1)+imag(s1)/tan((angnum-cang)*pi/180);
denc=[1 zp];

kc=abs(polyval(den,s1))*abs(polyval(denc,s1))^n/((abs(polyval(num,s1))
*abs(polyval(numc,s1))^n));
kc=abs(kc);

if(n==2)
kc=sqrt(kc)
printsys(numc,denc,'s'); printsys(numc,denc,'s');
else

kc=kc
printsys(numc,denc,'s');
end

end
%% Fin compensador en la vertical

%%%%%% CONTROLADO PD %%%%%%%%%%%%%%%%5

if tipo(1) == 'p'
echo on
% Compensador PD
echo off

zc=-real(s1)+imag(s1)/tan(cang*pi/180);
numc=[1 zc]
denc=[1];
kc=polyval(den,s1)/((polyval(numc,s1)*polyval(num,s1)));
kc=abs(kc)

% printsys(numc,[],'s');

end

%% Comprobación

if n==1
[numt,dent]=cloop(kc*conv(num,numc),conv(den,denc));
elseif n==2
[numt,dent]=cloop(kc*kc*conv(conv(num,numc),numc),conv(conv(den,denc),
denc));
end

roots(dent)

% Preparo argumentos
if(n==2)
kc=sqrt(kc)
printsys(numc,denc,'s'); printsys(numc,denc,'s');
numct=kc*conv(numc,numc);
denct=conv(denc,denc);
else
numct=kc*numc;
denct=denc;
end

Herramienta para compensación de sistemas: rltool

» num=4;
» den=conv([1 0],[1 2]);
» sys=tf(num,den);
» rltool(sys)

Permite añadir ceros, polos, variar la ganacia y observar la respuesta temporal

y frecuencial.
Sistemas Discretos

[NUMd,DENd] = C2DM(NUM,DEN,Ts,'method') converts the continuous-

time polynomial transfer function G(s) = NUM(s)/DEN(s) to discrete
time, G(z) = NUMd(z)/DENd(z), using 'method'.

'zoh' Convert to discrete time assuming a zero order

hold on the inputs.
'foh' Convert to discrete time assuming a first order
hold on the inputs.
'tustin' Convert to discrete time using the bilinear
(Tustin) approximation to the derivative.
'prewarp' Convert to discrete time using the bilinear
(Tustin) approximation with frequency prewarping.
Specify the critical frequency with an additional
argument, i.e. C2DM(A,B,C,D,Ts,'prewarp',Wc)
'matched' Convert the SISO system to discrete time using the
matched pole-zero method.

Respuesta temporal ante un escalón para diferentes periodos de muestreo.

1
s(s+1)

%% Ejemplo respuesta temporal

num=1;
den=[1 1 0];

[numc,denc]=cloop(num,den);

hold off
step(numc,denc);
pause

% Paso a discreto con diferentes periodos de muestreo

Ts=0.5;
t=0:0.5:10;

[numd,dend]=c2dm(num,den,Ts,'zoh');
[numdc,dendc]=cloop(numd,dend);
hold on
dstep(numdc,dendc,t);

Ts=0.1;
t=0:0.1:10;

[numd,dend]=c2dm(num,den,Ts,'zoh');
[numdc,dendc]=cloop(numd,dend);
dstep(numdc,dendc,t);

Ejercicio: Dibujar el lugar geométrico de las raices para Ts=0.5s, T=1s, T=2s.
Determinar el valor crítico de k y localizar los polos de lazo cerrado en los tres
casos.

1
s(s+1)

Ejercicio: Dado el controlador siguiente obtener una función matlab de forma

que dado una secuencia de errores en el tiempo almacenados en un vector se
obtenga la accion de control m.

13.93z-11.4077
G(z)=------------------------
z-0.15962

function [m]=control(e)
m(1)=13.93;
for i=2:length(e)

m(i)=0.1562*m(i-1)+13.93*e(i)-11.4077*e(i-1);
end;

%% Ejemplo diseño controladores

%% Planta G(s)=1/(s*(s+1))
%% Periodo de muestreo Ts=0.2
%% Coef amortiguamiento 0.5 frc natural 4.5345
%% Red de adelanto
%% Datos

num=1; % Planta
den=[1 1 0];

capa=0.5; % Especificaciones
wn=4.5345;
Ts=0.2; % Periodo de muestreo

% Polo dominante

s1=-capa*wn+wn*sqrt(1-capa*capa)*i;

% Diseño controlador continuo

zc=-1; % Posciono el polo de cancelación

numc=[1 -zc];

ang=angle(polyval(num,s1)/polyval(den,s1))*180/pi;
if ang<0 % Contribucion angular Compensador

cang=ang+180;
else
cang=180-ang;
end

angnum=angle(polyval([1 -zc],s1))*180/pi;
zp=-real(s1)+imag(s1)/tan((angnum-cang)*pi/180);
denc=[1 zp];

kc=abs(polyval(den,s1))*abs(polyval(denc,s1))/((abs(polyval(num,s1))*a
bs(polyval(numc,s1))));

fprintf('Controlador continuo\n');
printsys(kc*numc,denc);

[numcc,dencc]=cloop(kc*conv(num,numc),conv(den,denc));

step(numcc,dencc,0:0.05:2);

pause
% controlador continuo con mantenedor a entrada

num1=1;
den1=conv(den,[Ts/2 1]);

% Diseño controlador continuo

zc=-1; % Posciono el cero de cancelación

numc=[1 -zc];

ang=angle(polyval(num1,s1)/polyval(den1,s1))*180/pi;
if ang<0 % Contribucion angular Compensador

cang=ang+180;
else
cang=180-ang;
end

angnum=angle(polyval([1 -zc],s1))*180/pi;
zp=-real(s1)+imag(s1)/tan((angnum-cang)*pi/180);
denc=[1 zp];

kc=abs(polyval(den1,s1))*abs(polyval(denc,s1))/((abs(polyval(num1,s1))
*abs(polyval(numc,s1))));
fprintf('Controlador continuo con mantenedor a la entrada\n');
printsys(kc*numc,denc);

%% Discretizamos

[numcd,dencd]=c2dm(kc*numc,denc,Ts,'matched');

fprintf('Controlador discreto equivalente al continuo\n');

printsys(numcd,dencd,'z');

% Calculo G(z)

[numd,dend]=c2dm(num,den,Ts,'zoh');

printsys(numd,dend,'z');

% Lazo cerrado

[numdt,dendt]=cloop(conv(numd,numcd),conv(dend,dencd));

hold on
dstep(numdt,dendt,0:Ts:2);

pause
%% Calculo en digital directamente

z1=exp(Ts*s1); % Polo dominante en el plano z

% Diseño controlador discreto

zdc=exp(-1*Ts); % Posiciono el cero de cancelación

ndc=[1 -zdc];

ang=angle(polyval(numd,z1)/polyval(dend,z1))*180/pi
if ang<0 % Contribucion angular Compensador

cang=ang+180;
else
cang=180-ang;
end

angnum=angle(polyval([1 -zdc],z1))*180/pi;
zdp=-real(z1)+imag(z1)/tan((angnum-cang)*pi/180);
ddc=[1 zdp];

kdc=abs(polyval(ddc,z1))*abs(polyval(dend,z1))/((abs(polyval(ndc,z1))*
abs(polyval(numd,z1))));

fprintf('Controlador discreto diseño en z\n');

printsys(kdc*ndc,ddc,'z');

[numdt2,dendt2]=cloop(kdc*conv(ndc,numd),conv(ddc,dend));

dstep(numdt2,dendt2,0:Ts:2);

hold off
%% Ejemplo diseño controladores
%% Planta G(s)=exp(-2s)/s+1
%% Controlador difital PI Gd(z)=Kp+Ki (z/z-1)=Kd z-zz/(z-1)
%% Datos

num=1; % Planta
den=[1 1];

capa=0.5; % Especificaciones
n=10; % muestras por oscilación amortiguada
Ts=1;

% Polo dominante

z1=exp((-2*pi*capa/(sqrt(1-capa^2)*n) + i*2*pi/n))

% Calculo G(z)

[numd,dend]=c2dm(num,den,Ts,'zoh');
dend=conv(dend,[1 0 0]); % incluyo retraso 2 segundos

% Diseño controlador discreto

ddc=[1 -1]; % Posiciono el polo en z=1

ang=angle(polyval(numd,z1)/polyval(conv(dend,ddc),z1))*180/pi
if ang<0 % Contribucion angular Compensador

cang=ang+180;
else
cang=180-ang;
end

zz=-real(z1)+imag(z1)/tan(cang*pi/180);
ndc=[1 zz];

kdc=abs(polyval(ddc,z1))*abs(polyval(dend,z1))/((abs(polyval(ndc,z1))*
abs(polyval(numd,z1))));

fprintf('Controlador discreto diseño en z\n');

printsys(kdc*ndc,ddc,'z');

[numdt2,dendt2]=cloop(kdc*conv(ndc,numd),conv(ddc,dend));

roots(dendt2)

% Respuesta escalón
figure(1);
dstep(numdt2,dendt2,0:Ts:40);

kv=polyval((1/Ts)*kdc*conv(ndc,numd),1) /polyval(dend,1);
ess=1/kv

%respuesta a rampa
figure(2);
t=0:Ts:30;
u=t;
plot(t,u);
[Y]=dlsim(numdt2,dendt2,u);
hold on
stairs(t,Y);
title('Respuesta entrada escalón');
hold off
Espacio de estado

Cálculo de los autovalores de una matriz

A x= λ x

|A- λI|=0 valores propios

eig(A) si A es real y simétrica los valores propios son reales

A=[0 1; -1 0];
» eig(A)

ans =

0 + 1.0000i
0 - 1.0000i

Cálculo de autovalores y auto vectores

» A=[0 1 0; 0 0 1; -6 -11 -6];

» [X,D]=eig(A)

X=

-0.5774 0.2182 -0.1048

0.5774 -0.4364 0.3145
-0.5774 0.8729 -0.9435

D=

-1.0000 0 0
0 -2.0000 0
0 0 -3.0000

Forma de jordan

» A=[0 1 0; 0 0 1; 1 -3 3];
» [V,J]=jordan(A)
V=

1 -1 1
1 0 0
1 1 0

J=

1 1 0
0 1 1
0 0 1

Función de transferencia a espacio de estados

y(s)/u(s)=num/den=C(sI-A)-1B+D

» num=1;
» den=[1 1 1];
» [A,B,C,D]=tf2ss(num,den)

A=

-1 -1
1 0

B=

1
0

C=

0 1

D=

Si el sistema tiene más de una entrada

[num,den]=ss2tf(A,B,C,D,iu) donde iu es el número de entrada

Ejemplo;

» A=[0 1; -2 -3];
» B=[1 0; 0 1];
» D=[0 0];
» C=[1 0];

» [num1,den1]=ss2tf(A,B,C,D,1)

num1 =

0 1 3

den1 =

1 3 2

» [num2,den2]=ss2tf(A,B,C,D,2)

num2 =

0 0 1

den2 =

1 3 2

Representación mediante objeto

» sys=ss(A,B,C,D)

a=
x1 x2
x1 -1 -1
x2 1 0

b=
u1
x1 1
x2 0

c=
 x1 x2
y1 0 1

d=
u1
y1 0

Conversión de continuo a discreto

dx/dt=Ax+Bu --Æ x(k+1)=G x(k) + H u(k)

» A=[0 1; -2 3];
» B=[1 1]';
» Ts=0.1; %Periodo de muestreo
» [G,H]=c2d(A,B,Ts)

G=

0.9889 0.1162
-0.2325 1.3376

H=

0.1052
0.1052

%% Ejemplo espacio de estado

A=[-3 1 0 0; 0 0 -2 0; -4 0 0 1; 0 0 -3 0];
B=[0 2; 1 0; 0 3; 1 -3];
C=[1 0 0 0; 0 0 1 0];
D=[0 0; 0 1];

% Calculo de controlabilidad y observabilidad

fprintf('Controlabilidad rango %d\n',rank(ctrb(A,B)));

fprintf('Observabilidad rango %d\n',rank(obsv(A,C)));

% Calculo autovalores

fprintf('Autovalores :\n');
eig(A)

% Calculo de matriz de Jordan

[S,J]=jordan(A);

A1=J;
B1=inv(S)*B;
C1=C*S;
D1=D;

printsys(A1,B1,C1,D1);