Práctica 1_DS

Vista previa del material en texto

Práctica en MATLAB 
Instituto Tecnológico de la Laguna 
Dinámica de Sistemas 
Tema 1: Marco matemático 
Mecatrónica 
Fecha: 23 de abril de 2021 
Desarrollo de la práctica 
A) Representación de algunas señales de prueba en el análisis de sistemas dinámicos usando 
MATLAB. 
a) Escalón unitario 
>> t=-5:0.01:10; 
>>u=heaviside(t); 
>>plot(t,u); 
 
b) Escalón desplazado 
>> t=-5:0.01:10; 
>> u=heaviside (t-2); 
>> plot(t,u); 
 
 
c) Impulso unitario 
>> t=-5:0.01:10; 
>> d=gauspuls(t); 
>> plot(t,d); 
 
 
d) Rampa unitaria 
Aquí el operador punto significa que cada valor del vector “t” se multiplicará por el escalón 
unitario (heaviside). 
>> t=-5:0.01:10; 
>> r=t.*heaviside(t); 
>> plot(t,r); 
 
 
e) Exponencial decreciente 
>> t=-5:0.01:10; 
>> x=exp(-2*t).*heaviside(t); 
>> plot(t,x); 
 
f) Senoidal amortiguada 
>> t=0:0.01:10; 
>> y=exp(-t).*sin(2*pi*t); 
>> plot(t,y); 
 
 
B) Convolución continua por el método de casos 
En el siguiente ejemplo se realizará la convolución entre las siguientes señales: x(t) que es la entrada 
y h(t) que es la respuesta impulsiva. 
𝑥𝑥(𝑡𝑡) = 𝑢𝑢(𝑡𝑡) − 𝑢𝑢(𝑡𝑡 − 2) 
ℎ(𝑡𝑡) = (1 − 𝑡𝑡)[𝑢𝑢(𝑡𝑡) − 𝑢𝑢(𝑡𝑡 − 1)] 
Se escribirá en el Command Window de MATLAB el siguiente código, minimizando en algunas 
ocasiones la gráfica obtenida para no cerrarla hasta el último de los casos, esto permitirá ir viendo 
la evolución de la convolución: 
 
Se define primero la señal x(t): 
>> tx1=-2:0.1:0; 
>>tx2=0:0.1:2; 
>>tx3=2:0.1:4; 
>> tx=[tx1,tx2,tx3]; 
>> x1=zeros(size(tx1)); 
>>x2=ones(size(tx2)); 
>>x3=zeros(size(tx3)); 
>> x=[x1,x2,x3]; 
 
Luego, se define la señal h(t): 
>> th1=-2:0.1:0; 
>>th2=0:0.1:1; 
>>th3=1:0.1:4; 
>> th=[th1,th2,th3]; 
>> h1=zeros(size(th1)); 
>>h2=1-th2; 
>>h3=zeros(size(th3)); 
>> h=[h1,h2,h3]; 
 
 
Y luego se grafican: 
 
Teniendo la gráfica 
 
Ahora se obtendrá la señal espejo para h(t): 
 
 
 
Analizando los casos de la señal móvil que es h(t), se tiene: 
1. Primer Caso: t < 0 (Se escoge un valor de t = -2, sólo se trata de que en el primer caso no se 
traslapen las señales). 
 
 
2. Segundo Caso: 0 < t < 1 (Aquí se elige un valor entre 0 y 1, para mostrar que la señal móvil 
empieza a traslaparse, además se agrega un código para que se distinga el área traslapada). 
 
 
3. Tercer caso: 1 < t < 2. (Se escoge como tiempo de inicio t =1.5). 
 
 
4. Cuarto caso: 2 < t < 3, en este caso la señal móvil está a punto de salir de x(t), por lo que se 
escoge un tiempo de 2.5. 
 
 
5. Caso cinco: t > 3, Aquí la señal móvil abandona a x(t) por lo que se escoge un valor de t = 
3.5. 
 
 
Para finalizar el problema sólo falta calcular las integrales en los casos 2, 3 y 4, ya que en el 1 y el 5 
la convolución es cero. 
Para facilitar los cálculos en MATLAB, se definen como variables simbólicas t y T, esta última 
representa la variable tau. 
Primera integral 
 
