Control Lab 2

1
UNIVERSIDAD NACIONAL DE SAN AGUSTIN DE AREQUIPA
ESCUELA PROFESIONAL DE INGENIERIA ELECTRICA
TEMA: EXPERIENCIA 2
CURSO: LABORATORIO DE CONTROL
DOCENTE: LUIS ALBERTO MERCADO ALANIA
ALUMNO:
o CORNEJO HUANCA JUAN RUFFO
2021
2
Experiencia 2
Modelación de sistemas utilizando

MATLAB
2.1. Objetivos.-
Modelar sistemas lineales invariantes en el tiempo.

Utilizar los diferentes comandos que proporciona MATLAB para realizar
simulaciones de sistemas de control.
Utilizar herramientas computacionales provistas por MATLAB para la conexión,
conversión de modelos LTI.
2.2. Marco teórico.-

MATLAB trabaja esencialmente con matrices numéricas rectangulares (que pueden
tener elementos complejos), lo cual implica el uso de vectores fila o columna. Por esta
razón este paquete tiene una proyección hacia el control moderno (descrito a
variables de estado) y es útil para ilustrar las relaciones existentes entre las técnicas
clásicas y modernas de análisis. Para ello, contiene un conjunto de rutinas de propósito
general que permite modelar, analizar y simular cualquier tipo d sistema, además, es
capaz de trabajar con modelos lineales invariantes en el tiempo (LTI), los cuales son:
TF : modelo a función de transferencia

ZPK : modelo ceros – polos – ganancia
SS : modelo a espacio de estados
FRD : modelo de respuesta a frecuencia
MATLAB realiza las diversas conexiones y conversiones entre este conjunto de

modelos.
2.2.1. Funciones para la Conexión de Modelos LTI utilizando MATLAB.-
La librería de sistemas de control de Matlab cuenta con un conjunto de funciones para

interconectar modelos para desarrollar concatenaciones de entrada – salida, colocarlos
en serie, paralelo y con realimentación.
2.2.1.1. Conexión Serie.-
sys = series(sys1,sys2)
3
conecta en serie dos modelos:
Es equivalente a multiplicación: sys = sys2 * sys1
sys = series(sys1,sys2,outputs1,inputs2)
permite la siguiente conexión:
En donde outputs1 e inputs2 indican cuales salidas y1 de sys1 y cuales entradas u2

de sys2 deben ser conectadas. El modelo sys resultante tiene como entrada u y como
salida y.
2.2.1.2. Conexión con Realimentación.-
Considerando que el sistema de control realimentado es aquel que tiende a mantener

una relación preestablecida entre la salida y alguna entrada de referencia,
comparándolas y utilizando la diferencia como medio de control. Matlab permite realizar
dicha realimentación con los siguientes comandos:
sys = feedback(sys1,sys2)
El modelo en lazo cerrado sys tiene un vector de entrada y otro de salida, y esta función
determina una realimentación negativa como la de la figura. Los modelos sys1 y
sys2 deben ser continuos.
sys = feedback(sys1,sys2,feedin,feedout)
en la mayoría de sistemas de control realimentado es común la presencia de

perturbaciones o señales que tienden a afectar adversamente el valor de la salida,
pueden ser internas o externas. Esto implica señales que ingresan al sistema, pero que
no se realimentan, así:
4
El vector feedin contiene índices dentro del vector de entrada de sys1 y especifica
cuales entradas u son afectadas en el lazo de realimentación. Similarmente, feedout
especifica cuales salidas y de sys1 son usadas en la realimentación. El modelo LTI
resultante sys tiene el mismo numero de entradas y salidas que sys1.
2.2.1.3. Conexiones mas frecuentes en Sistemas de Control.-
Cuando el comportamiento dinámico de un sistema no es satisfactorio, esto es, no

cumple las especificaciones de respuesta transitoria y en estado estable a fin de obtener
un funcionamiento satisfactorio es posible utilizar, compensación en serie, que
abreves rasgos implica colocar en serie con la planta un compensador cuya función de
transferencia Gc puede implicar desde una variación de ganancia hasta complejas
redes de adelanto y atraso, etc. Esto es posible siempre y cuando exista realimentación
de tal forma que Gc procese la señal de error. Las conexiones más comunes en los
sistemas de control clásicos son:
Compensador Planta
GC(s) G(s)
R(s) Y(s)
H(S)
Compensación en Serie
G1(s) G(s)
R(s) Y(s)
G(s)
H(s)
Compensación de Retroalimentación o en Paralelo
Generalmente, en el análisis y diseño de sistemas de control se ha de tener una base

