|

Simulación 1 Matlab-Simulink.

Estudiante:
Juan Esteban López Badillo
Reynel de Aguas Aviles

Universidad Pontificia Bolivariana.

Sistemas Dinámicos.

Docente :
Iván Darío Mora Orozco.

Medellín, Colombia.
Gráfico del sentido y acción de las variables:
Planteamos el siguiente grafico para ilustrar las fuerzas y las velocidades.

Ecuaciones de equilibrio
F K ( t )−F m 2 ( t )−F B ( t )−F K ( t )=0
1 2
(1)

x (t )−F m 1 ( t )−F K (t )=0 1

(2)

F B ( t )−F K ( t )=0
3
(3)

y ( t ) −F B (t )=0 (4)

Ecuaciones de compatibilidad
V K ( t )−V m ( t ) +V m ( t ) =0
1 1 2
(5)

V B ( t )−V k ( t )+ V k ( t ) = 0
2 3
(6)

V k ( t )−V m ( t ) = 0
2 2
(7)

Ecuaciones descriptivas
−1
F K ( t )=K 1 D V K ( t )
1 1
(8)
−1
F K ( t )=K 2 D V K ( t )
2 2
(9)
−1
F K ( t )=K 3 D V K ( t )
3 3
(10)

F m ( t )=M 1 D V m ( t )
1 1
(11)
F m ( t )=M 2 DV m ( t )
2 2
(12)

F B ( t )=B V B (t ) (13)

Modelo según la ecuación diferencial

Planteamos el siguiente algoritmo para resolver el sistema de ecuaciones de equilibrio, de
compatibilidad y descriptivas :
% Cerrar todas las figuras, borrar todas las variables y limpiar la pantalla.
close all;
clear all;
clc;

% Definir las variables como símbolos para cálculos simbólicos.

syms yt xt D K1 K2 K3 B M1 M2 fK1 fK2 fK3 fB fM1 fM2 VK1 VK2 VK3 VB VM1 VM2

% Todas las ecuaciones se igualan a cero en MATLAB para cálculos simbólicos.

%
--------------------------------------------------------------------------------
-

% Ecuaciones de equilibrio.
Ec1 = fK1-fM2-fB-fK2;
Ec2 = xt-fM1-fK1;
Ec3 = fB-fK3;
Ec4 = yt-fB;

% Ecuaciones de compatibilidad.
Ec5 = VK1-VM1+VM2;
Ec6 = VB-VK2+VK3;
Ec7 = VK2-VM2;

% Ecuaciones descriptivas.
Ec8 = fK1 - K1 * (D^(-1)) * VK1;
Ec9 = fK2 - K2 * (D^(-1)) * VK2;
Ec10 = fK3 - K3 * (D^(-1)) * VK3;
Ec11 = fB - B * VB;
Ec12 = fM1 - M1 * D * VM1;
Ec13 = fM2 - M2 * D * VM2;

% Utilizar el comando 'solve' para obtener el modelo del circuito.

solution = solve(Ec1, Ec2, Ec3, Ec4, Ec5, Ec6, Ec7, Ec8, Ec9, Ec10, Ec11, Ec12,
Ec13, fK1, fK2, fK3, fB, fM1, fM2, VK1, VK2, VK3, VB, VM1, VM2, yt);

% Extraer la solución para yt.

soly = solution.yt;

% Simplificar la solución.
y = simplify(soly);

% Presentar la solución de manera legible.

pretty(y)
Al ejecutar se obtiene:

Ahora organizamos la ecuación que obtuvimos del programa de la siguiente manera :

El término que contenga la mayor derivada tenga un coeficiente igual a la unidad

[ BD K 1 K 3 ] x ( t )=¿