Segunda integral 
 
Tercera integral 
 
Se concluye que la salida generada por la convolución es: 
𝒚𝒚(𝒕𝒕) =
⎩
⎪⎪
⎨
⎪⎪
⎧𝒕𝒕 −
𝒕𝒕𝟐𝟐
𝟐𝟐
, 𝟎𝟎 < 𝒕𝒕 ≤ 𝟏𝟏
𝟏𝟏
𝟐𝟐
, 𝟏𝟏 < 𝒕𝒕 ≤ 𝟐𝟐
(𝒕𝒕 − 𝟑𝟑)𝟐𝟐
𝟐𝟐
, 𝟐𝟐 < 𝒕𝒕 ≤ 𝟑𝟑
𝟎𝟎, 𝒐𝒐𝒕𝒕𝒐𝒐𝒐𝒐 𝒄𝒄𝒄𝒄𝒄𝒄𝒐𝒐
 
Gráficamente, se tiene 
 
 
C) Ahora se analizará el mismo ejemplo, pero utilizando el comando conv con el que cuenta 
MATLAB, pero primero se deben aclarar unas reglas que deben emplearse para cualquier 
problema donde se requiera usar la convolución para determinar la respuesta de un sistema 
dinámico. 
 
Reglas para realzar la convolución usando el comando CONV de Matlab. 
1. Las dos señales (entrada y respuesta al impulso) deben definirse en el mismo intervalo de 
tiempo. Por lo tanto, ambas señales se definen en el intervalo a ≤ 𝑡𝑡 ≤ 𝑏𝑏. En 𝑡𝑡 = 𝑎𝑎, se tiene 
el primer instante de tiempo en el que al menos una de las señales no es cero y en 𝑡𝑡 = 𝑏𝑏 
es el último instante en el tiempo en el que al menos una se las señales no es cero. En 
nuestro ejemplo, el intervalo de tiempo es 0 ≤ 𝑡𝑡 ≤ 2. En ese lapso, la señal de entrada es 
𝑥𝑥(𝑡𝑡) = 1 y la respuesta impulsiva es expresada como. 
𝒉𝒉(𝒕𝒕) = �𝟏𝟏 − 𝒕𝒕, 𝟎𝟎 ≤ 𝒕𝒕 ≤ 𝟏𝟏 𝟎𝟎, 𝟏𝟏 ≤ 𝒕𝒕 ≤ 𝟐𝟐 
2. Cuando una señal consta de varias partes, los intervalos de tiempo en los que se define 
cada parte no deben traslaparse o sobreponerse. Por lo tanto, la respuesta impulsiva o 
señal móvil debe definirse como 
𝒉𝒉(𝒕𝒕) = �𝟏𝟏 − 𝒕𝒕, 𝟎𝟎 ≤ 𝒕𝒕 ≤ 𝟏𝟏 𝟎𝟎, 𝟏𝟏 < 𝒕𝒕 ≤ 𝟐𝟐 
En MATLAB quedaría como 
 
3. La salida del comando conv debe multiplicarse por el tamaño de paso usado para definir 
las señales 𝑥𝑥(𝑡𝑡) y ℎ(𝑡𝑡) para calcular correctamente la respuesta del sistema. Esta regla 
nace debido a que la integral de convolución se aproxima mediante una suma en MATLAB. 
 
 
 
Se debe cumplir que el número de datos de la salida 𝑦𝑦(𝑡𝑡) debe ser igual al tamaño de 𝑥𝑥(𝑡𝑡) más el 
tamaño de ℎ(𝑡𝑡) menos 1. 
 