de comparación del desempeño de diversos sistemas de control, la misma que se
configura especificando las señales de entrada de prueba particulares y comparando
las respuestas de varios sistemas a estas señales de entrada. MATLAB permite
5
utilizar señales de prueba típicas para comparar sistemas, como señales paso,
rampa, etc. Esta función reproduce una figura con la respuesta de sys a la entrada
Paso:
step(sys) % Respuesta Escalón Unitario (paso)
2.2.2. Funciones para la Conversión de Modelos LTI utilizando MATLAB.-
Existen cuatro tipos de modelos linealmente invariantes en el tiempo LTI que pueden
utilizarse con la librería de Sistemas de Control, que son TF (función de
transferencia), ZPK (ceros, polos y ganancia), SS (espacio de estados) y FRD
(respuesta en frecuencia). Es posible realizar la conversión de un modelo a otro, en
forma explicita, para un modelo dado sys con la siguiente sintaxis:
sys = tf(sys) % Conversión a TF

sys = zpk(sys) % Conversion a ZPK
sys = ss(sys) % Conversion a SS
sys = frd(sys, frequency) % Conversion a FRD
para el último caso, frequency es un vector de frecuencias usada como argumento e

entrada cuando se realiza la conversión al modelo FRD.
Por ejemplo:
Un modelo de espacio estados, para convertirse a un modelo ZPK:
sys = ss(-2,1,1,3)
zpk(sys)
s 2.333
3
s 2
Matlab en ocasiones realiza conversiones automáticas ya que existen varios comandos

que requieren de un modelo específico como parámetro de entrada así que antes
de realizar la función indicada por el comando realiza la conversión. Estas conversiones
pueden ser utilizadas tanto para sistemas sencillos con una única entrada y única salida
(SISO) como para sistemas de múltiples entradas y salidas (MIMO).
2.3. Trabajo Preparatorio.-
Se tiene un circuito serie RLC Alimentado por una fuente v(t) entrada y vc(t) tensión
en el capacitor de salida.
UNIVERSIDAD NACIONAL DE SAN AGUSTÍN
FACULTAD DE INGENIERIA DE PRODUCCION Y SERVICIOS
ESCUELA PROFESIONAL DE INGENIERÍA ELÉCTRICA
2.3.1. Obtener la ecuación diferencial que define el sistema
Como se sabe al aplicar la segunda ley de Kirchhoff en la malla RCL con la

fuente V(t) nos dice que:
𝑉(𝑡) = 𝑉𝑅(𝑡) + 𝑉𝐿(𝑡) + 𝑉𝑐(𝑡)
Ahora solo reemplazamos en la ecuación las tensiones de cada componente

en el dominio del tiempo.
𝑑𝑖(𝑡) 1 𝑡
𝑉(𝑡) = 𝑅𝑖(𝑡) + 𝐿 + ∫ 𝑖(𝑡)𝑑𝑡
𝑑𝑡 𝐶 0
Ahora como se observa todo esta relacionado con la corriente y sabemos que
𝑖(𝑡) = 𝑑𝑞(𝑡)/𝑑𝑡.
Ahora solo hacemos el cambio de variables para eliminar las integrales.
𝑑 2 𝑞(𝑡) 𝑑𝑞(𝑡) 1
𝐿 + 𝑅 + 𝑞(𝑡) = 𝑣(𝑡)
𝑑𝑡 2 𝑑𝑡 𝐶
Ahora como se sabe la capacitancia esta definida por:
𝑞(𝑡) = 𝐶. 𝑉𝑐(𝑡)
Ahora solo se sustituye en la ecuación diferencial donde la cual se obtiene:
𝑑 2 𝑉𝑐(𝑡) 𝑉𝑐(𝑡)
𝐿𝐶 2
+ 𝑅𝐶 + 𝑉𝑐(𝑡) = 𝑉(𝑡)
𝑑𝑡 𝑑𝑡
2.3.2. Obtener la función de transferencia del sistema
De la pregunta anterior podemos obtener la función de transferencia con la

ecuación hallada anteriormente.
𝑑 2 𝑉𝑐(𝑡) 𝑉𝑐(𝑡)
𝐿𝐶 + 𝑅𝐶 + 𝑉𝑐(𝑡) = 𝑉(𝑡)
𝑑𝑡 2 𝑑𝑡
De esta ecuación podemos hacer hallar la ecuación diferencial con respecto