( B K3 K1 D
BM 1 M 2 ) 5
[ 4 K K K
(
M1 M2 M2 M2
K 3 K K K K K K
M2 B M1 B M2 B
2
) (
x (t )= D + K 3 D + 1 + 1 + 2 + 3 D + 3 1 + 3 1 + 3 2 D +
K 1 K2 K1 K3
+
M1 M2 M1 M2
D+
) ( )

Si deseamos ver la gráfica que describe esta ecuación diferencial usaremos la función de transferencia H (s )

Y (s) S
H ( s )= = 5 4
X ( s ) s + s +3 s +3 s 2 +2 S+ 1
3

s
H ( s )= 5 4 3 2
s +s + 4 s +3 s +2 s +1
Si queremos graficar y (t ) usaremos el siguiente algoritmo en Matlab:
clear all
close all
clc

% Definición de constantes
K1 = 1;
K2 = 1;
K3 = 1;
M1 = 1;
M2 = 1;
B = 1;
% Coeficientes de la ecuación
num = [(B*K3*K1/M1*M2*B) 0];
den = [1 K3 K1/M1 + K1/M2 + K2/M2 + K3/M2 (K3*K1/M2*B + K3*K1/M1*B + K3*K2/M2*B)
(K1*K2/M1/M2 + K1*K3/M1/M2) K1*K2*K3/M1/M2/B];

% Creación del sistema de transferencia

sys = tf(num, den)

% Gráfica de la respuesta escalón

figure
step(sys)
grid on
xlabel('Tiempo [s]')
ylabel('y(t)')
title('Respuesta al escalón del sistema')

Al ejecutar el código obtenemos la función de transferencia:

Y la gráfica de y (t ):
Modelo en diagrama de bloques
De las ecuaciones planteadas anteriormente procedemos con la construcción del respectivo
diagrama de bloques:

Dibujamos el diagrama de bloques en Simulink:

Ahora definimos el diagrama anterior como un subsistema e incluiremos como
entrada un escalón (Step), salida un Scope y definiremos los vectores yt_block y
ts_block para importar los datos desde Simulink a Matlab:
Por último, verificaremos la salida scope y además haremos la comparación con
la señal obtenida usando la ecuación diferencial:
Según el Scope la señal de salida es:

Para comprar las grafica obtenida por diagrama de bloques y función de transferencia usaremos el
siguiente código:
% Definición de constantes
K1 = 1;
K2 = 1;
K3 = 1;
M1 = 1;
M2 = 1;
B = 1;

% Coeficientes de la ecuación
num = [(B*K3*K1/M1*M2*B) 0];
den = [1 K3 K1/M1 + K1/M2 + K2/M2 + K3/M2 (K3*K1/M2*B + K3*K1/M1*B + K3*K2/M2*B)
(K1*K2/M1/M2 + K1*K3/M1/M2) K1*K2*K3/M1/M2/B];

% Creación del sistema de transferencia

sys = tf(num, den)

% Gráfica de la respuesta escalón

figure
step(sys)
grid on
xlabel('Tiempo [s]')
ylabel('y(t)')
title('Respuesta al escalón del sistema')
hold on

stepplot(sys)

plot(out.ts,out.yt,'r');

xlabel('Tiempo [s]');ylabel('yt');
Obtendremos como resultado:

(Podemos ver que las gráficas se solapan.)

Modelo en variables de estado

Para sistemas mecánicos de traslación se eligen variables de estado velocidades en las
masas y fuerzas en los resortes.
y ( t ) =F K ( t )
3
de esta manera podemos representar a la ecuación de salida representada en
variables de estado.
Ecuación en variables de estado para la masa M 1 :
1 1 1 1
D V̇ m (t )=
1
M1
F m ( t )=
1
M1
( x ( t )−F K ( t ) ) =
1
M1
x ( t )− F (t )
M1 K 1

Ecuación en variables de estado para la masa M 2 :

1 1
D V̇ m ( t )=
2
M2
F m ( t )=
2
( F ( t )−F B ( t )−F K ( t ) )
M2 K 1 2
 1 1
D V̇ m ( t )=
2
M2
( F K ( t )−F B ( t )−F K ( t ) )=
1 2
( F ( t )− y ( t )−F K ( t ) )
M2 K 1 2

1 1
D V̇ m ( t )=
2
( F ( t )− y ( t )−F K ( t ) )= M ( F K ( t )−F K ( t )−F K ( t ) )
M2 K 1 2 1 3 2
2

1 1 1
D V m ( t )= F K ( t )− F K (t )− F (t )
2
M2 M2
1
M2 K3 2

Ecuación en variables de estado para el resorte K 1 :

D F K ( t ) =K 1 V K ( t ) =K 1 ( V m ( t )−V m ( t ) )=K 1 V m ( t )−K 1 V m ( t )

1 1 1 2 1 2

Ecuación en variables de estado para resorte K 2 :

D F K ( t ) =K 2 V K ( t )=K 2 ( V m ( t ) )
2 2 2

τ ˙K ( t )=K 2 V m ( t )
2 2

Ecuación en variables de estado para resorte K 3 :

D F K ( t )=K 3 V K ( t )=K 3 ( V k ( t )−V B ( t ) )=K 3 ( V m ( t )−BF k ( t ) )

3 3 3 2 3

D F K ( t )=K 3 ( V m ( t ) −BF k ( t ) ) =K 3 V m ( t )−K 3 BF k ( t )

3 2 3 2 3

Para evidenciar el comportamiento de las variables de estado mediante una gráfica;

declarando una función y luego graficando respecto al tiempo el resultado obtenido al
poder las ecuaciones en variables de estado en la función declarada anteriormente:

Declaramos la función solEDO:

% Nombre del archivo: solEDO
% Función para calcular las derivadas de un sistema mecánico rotacional

function dxdt = solEDO(t, x)

% Se define el vector dxdt como un vector columna de tamaño 5x1
dxdt = zeros(5, 1);

% Parámetros del sistema rotacional

B = 1; % Coeficiente de amortiguamiento
K1 = 1; % Constante del resorte K1
K2 = 1; % Constante del resorte K2
K3 = 1; % Constante del resorte K3
M1 = 1; % Momento de inercia de la masa 1
M2 = 1; % Momento de inercia de la masa 2

% Valor de la entrada, que es un escalón

ut = 1;

% Se definen las ecuaciones en primera derivada (dxi/dt)

dxdt(4) = (1/M1 )* ut - (1/M1) * x(2);
dxdt(5) = (1/M2) * x(2) - (1/M2) * x(1) - (1/M2) * x(3);
dxdt(2) = (K1) * x(4)- (K1) * x(5);
dxdt(3) = (K2) * x(5);
dxdt(1) = (K3) *x(5)- (K3*B)*x(1);
end
Luego de declarar la función solEDO se hace uso de esta en un segundo m-file:

% Limpia la memoria, cierra las figuras existentes y limpia la ventana de

comandos
clear, close all, clc;

% Definición de parámetros del sistema

B = 1;
K1 = 1;
K2 = 1;
K3 = 1;
J1 = 1;
J2 = 1;

% Especificación del rango de tiempo de la simulación, en segundos

ts = [0 60];

% Define el estado inicial del sistema, que es de orden tres

x0 = [0 0 0 0 0];

% Invocación de la función solEDO y resolución con ODE45.

% La solución entrega el vector de tiempos t y el vector x
[t, x] = ode45('solEDO', ts, x0);

% Crear una figura para los primeros tres subplots

figure;

% Subplot 1: x1 vs. Tiempo

subplot(3, 1, 1);
plot(t, x(:, 1), 'LineWidth', 1.5);
grid on;
xlabel('Tiempo [s]');
ylabel('x1 = fK3');
title('Variable de estado x1(t)');

% Subplot 2: x2 vs. Tiempo

subplot(3, 1, 2);
plot(t, x(:, 2), 'LineWidth', 1.5);
grid on;
xlabel('Tiempo [s]');
ylabel('x2 = fK1');
title('Variable de estado x2(t)');

% Subplot 3: x3 vs. Tiempo

subplot(3, 1, 3);
plot(t, x(:, 3), 'LineWidth', 1.5);
grid on;
xlabel('Tiempo [s]');
ylabel('x3 = fK2');
title('Variable de estado x3(t)');
% Crear una nueva figura para los últimos tres subplots
figure;

% Subplot 4: x4 vs. Tiempo

subplot(3, 1, 1);
plot(t, x(:, 4), 'LineWidth', 1.5);
grid on;
xlabel('Tiempo [s]');
ylabel('x4 = VM1');
title('Variable de estado x4(t)');

% Subplot 5: x5 vs. Tiempo

subplot(3, 1, 2);
plot(t, x(:, 5), 'LineWidth', 1.5);
grid on;
xlabel('Tiempo [s]');
ylabel('x5 = VM2');
title('Variable de estado x5(t)');

% Subplot 6: yt vs. Tiempo

subplot(3, 1, 3);
plot(t, x(:, 1), 'LineWidth', 1.5);
grid on;
xlabel('Tiempo [s]');
ylabel('y3(t) = x1');
title('Salida y3(t)');
Como resultado obtenemos las siguientes graficas:
Comparación de los resultados:
Pudimos ver el comportamiento que presento cada modelo ante un escalón como entrada
con una salida idéntica, en la gráfica función de transferencia y diagrama de bloques y la
gráfica función de transferencia.
Conclusiones
Como evidenciamos anteriormente, el resultado es que todas las señales de salida se
solapan y superponen, por lo tanto, son idénticas; esto quiere decir que el resultado es el
mismo independientemente el modelo que se use.