4. La salida del sistema debe graficarse en un intervalo doble de tiempo en el que fueron 
definidas las señales 𝑥𝑥(𝑡𝑡) y ℎ(𝑡𝑡). 
 
 
Para poder usar el comando conv, deben realizarse estrictamente las cuatro reglas antes 
mencionadas y deben quedar claras. Es decir, se deben aplicar todas y cada una de las reglas en 
estricto orden. 
 
D) El siguiente programa (scrpipt) en MATLAB, genera la convolución gráfica entre las siguientes 
funciones, las cuales se describen por tramos o el comando tripuls del MATLAB. 
El código es: 
 
 
Al correr el código se produce la siguiente animación. 
 
 
 
Tarea: 
1. Para el ejercicio de convolución visto en clase, escriba los comandos correspondientes en 
MATLAB para resolverla por: 
a) Método Gráfico (Casos). 
%Definiendo f(t) 
tf1=-2:0.1:0; 
tf2=0:0.1:1; 
tf3=1:0.1:2; 
tf4=2:0.1:4; 
f1=zeros(size(tf1)); 
f2=2*ones(size(tf2)); 
f3=ones(size(tf3)); 
f4=zeros(size(tf4)); 
tf=[tf1,tf2,tf3,tf4]; 
f=[f1,f2,f3,f4]; 
 
%Definiendo g(t) 
tg1=-2:0.1:0; 
tg2=0:0.1:1; 
tg3=1:0.1:2; 
tg4=2:0.1:4; 
g1=zeros(size(tg1)); 
g2=ones(size(tg2)); 
g3=ones(size(tg3)); 
g4=zeros(size(tg4)); 
tg=[tg1,tg2,tg3,tg4]; 
g=[g1,g2,g3,g4]; 
 
 
%Graficando ambas señales 
plot(tf,f,tg,g,':*') 
ylim([0.1 2.2]); 
legend ('f(\tau)','g(\tau)'); 
grid 
xlim ([-1 3]); 
 
%Obteneindo g(-tau) gráficamente 
plot(tf,f,-tg,g,':*') 
legend ('f(\tau)','g(\tau)'); 
grid 
xlim([-2.5 2.5]); 
ylim ([-0.1 2.1]); 
 
 
%Falta agregar el parámetro "t" para poder hacer móvil a la g(-tau) 
 
%Caso 1. t<0 
%se escoge un valor menor que cero que se encuentre dentro de los vectores definidos 
t=-2; 
plot(tf,f,-tg+t,g,':*'); 
legend ('f(\tau)','g(\tau)'); 
grid 
ylim([-0.1 2.1]); 
 
%Caso 2. 0<t<1 
%se escoge un valor entre 0 y 1 
t=0.5; 
plot(tf,f,-tg+t,g,':*'); 
legend ('f(\tau)','g(\tau)'); 
grid 
ylim([-0.1 2.1]) 
%Para observar cómo se empalman las señales 
T=1; 
r=0:0.1:t; 
a=(2/T-1/T-1/T)*r+1; 
hold on; 
area(r,a); 
hold off; 
 
%Caso 3. 1<t<2 
%se escoge un valor entre 1 y 2 
t=1.5; 
plot(tf,f,-tg+t,g,':*'); 
legend ('f(\tau)','g(\tau)'); 
grid 
ylim([-0.1 2.1]) 
%Para observar cómo se empalman las señales 
T=1; 
r=0:0.1:t; 
a=(2/T-1/T-1/T)*r+1; 
hold on; 
area(r,a); 
hold off; 
 
%Caso 4. 2<t<3 
%se escoge un valor entre 2 y 3 
t=2.5; 
plot(tf,f,-tg+t,g,':*'); 
legend ('f(\tau)','g(\tau)'); 
grid 
ylim([-0.1 2.1]) 
%Para observar cómo se empalman las señales 
T=1; 
r=(t-2):0.1:2; 
a=(2/T-1/T-1/T)*r+1; 
hold on; 
area(r,a); 
hold off; 
 