de Vc(t) y hacemos la transformada de Laplace donde se obtiene:
(𝐿𝐶𝑠 2 + 𝑅𝐶𝑠 + 1)(𝑉𝑐(𝑠)) = 𝑉(𝑠)
Donde podemos despejar el Vc(t) como salida y V(t) como entrada.
𝑉𝑐(𝑠) 1
= 2
𝑉(𝑠) 𝐿𝐶𝑠 + 𝑅𝐶𝑠 + 1
𝑉𝑐(𝑠) 1/𝐿𝐶
=
𝑉(𝑠) 𝑅 1
𝑠 2 + 𝐿 𝑠 + 𝐿𝐶
La cual podemos llevar al diagrama de bloques
2.3.3. Obtener analíticamente el modelo en variables de estado
De las ecuaciones diferenciales tenemos:
𝑑𝑖 𝑅 1 1 𝑑𝑒𝑜 1
= 𝑖̇ = − 𝑖 − 𝑒𝑜 + 𝑒𝑖 𝑑𝑜𝑛𝑑𝑒 = 𝑒𝑜̇ = 𝑖
𝑑𝑡 𝐿 𝐿 𝐿 𝑑𝑡 𝐶
Ahora definimos las variables de estado como:
𝑅 1 1
𝑥1̇ = − 𝑖 − 𝑒𝑜 + 𝑒𝑖
𝑥1 = 𝑖 𝑥1̇ = 𝑖 𝐿 𝐿 𝐿
𝑑𝑒𝑟𝑖𝑣𝑎𝑚𝑜𝑠 ̇ 𝑐𝑎𝑚𝑏𝑖𝑜 𝑑𝑒 𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒
𝑥2 = 𝑒𝑜 𝑥2 = 𝑒𝑜̇ 1
𝑥2̇ = 𝑥1
𝐶
𝑅 1 1
=− 𝑥1 − 𝑥2 + 𝑒𝑖
𝐿 𝐿 𝐿
De esto obtnenemos las ecuaciones de estado:
𝑅 1
− − 1
̇ 𝐿] . [𝑥1] + [ ] . 𝑒 𝑥1
[𝑥1] = [ 𝐿 𝐿 𝑖 𝑑𝑜𝑛𝑑𝑒 𝑦 = 𝑒𝑜 = [0 1] [ ]
𝑥2̇ 1 𝑥2 𝑥2
0 0
𝐶
2.3.4. Obtener analíticamente vc(t) para una entrada escalón unitario para
valores de R L y C asumidos por el estudiante.. (nótese que la
entrada paso es la integral de una entrada impulso)
De la transformada de Laplace hallada anteriormente tenemos que:

𝑉𝑐(𝑠) 1
= 2
𝑉(𝑠) 𝐿𝐶𝑠 + 𝑅𝐶𝑠 + 1
También como dato el escalo unitario definida como

𝑦(𝑡) = 0 ; 𝑝𝑎𝑟𝑎 𝑢𝑛 𝑡 < 0
; su transformada de Laplace es:
𝑦(𝑡) = 1 ; 𝑝𝑎𝑟𝑎 𝑢𝑛 𝑡 > 0
1
𝑋(𝑠) =
𝑠
Ahora solo damos valores como para R = 3 ohm , L = 1 H y C = 0.5 F

Entonces reemplazamos.
𝑉𝑐(𝑠) 1 1
= =
𝑉(𝑠) 𝐿𝐶𝑠 2 + 𝑅𝐶𝑠 + 1 0.5𝑠 2 + 1.5𝑠 + 1
1
𝑉(𝑠) =
𝑠
𝑉𝑐(𝑠)
Ahora para hallar el Vc(s) solo se multiplica para ∗ 𝑉(𝑠)
𝑉(𝑠)
1 1 1
= ∗ =
0.5𝑠 2 + 1.5𝑠 + 1 𝑠 0.5𝑠 + 1.5𝑠 2 + 𝑠
3
Ahora solo resolvemos la ecuación con la transformada inversa de Laplace
𝑉𝑐(𝑡) = 𝑒 −2𝑡 − 2𝑒 −𝑡 + 1
2.3.5. Con la ayuda del Excel presente los gráficos para una entrada
escalón unitario en lazo abierto.
2.4. Trabajo Experimental.-
2.4.1. Obtenga el modelo en espacio de estado, zpk, respuesta en

frecuencia si es posible del sistema del trabajo preparatorio.
De la funcion de transferencia hallada anteriormente la cual es:
𝑉𝑐(𝑠) 1 1
= 2
= 2
𝑉(𝑠) 𝐿𝐶𝑠 + 𝑅𝐶𝑠 + 1 0.5𝑠 + 1.5𝑠 + 1
Lo llevaremos al Matlab con los siguientes comandos

>> num=[1];
>> den=[0.5 1.5 1];
>> A=tf(num,den)
Ahora definiremos los cero y polos con la función de transferencia definida con
los siguientes comandos.
>> B=zpk(A)
Ahora hallamos los espacios de estado con el siguiente comando.

>> C=ss(A)
Ahora solo definimos la respuesta en frecuencia para una de 60hz con el

siguiente comando.
>> F=frd(A,60)
2.4.2. Obtener la respuesta en lazo abierto y cerrado para las entradas:

impulso, paso, rampa, senoidal.
Como primer paso debemos definir la función de transferencia como:

>> num=[1];
>> den=[0.5 1.5 1];
>> A=tf(num,den)
Luego de esto colocamos el comando impulso para A.

>> impulse(A)
Para el comando step es el siguiente:

>> step(A)
Para el caso de entrada de rampa por estar en serie será el producto de

ganancias para esto definimos los siguientes comandos.
num1=[1];
den1=[1 0 0];
num=[1];
den=[0.5 1.5 1];
b=tf(num1,den1);
a=tf(num,den);
sys=series(a,b);
>> sys
plot(1),impulse(sys),grid
disp('RESUPUESTA A ENTRADA DE RAMPA');
Para la señal senoidal como se sabe es sen(t) y su transformada de Laplace

1
es: 𝑠2 +1 donde solo seria el producto por esta en serie la cual podemos
calcular con el siguiente comando.
num1=[1];
den1=[1 0 1];
num=[1];
den=[0.5 1.5 1];
b=tf(num1,den1);
a=tf(num,den);
sys=series(a,b);
sys
Esto lo podemos llevarlo a la grafica con:
plot(1),impulse(sys),grid
disp('RESUPUESTA A ENTRADA SENOIDAL');
2.4.3. Obtenga la ecuación diferencial que representa al sistema y la

función de transferencia del siguiente circuito:
Como primer paso debemos definir el circuito como entrada una tensión V(t) y
como salida la Vc(t)
Primero aplicamos la segunda ley de Kirchhoff en la primera malla.
𝑉(𝑡) = 𝐼1 ∗ 𝑅1 + 𝑉𝑐(𝑡)
Sabemos que el Vc(t) está definida por:
1
∫ 𝑖𝑑𝑡 = 𝑉𝑐(𝑡)
𝐶
Ahora solo aplicamos Vc(t)/V(t)
1
𝑉𝑐(𝑡) 𝐶𝑠 1
= =
𝑉(𝑡) 𝑅 + 1/𝐶𝑠 𝑅𝐶𝑠 + 1
2.5. Informe.-
2.5.1. Presente los resultados obtenidos en la parte experimental.
2.5.2. Empleando lazos y estructura de control de flujo, elabore un

programa que permita obtener sobre un mismo grafico la
respuesta escalón en lazo abierto para cinco valores diferentes
del parámetro a del sistema dado por la siguiente función de
transferencia:
for a=1:5;
nun=[a];
den=[1 4];
x=tf(nun,den);
step(x)
grid
hold on
end
Transfer function:
1
-----
s + 4
Transfer function:
2
-----
s + 4
Transfer function:
3
-----
s + 4
Transfer function:
4
-----
s + 4
Transfer function:
5
-----
s + 4
2.5.3 Presentar resultados obtenidos del uso del programa mason.m

function [Num,Den] = mason(NetFile,Start,Stop)
% mason.m
% This function takes a netfile describing a signal flow graph
% with symbolic coefficients and generates an equation representing
% the equivilent term between an independent input node, and dependent
% output node. Please see the *readme* file for a full description,
and
% an example netfile.
%
% Author : Rob Walton
% Organisation : TRLabs and the University of Calgary, Alberta, Canada
% Date : January 25th 1999
% Revised : January 20th 2000 (Removed bug that caused the odd loop to
be thrown away)
%
% Please email me at <walton@ieee.org> if you find any errors!
%
% USAGE:
% [Numerator,Denominator] = mason(Netfile,StartNode,StopNode)
%
% Netfile - is a string with the name of the netfile to load
% StartNode - is the integer number describing the independent input
node
% StopNode - is the integer number describing the dependent output
node
% Numerator - is a string containing the equation for the Numerator
% Denominator - is a string containing the equation for the
Denominator
%*** Load the the net description file into Net ***
% *** The first column in the file is the coefficient number (These
must be in order starting
% at 1). The second and third column are start node and stop node
numbers respectively. The last
% column is the name of the coefficient. ** See readme file **
% *** Net will be the first 3 columns of the file. Coeff will be
the last column. ***
fid=fopen(NetFile); % Open the file
if (fid==-1)
fprintf('\n*** File, %s, not found ***\n\n',NetFile)
return
end
Net=[]; % Initialize the Numerical Net matrix
line_number=0; % Line number read from file
Coeff_Names={}; % Initialize cell array of strings
while 1 % Loop Until end of file, read one line at a time
line_number=line_number+1; % Count which line we are on
x=fscanf(fid,'%d',3); % Read the three decimal numbers into x
Coeff=fscanf(fid,'%s\n',1); % Read the one coefficient name into coeff
if isempty(x) % Stop the loop if no data is left in file
break
end
Net(line_number,:)=transpose(x); % Append one row to bottom of
numerical matrix
Coeff_Names{line_number}= Coeff; % Append the coefficient name to the
coefficient array
end
fclose(fid); % Remember to close the file!
%*** Determine Number of Coefficients in net file ***
temp=size(Net); % Determine the number of rows in the net matrix
Number_Coeff=temp(1);
%*** Find all the paths connecting the start and end nodes, along
which ***
%*** no node is crossed more than once ***
[PathCoeffList,PathNodeList]=findpaths(Start,Stop,[],[],Net);
% PathCoeffList and PathNodeList are matrixes where each row lists the
number of the coefficients or the nodes visited respectively. Each row
is padded with zeros to make them the same length.
%fprintf('\n- Path List -\n');
%print_paths(PathCoeffList);
%*** Determine all the first-Order loops ***
LoopCoeffList=[]; % Initialise list of coefficients in for each loop
LoopNodeList=[]; % Initialise list of nodes for each loop found
for index=1:Number_Coeff; % Find list of loops originating from each
node
% Get the matrix describing all the loops from at node #index
[FoundLoops,FoundNodes]=findpaths(index,index,[],[],Net);
LoopCoeffList=[LoopCoeffList;FoundLoops]; % Append Coefficients of
loops
LoopNodeList=[LoopNodeList;FoundNodes]; % Append nodes visited for
each loop
end
% Remove duplicate loops
[LoopCoeffList,LoopNodeList]=RemoveDuplicateLoops(LoopCoeffList,LoopNo
deList);
%fprintf('\n\n- 1st Order Loop List -\n');
%print_paths(LoopCoeffList);
%*** Convert to nomenclature used by Pozars RF Book ***
% P{n} represents the nth path found connecting start to stop
% P{n}.Coeff is an array with a list of the coefficients passed
through in order
% P{n}.Nodes is an array listing the nodes passed through in order.
Including the end nodes
% NOTE: A cell array is used because the path lengths can be different
resulting in different sized arrays
% *** Make a cell array of P the different length paths ***

temp=size(PathCoeffList); % Determine number of paths
NumberPaths=temp(1);
if (NumberPaths==0);
fprintf('\n*** There are no paths connecting those nodes ***\n')
return
end
for index=1:NumberPaths % Do each path separately
Coeff=PathCoeffList(index,:); % Read Coefficients for a path
P{index}.Coeff=Coeff(1:sum(Coeff>0)); % Strip trailing zeros and put
in struct
Node=PathNodeList(index,:); % Read node list for a path
P{index}.Node=[Node(1:sum(Coeff>0)),Stop]; % Append trailing zeros and
put in struct.
% Append the Stop node onto the end of the node list
end
% *** Make a cell array of the first order paths, each row a different
order ***
% *** The first column contains the number of paths of that order
% L{LoopOrder}.NumberLoops = number of loops of this order
% L{LoopOrder}.Coeff{n} = Coefficients of nth loop
% L{LoopOrder}.Node{n} = Nodes of nth loop
temp=size(LoopCoeffList);
NumberLoops=temp(1); % Determine number of first order paths
L{1}.NumberLoops=NumberLoops; % Set number of loops in the L{1} struct
for index=1:NumberLoops % Do each loop seperately
Coeff=LoopCoeffList(index,:); % Read coefficients for that loop
L{1}.Coeff{index}=Coeff(1:sum(Coeff>0)); % Strip Trailing zeros and
put in struct
Node=LoopNodeList(index,:); % Read Node list for loop
L{1}.Node{index}=[Node(1:sum(Coeff>0)),Node(1)]; % Strip trailing
zeros and put in struct
% Append Stop node (same as first node in list
end
%*** Determine nth order loops ***
n=1; % n is the order of loops we are finding
while 1 % Loop until an order of loop is reached that is empty
n=n+1; % Count which order we are on
L{n}.NumberLoops=0; % Assume no loops of this order
% compare each first order loop with each n-1th loop. If non touching
add to the
% two combined to the nth loop.
for first=1:L{1}.NumberLoops % Take each first order loop
for second=1:L{n-1}.NumberLoops % Compare with each n-1th loop
if not(AreTouchingLoops(L{1}.Node{first},L{n-1}.Node{second})) % Non
Touching loops found
% Determine if loop is a duplicate
Duplicate=0; % A flag to indicate loop found is duplicate(0=not dup)
for index=1:L{n}.NumberLoops % Add this loop if it is not a duplicate
entry
if IsSameLoop([L{1}.Coeff{first}, L{n-
1}.Coeff{second}],L{n}.Coeff{index}) %Duplicate found
Duplicate=1; % Set the duplicate flag
end
end
if (Duplicate==0) % Add the loop if not a duplicate
L{n}.NumberLoops=L{n}.NumberLoops+1; % Increment the number of loops
of that order
% For Node and Coeff structs. Append a new array describing the loop
of order n found
L{n}.Coeff{(L{n}.NumberLoops)}=[L{1}.Coeff{first}, L{n-
1}.Coeff{second}];
L{n}.Node{(L{n}.NumberLoops)}=[L{1}.Node{first}, L{n-1}.Node{second}];
end
end
end
end
if (L{n}.NumberLoops==0) % If no loops of order n where found, then
break
break % There will be no loops of order n+1
end
end
% ***** Display File info *****
fprintf('\n-- Network Info --\n')
fprintf('Net File : ');fprintf(NetFile);fprintf('\n');
fprintf('Start Node : %d\n',Start);
fprintf('Stop Node : %d\n',Stop);
% ***** Display the paths found ******
fprintf('\n----- Paths -----\n')
for pathn=1:length(P) % Look at each Path and display it's Coeff
numbers
fprintf('P%d : ',pathn); % on a different line
fprintf('%d ',P{pathn}.Coeff);
fprintf('\n');
end
% ***** Display all the loops found *****
for loop_order=1:length(L)-1 % Look at each loop order (last order has
no loops
fprintf('\n- Order %d Loops -\n',loop_order) % Print header describing
loop order
for loop_number=1:L{loop_order}.NumberLoops % Look at each loop of
that order
fprintf('L%d%d : ',loop_order,loop_number) % Display coefficients on a
different line
fprintf('%d ',L{loop_order}.Coeff{loop_number})
fprintf('\n')
end
end
% *******************************************************
% ************ Generate the final equation **************
% *******************************************************
% For now the equations are written in terms of the coefficient number
: c#
% the coefficient strings will be substituted later
% Determine Numerator
Num=''; % Assume Numerator is empty to start
for pathn=1:length(P) % Add Each path and related
Num=sprintf('%s%s*(1', Num, CoeffToString(P{pathn}.Coeff)); % Pn*(1
...
for order=1:length(L)-1 % Append each order of sums of non-touching
loops
% if order is odd order append a minus, otherwise a plus
if (rem(order,2)==1)
Num=sprintf('%s-',Num);
else
Num=sprintf('%s+',Num);
end
% Append the sum of all the nontouching loops that don't touch the
current path
Num=[Num,PrintSumsNotTouching(L,order,P{pathn}.Node)];
end
Num=sprintf('%s)+',Num); % Close the bracket around paths list of sums
end
Num=Num(1:length(Num)-1); % Remove the extra plus sign on the end.NOTE
using /b screws up the symbolic math later
% Determine Denominator
Den='1'; % Denominator always start with a zero
for order=1:length(L)-1 % Add order subtract the sum of each orders
loops
% if order is odd order append a minus, otherwise a plus,
if (rem(order,2)==1)
Den=sprintf('%s-',Den);
else
Den=sprintf('%s+',Den);
end
%Add or subtract all the loops
% KLUDGE: all the loops not touching the path with nodes 999999999 are
added
% That definetly should be all of them!
Den=[Den,PrintSumsNotTouching(L,order,[9999999 999999])]; %Sums of all
the loops of order order
end
fprintf('\nThe variables returned are strings describing\n')
fprintf('the numerator and Denominator of the transfer equation.\n')
fprintf('If you have the symbolic toolbox, use
Denominator=sym(Denominator)\n');
fprintf('and Numerator=sym(Numerator) to make these symbolic
equations.\n')
fprintf('You can now use simple(Numerator/Denominator) to boil the
whole\n')
fprintf('thing down. You could also use simple(Numerator) to simplify
the\n')
fprintf('Numerator on it'' own.\n\n')
% ****** Convert to Symbolic and do substitutions *******
for coeff_num=length(Coeff_Names):-1:1; %Cycle through Coefficient
array, substituting each one
orig=sprintf('c%d',Net(coeff_num,1)); % for each line generate c[Coeff
Number] to replace
Den=strrep(Den,orig,Coeff_Names{coeff_num}); % Replace all the c#s
with the strings from net file
Num=strrep(Num,orig,Coeff_Names{coeff_num});
end % This loop had to count down so there was no risk of C12 being
replace by C1
%*********************************************************************
****************************
function Touching=AreTouchingLoops(Nodes1,Nodes2)
%*********************************************************************
****************************
% This function takes two arrays describing two sets of nodes
visited(each padded with zeros).
% Return 1 if they are they are touching loops.
% Determine length of loop arrays with zeros removed
Loop1Length=sum(Nodes1>0);
Loop2Length=sum(Nodes2>0);
for first=1:Loop1Length
for second=1:Loop2Length
if (Nodes1(first)==Nodes2(second))
Touching=1;
return;
end
end
end
Touching=0;
%*********************************************************************
****************************
function StrMult=CoeffToString(Coefficients)
%*********************************************************************
****************************
% StrMult=CoeffToString(Coefficients)
% Coefficients is an array with coefficients c1,c2..cN
N=length(Coefficients); % Get length of string
StrMult=sprintf('c%d',Coefficients(1)); % Start with first coefficient
for n=2:N % Append each coefficent in list with * before it
StrMult=[StrMult, sprintf('*c'),sprintf('%d',Coefficients(n))];
end
%*********************************************************************
****************************
function [PathUp,NodesUp]=findpaths(StartNode,StopNode,Path,Nodes,Net)
%*********************************************************************
****************************
%[PathUp,NodesUp]=findpaths(StartNode,StopNode,Path,Nodes,Net)
%
%Iterative function to find path between StartNode and StopNode. Net
is the array with the network
%list in it. Path is the single path to date for a given route through
the tree. PathUp is a
%list of all paths terminated below that node that are sucesfull.
%Nodes is the list of nodes tvaersed so far on the way down
% Determine number of coefficients in net
temp=size(Net);
NumberCoeff=temp(1,1);
PathUp=[];
NodesUp=[];
% Terminate branch and return nothing if the Nodes to date contains
repetitions.
for index=1:NumberCoeff
if not(isempty(Nodes)) % Only compare if the the Path has data in it
if (sum(Nodes==index)>1)
PathUp=[];
% fprintf('Repeated Node : ');
% fprintf('%d ',Nodes);
% fprintf('\n');
return
end
end
end
% Terminate branch and return path if start and stop nodes are the
same
if ((StartNode==StopNode) & (length(Path>1)))
PathUp=Path;
NodesUp=Nodes;
%fprintf('Sucessfull Path : ');
%fprintf('%d ',Path);
%fprintf('\n');
return
end
% Check for all branches leaving StartNode, and call another iteration
for them
for index=1:NumberCoeff
if (StartNode==Net(index,2))
% Iterate with appended coeff to path and new startnode

[FoundPath,FoundNodes]=findpaths(Net(index,3),StopNode,[Path,Net(index
,1)],[Nodes,StartNode],Net);
if not(isempty(FoundPath)) %Only append if not empty
PathUp=[PathUp;[FoundPath,zeros(1,NumberCoeff+1-length(FoundPath))]];
NodesUp=[NodesUp;[FoundNodes,zeros(1,NumberCoeff+1-
length(FoundPath))]];
end
end
end
%*********************************************************************
****************************
function Same=IsSameLoop(Loop1,Loop2)
%*********************************************************************
****************************
% This function takes two arrays describing two loops(Can be padded
with zeros if desired).
% Return 1 if they are they describe the same circular loop.
% Determine length of loop arrays with zeros removed
Loop1Length=sum(Loop1>0); % Count all the non zero terms
Loop2Length=sum(Loop2>0);
%Return 0 if different length since the loops can't be the same!
if (Loop1Length~=Loop2Length)
Same=0;
return
end
%They are the same length so see if the contain the same nodes, but in
any order.
% sort the nodes and subtract the two vectors. The resulting vector
componments will all be zero, only if the lists contains the same
values.
if (sum(abs(sort(Loop1)-sort(Loop2)))==0)
Same=1; % Loops are the same
else
Same=0; % Loops are different
end
%*********************************************************************
****************************
function Str=PrintSumsNotTouching(L,order,Pnodes)
%*********************************************************************
****************************
% Str=PrintSumsNotTouching(L,path)
% L is the array of structs containing all the first and higher order
loops.
% Pnodes is the array of nodes that decibing a path
%
% The function returns a string with the sum off all the loops of
order order
% that do not touch the path. The sum is contained within a set of
brackets
No_NonTouching=1; % Flag set so indacate no nontouching loops found
Str=('('); % Open the first bracket
for n=1:L{order}.NumberLoops % Look at each loop of thet order
if not(AreTouchingLoops(Pnodes,L{order}.Node{n})) %The loop doesn't
touch the path
Str=sprintf('%s%s+',Str,CoeffToString(L{order}.Coeff{n}));% So add its
coefficients
No_NonTouching=0; % Set flag to indacet a nontouching loop was found
end
end
Str=Str(1:(length(Str)-1)); % Remove the extra plus sign (or

open bracket
% if not loops where found
Str=sprintf('%s)',Str); % Append the closed bracket
%If the sum is zero return zero instead
if No_NonTouching==1 % If no loops foun then return '0' instead
Str='0';
end
%*********************************************************************
****************************
function [LoopList,NodeList]=RemoveDuplicateLoops(LoopList,NodeList);
%*********************************************************************
****************************
% [LoopList,NodeList]=RemoveDuplicateLoops(LoopList,NodeList)
% Returns a subset of the LoopList matrix, where each duplicate row
has been removed
% This function works on the initial loops description where each loop
is a row in the
% the matrix padded with zeros to make them all the same length
temp=size(LoopList); % Get number of loops
NumberLoops=temp(1);
% Compare each loop with all the loops after it. And remove its
duplicates from after it.
first=1; % The first loop
while (first<=NumberLoops) % Loop until all the loops have been used
as first loops
second=first+1; % Start the second loop to compare as being one ahead
of first loop
while (second<=NumberLoops) % choose the second loop to compare as all
the ones after first
% Remove the extra loop found at the second loop index.
% NOTE: A for loop was not used since the number of loops is not
constant
if (IsSameLoop(LoopList(first,:),LoopList(second,:))==1) %Remove row
at second loop
LoopList=[LoopList(1:second-1,:);LoopList(second+1:NumberLoops,:)];
NodeList=[NodeList(1:second-1,:);NodeList(second+1:NumberLoops,:)];
NumberLoops=NumberLoops-1; % Decrement the number o loops
else
second=second+1; % Only increment second if no loop was removed
% Otherwise a new loop is move to second
end
end
first=first+1; % increment the first loop pointer
end
Comentarios y conclusiones.
• Como se ve el software Matlab no sirve para modelar funciones de

transferencia
• El software nos permite hacer las operaciones básicas de funciones de

transferencia tales como en serie y en paralelo para esto debe estar
previamente definidas dichas funciones.
• Nos permite hallar los ceros y polos de las funciones de transferencia
• Se pudo agregar entradas como función impulso, escalón unitario y en

rampa para analizar su forma transitoria.
• Las funciones de transferencia nos ayudan a modelar modelos

matemáticos tales como un circuito RLC como visto en este laboratorio.
• Para una mayor comprensión es necesario conocer y consultar el

lenguaje de programación del software Matlab.
2.6. Bibliografía.-
• https://vdocumento.com/laboratorio-2-contro-automatico.html
• https://www.mathworks.com/help/control/ref/lti.step.html;jsessionid=d4600512a258
73ee9953862bc610
• https://www.angelfire.com/la/hmolina/matlab3.html

Control Lab 2

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Control Lab 2

Cargado por

Copyright:

Formatos disponibles

1

UNIVERSIDAD NACIONAL DE SAN AGUSTIN DE AREQUIPA

ESCUELA PROFESIONAL DE INGENIERIA ELECTRICA

CURSO: LABORATORIO DE CONTROL

DOCENTE: LUIS ALBERTO MERCADO ALANIA

o CORNEJO HUANCA JUAN RUFFO

Modelación de sistemas utilizando

Modelar sistemas lineales invariantes en el tiempo.

2.2. Marco teórico.-

TF : modelo a función de transferencia

MATLAB realiza las diversas conexiones y conversiones entre este conjunto de

2.2.1. Funciones para la Conexión de Modelos LTI utilizando MATLAB.-

La librería de sistemas de control de Matlab cuenta con un conjunto de funciones para

2.2.1.1. Conexión Serie.-

conecta en serie dos modelos:

Es equivalente a multiplicación: sys = sys2 * sys1

permite la siguiente conexión:

En donde outputs1 e inputs2 indican cuales salidas y1 de sys1 y cuales entradas u2

2.2.1.2. Conexión con Realimentación.-

Considerando que el sistema de control realimentado es aquel que tiende a mantener

en la mayoría de sistemas de control realimentado es común la presencia de

2.2.1.3. Conexiones mas frecuentes en Sistemas de Control.-

Cuando el comportamiento dinámico de un sistema no es satisfactorio, esto es, no

Compensación de Retroalimentación o en Paralelo

Generalmente, en el análisis y diseño de sistemas de control se ha de tener una base

step(sys) % Respuesta Escalón Unitario (paso)

2.2.2. Funciones para la Conversión de Modelos LTI utilizando MATLAB.-

sys = tf(sys) % Conversión a TF

para el último caso, frequency es un vector de frecuencias usada como argumento e

Un modelo de espacio estados, para convertirse a un modelo ZPK:

Matlab en ocasiones realiza conversiones automáticas ya que existen varios comandos

2.3. Trabajo Preparatorio.-

2.3.1. Obtener la ecuación diferencial que define el sistema

Como se sabe al aplicar la segunda ley de Kirchhoff en la malla RCL con la

Ahora solo reemplazamos en la ecuación las tensiones de cada componente

Ahora solo hacemos el cambio de variables para eliminar las integrales.

Ahora como se sabe la capacitancia esta definida por:

Ahora solo se sustituye en la ecuación diferencial donde la cual se obtiene:

2.3.2. Obtener la función de transferencia del sistema

De la pregunta anterior podemos obtener la función de transferencia con la

De esta ecuación podemos hacer hallar la ecuación diferencial con respecto

(𝐿𝐶𝑠 2 + 𝑅𝐶𝑠 + 1)(𝑉𝑐(𝑠)) = 𝑉(𝑠)

Donde podemos despejar el Vc(t) como salida y V(t) como entrada.

La cual podemos llevar al diagrama de bloques

2.3.3. Obtener analíticamente el modelo en variables de estado

De las ecuaciones diferenciales tenemos:

De esto obtnenemos las ecuaciones de estado:

De la transformada de Laplace hallada anteriormente tenemos que:

También como dato el escalo unitario definida como

Ahora solo damos valores como para R = 3 ohm , L = 1 H y C = 0.5 F

Ahora solo resolvemos la ecuación con la transformada inversa de Laplace

2.4. Trabajo Experimental.-

2.4.1. Obtenga el modelo en espacio de estado, zpk, respuesta en

De la funcion de transferencia hallada anteriormente la cual es:

Lo llevaremos al Matlab con los siguientes comandos

Ahora hallamos los espacios de estado con el siguiente comando.

Ahora solo definimos la respuesta en frecuencia para una de 60hz con el

2.4.2. Obtener la respuesta en lazo abierto y cerrado para las entradas:

Como primer paso debemos definir la función de transferencia como:

Luego de esto colocamos el comando impulso para A.

Para el comando step es el siguiente:

Para el caso de entrada de rampa por estar en serie será el producto de

Para la señal senoidal como se sabe es sen(t) y su transformada de Laplace

% * Make a cell array of P the different length paths *