%Caso 5. 3<t<4 
%se escoge un valor entre 3 y 4 
t=3.5; 
plot(tf,f,-tg+t,g,':*'); 
legend ('f(\tau)','g(\tau)'); 
grid 
ylim([-0.1 2.1]) 
%Para observar cómo se empalman las señales 
T=1; 
r=(t-2):0.1:2; 
a=(2/T-1/T-1/T)*r+1; 
hold on; 
area(r,a); 
hold off; 
 
 
%Caso 6. t>4 
%se escoge un valor mayor que 4 
t=4.5; 
plot(tf,f,-tg+t,g,':*'); 
legend ('f(\tau)','g(\tau)'); 
grid 
ylim([-0.1 2.1]) 
 
Para finalizar el problema sólofalta calcular las integrales en los casos 2, 3 y 4, ya que en el 1 y el 5 
la convolución es cero. 
%Calculando la integral 
syms t T 
f1=2; 
f2=1; 
 
Primera integral 
%Para valores de tiempo de 0 a 1 
%los límites de la integral son de 0 a t 
y1=int(f1,T,0,t) 
y1 = 2*t 
 
Segunda integral 
%Para valores de tiempo de 1 a 2 
%los límites de la integral son de 0 a 1 y de 1 a t 
y2 = int(f1,T,0,1) + int (f2,T,1,t) 
y2 = t + 1 
 
Tercera integral 
%Para valores de tiempo de 2 a 3 
%los límites de la integral son de t-2 a 1 y de 1 a 2 
y3 = int(f1,T,t-2,1) + int (f2,T,1,2) 
y3 = 7 - 2*t 
 
Cuarta integral 
%Para valores de tiempo de 3 a 4 
%los límites de la integral son de t-2 a 2 
y4= int(f2,T,t-2,2) 
y4 = 4 – t 
 
La respuesta, finalmente, queda como: 
𝒚𝒚(𝒕𝒕) =
⎩
⎪
⎨
⎪
⎧
𝟐𝟐𝒕𝒕, 𝟎𝟎 < 𝒕𝒕 ≤ 𝟏𝟏
𝒕𝒕 + 𝟏𝟏, 𝟏𝟏 < 𝒕𝒕 ≤ 𝟐𝟐
−𝟐𝟐𝒕𝒕 + 𝟕𝟕, 𝟐𝟐 < 𝒕𝒕 ≤ 𝟑𝟑
𝟒𝟒 − 𝒕𝒕, 𝟑𝟑 < 𝒕𝒕 ≤ 𝟒𝟒
𝟎𝟎, 𝒐𝒐𝒕𝒕𝒐𝒐𝒐𝒐 𝒄𝒄𝒄𝒄𝒄𝒄𝒐𝒐
 
%Graficando los resultados 
t1=0:0.1:1; 
t2=1:0.1:2; 
t3=2:0.1:3; 
t4=3:0.1:4; 
 
y1=t1.*2; 
y2=t2.*1 + 1; 
y3=7 - t3.*2; 
y4=4 - t4.*1; 
t=[t1 t2 t3 t4]; 
y=[y1 y2 y3 y4]; 
plot(t,y); 
ylim([-0.1 2.1]) 
xlim([-0.1 4.1]) 
ylim([-0.1 3]) 
ylim([-0.1 3.3]) 
ylim([0 3.3]) 
title('Señal de salida y(t)') 
 
 
 
b) Usando el comando CONV. 
 
 
 
c) Modifique el programa de la sección D, para obtener la convolución. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2.- Resuelva las siguientes ecuaciones diferenciales usando el comando dsolve. 
a) 𝒅𝒅𝒅𝒅
𝒅𝒅𝒕𝒕
+ 𝟕𝟕𝒅𝒅 = 𝟓𝟓𝒄𝒄𝒐𝒐𝒄𝒄(𝟐𝟐𝒕𝒕) 𝒅𝒅 �𝝅𝝅
𝟒𝟒
� = 𝟎𝟎 𝒅𝒅′ �𝝅𝝅
𝟒𝟒
� = 𝟎𝟎 
dsolve ('Dx+7*x=5*cos(2*t)' , 'x(pi/4)=0' , 'Dx(pi/4)=0') 
ans = 
(5*53^ (1/2) *cos (2*t - atan (2/7))) /53 - (5*53^ (1/2) *cos (pi/2 - atan (2/7)) *exp((7*pi) /4) *exp(-
7*t)) /53 
Reacomodando el resultado obtenido por Matlab se obtendría: 
5(53)1/2 ∙ cos(2𝑡𝑡 − tan−1(2/7)
53 −
5(53)1/2(cos(𝜋𝜋/2 − tan−1(2/7))) �𝑒𝑒�
7𝜋𝜋
4 �� �𝑒𝑒(−7𝑡𝑡)�
53 
 
b) �̈�𝒚 + 𝟐𝟐�̇�𝒚 + 𝒚𝒚 = 𝟓𝟓𝒆𝒆−𝟐𝟐𝒕𝒕 𝒚𝒚(𝟎𝟎) = 𝟐𝟐 𝒚𝒚′(𝟎𝟎) = 𝟏𝟏 
 
dsolve ('D2y+2*Dy+y=5*exp(-2*t)' , 'y(0) =2' , 'Dy(0)=1') 
 ans = 
 8*t*exp(-t) - 3*exp(-t) - 5*t*exp(-2*t) + 5*exp(-2*t) *(t + 1) 
Reacomodando el resultado obtenido por Matlab: 
8𝑡𝑡𝑒𝑒−𝑡𝑡 − 3𝑒𝑒−𝑡𝑡 − 5𝑡𝑡𝑒𝑒−2𝑡𝑡 + 5𝑒𝑒−2𝑡𝑡(𝑡𝑡 + 1) 
 
Observaciones y conclusiones 
Matlab resulta ser una herramienta muy útil para estudiantes de ingeniería. Gracias al desarrollo 
de esta práctica, fue posible introducirse al entorno de este programa con el cual estaremos 
trabajando a lo largo, primero que nada, de la materia, y, posteriormente, en la carrera de 
ingeniería. Se pudo analizar que, como todo, en un inicio puede llegar a ser algo complicado ya 
que es algo "nuevo". Sin embargo, conforme se iba avanzando en la realización de la práctica, todo 
se fue haciendo un poco más "sencillo", ya que no se presentaban los errores que en un inicio sí. 
Ahora, pasando específicamente a la realización del ejercicio, fue posible desarrollar un ejemplo 
que se había visto "teóricamente", donde se habían obtenido las funciones, pero no se había 
realizado la gráfica, lo cual, con ayuda de este programa, se realizó sin ningún problema, además 
de, observar en cada caso la manera en que se empalmen ambas funciones y, también, analizar la 
animación que se genera, en la cual se ve "paso a paso" cómo se va realizando la convolución. 
Adicionalmente, este software nos fue -y nos va a ser- de ayuda para comprobar la respuesta a 
ciertos ejercicios matemáticos, tales como una ecuación diferencial, o cualquier otra operación 
matemática, aunado a tener a la mano una herramienta para graficar, por ejemplo, una función 
rampa, una función exponencial, senoidal, senoidal amortiguada, etc. y poder analizar 
comportamiento de ciertas funciones que se nos den como resultado. 
Nos gustaría puntualizar que es un software muy potente, pero, como toda herramienta, es 
necesario saberla utilizar. En primera instancia, la interfaz puede resultar abrumadora ya que no 
es tan "sencilla" como otros softwares matemáticos; es un poco menos intuitiva en un primer 
acercamiento, ya que los comandos que hemos analizado hasta el momento son mediante textos. 
Pero, una vez dentro del programa y con los conocimientos básicos, podemos sacarle bastante 
provecho.