Categoría: Soluciones

Ejercicio: 1Eva2016TII_T4 LTI DT Sistema 2do orden

literal a. Ecuación de diferencias de coeficientes constantes

Al diagrama del ejercicio se añaden las referencias de y[n], y[n-1] y y[n-2] de acuerdo a los bloques de retraso (delay) para escribir la expresión:

y[n] = x[n] + \frac{3}{4} y[n-1] - \frac{1}{8} y[n-2] y[n] - \frac{3}{4} y[n-1] + \frac{1}{8} y[n-2] = x[n]

Para usar los operadores ‘E’ y encontrar el polinomio característico, dado que el sistema es LTI – DT, se  puede desplazar 2 unidades:

y[n+2] - \frac{3}{4} y[n+1] + \frac{1}{8} y[n] = x[n+2]

La expresión usando notación de operadores ‘E’ es:

\Big[ E^2 - \frac{3}{4} E + \frac{1}{8} \Big] y[n] = E^2 x[n]

donde el numerador P[E] = E²
y el denominador Q[E] = E² – (3/4)E +(1/8)

H(E) = \frac{P[E]}{Q[E]} = \frac{E^2}{E^2-\frac{3}{4}E+\frac{1}{8}}

---

literal b. Respuesta a impulso

A partir de la notación de operadores’E’,  se busca los modos característicos en el polinomio del denominador Q(E). También se expresa como y[n] como resultado de entrada cero x[n]=0

Q[E] = E^2 - \frac{3}{4} E + \frac{1}{8} \gamma^2 - \frac{3}{4} \gamma + \frac{1}{8} = 0

usando la fórmula o el algoritmo se busca las raices del polinomio Q(E):

(\gamma - \frac{1}{4})(\gamma - \frac{1}{2}) = 0 \gamma_1 = \frac{1}{4} ; \gamma_2 = \frac{1}{2}

Siendo raices reales y no repetidas, la respuesta del sistema tiene la forma:

y_c[n] = c_1 \Big( \frac{1}{4} \Big) ^n +c_2 \Big( \frac{1}{2} \Big) ^n

se convierte a la forma:

h[n] =\frac{b_n}{a_n} \delta [n] + y_c[n] \mu [n] h[n] = \Bigg[ c_1 \Big( \frac{1}{4} \Big) ^n +c_2 \Big( \frac{1}{2} \Big) ^n \Bigg] \mu [n]

Para encontrar los coeficientes c₁ y c₂, se requieren dos valores iniciales. En el literal a se indica que el sistema es causal, en consecuencia «No es posible obtener una salida antes que se aplique la entrada» y tenemos que: y[-1] = 0; y[-2] = 0.

La ecuación original de y[n] para respuesta a impulso tiene entrada x[n]=δ[t]

y[n] = \frac{3}{4} y[n-1] - \frac{1}{8} y[n-2] + x[n] y[n] = \frac{3}{4} y[n-1] - \frac{1}{8} y[n-2] + \delta [n]

donde el impulso tiene valor de 1 solo en n=0, haciendo equivalente h[n] equivale a y[n] , entonces:

h[n] = \delta [n] + \frac{3}{4} h[n-1] - \frac{1}{8} h[n-2]

n = 0

h[0] = \delta [0] + \frac{3}{4} h[-1] - \frac{1}{8} h[-2] h[0] = \delta [0] + \frac{3}{4} (0) - \frac{1}{8} (0) = 1

n=1

h[1] = \delta [1] + \frac{3}{4} h[0] - \frac{1}{8} h[-1] h[1] = (0) + \frac{3}{4} (1) - \frac{1}{8} (0) = \frac{3}{4}

con lo que es posible encontrar c₁ y c₂,

h[0] = 1 = c_1 \Big( \frac{1}{4} \Big) ^0 \mu [0] + c_2 \Big( \frac{1}{2} \Big) ^0 \mu (0) c_1 + c_2 = 1 h[1] = \frac{3}{4} = c_1 \Big( \frac{1}{4} \Big) ^1 \mu [1] + c_2 \Big( \frac{1}{2} \Big) ^1 \mu (1) \frac{1}{4} c_1 + \frac{1}{2} c_2 = \frac{3}{4}

resolviendo:

c_1 = -1 c_2 = 2 h[n] = - \Big( \frac{1}{4} \Big) ^n \mu [n] + 2 \Big( \frac{1}{2} \Big) ^n \mu [n] h[n] = \Bigg[ 2 \Big( \frac{1}{2} \Big) ^n - \Big( \frac{1}{4} \Big) ^n \Bigg] \mu [n]

Observaciones:

Las raíces características o frecuencias naturales del sistema se encuentran dentro del círculo de radio unitario. El sistema es asintóticamente estable, que implica que es BIBO estable.

h[n] no es de la forma k δ[n], por lo que el sistema global es con memoria.

La forma de respuesta al impulso se vuelve evidente que el sistema es IIR.

Algoritmo en Python

Usando el algoritmo de LTID – Respuesta impulso. Ejercicio con Python:

 respuesta impulso: 
hi: [1.   0.75]
Matriz: 
[[1.   1.  ]
 [0.5  0.25]]
Ch:  [ 2. -1.]
n>=0, hn:  
      n          n
- 0.25  + 2.0*0.5 
>>> 

Instrucciones Python

# Sistema LTID. Respuesta impulso
# QE con raices Reales NO repetidas Lathi ejemplo 3.13 pdf271
# Lathi ejemplo 3.18 y 3.19 pdf278,
# blog.espol.edu.ec/telg1001
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt

# INGRESO
# coeficientes E con grado descendente
QE = [1.0, -3/4, 1/8]
PE = [1., 0., 0.]
# condiciones iniciales ascendente ...,y[-2],y[-1]
inicial = [0, 0.]

tolera = 1e-6  # casi_cero
muestras = 10  # para grafica

# PROCEDIMIENTO
# Respuesta a ENTRADA CERO
# raices, revisa numeros complejos
gamma = np.roots(QE)
revisaImag = np.iscomplex(gamma)
escomplejo = np.sum(revisaImag)

# coeficientes de ecuacion
m_q = len(QE)-1
Ac = np.zeros(shape=(m_q,m_q),dtype=float)

# revisa si parte compleja <tolera o casi_cero 
if escomplejo>0:
    for i in range(0,m_q,1):
        valorimag = np.imag(gamma[i])
        if np.abs(valorimag)<tolera:
            gamma[i] = float(np.real(gamma[i]))
    sumaj = np.sum(np.abs(np.imag(gamma)))
    if sumaj <tolera:
        print(sumaj)
        gamma = np.real(gamma)
        escomplejo = 0

# revisa repetidos
unicoscuenta = np.unique(gamma,return_counts=True)
repetidas = np.sum(unicoscuenta[1]-1)

# Respuesta impulso h[n]
ki = np.arange(-m_q,m_q,1)
hi = np.zeros(m_q, dtype=float)
xi = np.zeros(2*m_q, dtype=float)
xi[m_q] = 1 # impulso en n=0
Ah = np.zeros(shape=(m_q,m_q),dtype=float)

# h[n] iterativo
p_n = len(PE)
for i in range(0,m_q,1):
    for k in range(m_q,2*m_q,1):
        hi[i] = hi[i] - QE[k-m_q]*hi[m_q-k+1]
    for k in range(0,p_n,1):
        hi[i] = hi[i] + PE[k]*xi[m_q+i]
Bh = np.copy(hi[:m_q])

# coeficientes de ecuacion
for i in range(0,m_q,1):
    for j in range(0,m_q,1):
        Ah[i,j] = gamma[j]**(i)
ch = np.linalg.solve(Ah,Bh)

# ecuacion hn
n = sym.Symbol('n')
hn = 0*n
for i in range(0,m_q,1):
    hn = hn + ch[i]*(gamma[i]**n)

# SALIDA
if escomplejo == 0: 
    print('\n respuesta impulso: ')
    print('Bh:',Bh)
    print('Matriz: ')
    print(Ah)
    print('Ch: ',ch)
    print('n>=0, hn:  ')
    sym.pprint(hn)
else:
    print(' existen raices con números complejos.')
    print(' usar algoritmo de la sección correspondiente.')
    

# grafica datos
ki = np.arange(-m_q,muestras,1)
hi = np.zeros(muestras+m_q)

if escomplejo == 0: 
    # evaluación de h[n]
    h_n = sym.lambdify(n,hn)
    hi[m_q:] = h_n(ki[m_q:])

    # grafica h[n]
    plt.stem(ki,hi,label='h[n]',
             markerfmt ='C1o',
             linefmt='C2--')
    plt.legend()
    plt.grid()
    plt.ylabel('h[n]')
    plt.xlabel('ki')
    plt.title('h[n] = '+str(hn))
    plt.show()

---

literal c.  respuesta de paso s[n]

s[n] = \sum_{k=-\infty}^{n} h[k] s[n \rightarrow \infty] = \sum_{k=-\infty}^{\infty} h[k] = \sum_{k=-\infty}^{\infty} \Bigg[ 2 \Big( \frac{1}{2} \Big) ^k - \Big( \frac{1}{4} \Big) ^k \Bigg] \mu [k] = \sum_{k=0}^{\infty} \Bigg[ 2 \Big( \frac{1}{2} \Big) ^k - \Big( \frac{1}{4} \Big) ^k \Bigg]

considerando que:

\sum_{k=0}^{\infty} \alpha ^k = \frac{1}{1-\alpha} ; |\alpha|<1

se reemplaza con:

s[n \rightarrow \infty] = \sum_{k=0}^{\infty} \Bigg[ 2 \Big( \frac{1}{2} \Big) ^k - \Big( \frac{1}{4} \Big) ^k \Bigg] = 2\frac{1}{1-\frac{1}{2}} - \frac{1}{1-\frac{1}{4}} = 2(2) - \frac{4}{3} s[n \rightarrow \infty] =\frac{8}{3}

un método mas detallado es:

s[n] = \sum_{k=-\infty}^{n} h[k] s[n] = \sum_{k=-\infty}^{n} \Bigg[ 2 \Big( \frac{1}{2} \Big) ^k - \Big( \frac{1}{4} \Big) ^k \Bigg] \mu [k] s[n] = \sum_{k=0}^{n} \Bigg[ 2 \Big( \frac{1}{2} \Big) ^k - \Big( \frac{1}{4} \Big) ^k \Bigg] s[n] = 2 \sum_{k=0}^{n} \Big( \frac{1}{2} \Big) ^k - \sum_{k=0}^{n} \Big( \frac{1}{4} \Big) ^k

considerando que:

\sum_{k=0}^{n} \alpha ^k = \frac{1-\alpha ^{n+1}}{1-\alpha}

se tiene lo siguiente,

s[n] = 2 \frac{1-\frac{1}{2}^{n+1}}{1-\frac{1}{2}} - \frac{1-\frac{1}{4}^{n+1}}{1-\frac{1}{4}} s[n] = 2 \frac{1-\frac{1}{2} \Big(\frac{1}{2} \Big)^{n}}{\frac{1}{2}} - \frac{1-\frac{1}{4} \Big( \frac{1}{4} \Big)^{n}}{\frac{3}{4}} s[n] = 4 \Bigg[ 1-\frac{1}{2} \Big(\frac{1}{2}\Big)^{n} \Bigg]- \frac{4}{3} \Bigg[ 1- \frac{1}{4} \Big(\frac{1}{4} \Big)^{n} \Bigg] s[n] = 4-2 \Big(\frac{1}{2}\Big)^{n} -\frac{4}{3}+ \frac{1}{3} \Big(\frac{1}{4} \Big)^{n} lim _ {n \to \infty}s[n] = lim _ {n \to \infty} \Bigg[ \frac{8}{3}-2 \Big(\frac{1}{2}\Big)^{n} + \frac{1}{3} \Big(\frac{1}{4} \Big)^{n} \Bigg] lim _ {n \to \infty}s[n] = \frac{8}{3}

que es el mismo resultado que con el método presentado al inicio del literal.

---

---

Solución alterna: Usando transformada z

Revisar: LTID Transformada z – X[z] Fracciones parciales modificadas con Python

A partir de la ecuación de diferencias:

y[n+2] - \frac{3}{4} y[n+1] + \frac{1}{8} y[n] = x[n+2]

en transformada z (unidad 7), que es semejante a operador ‘E’,

z^2 Y[z]- \frac{3}{4} z Y[z] + \frac{1}{8}Y[z] = z^2 X[z] \Big[ z^2 - \frac{3}{4} z + \frac{1}{8}\Big] Y[z] = z^2 X[z]

la función de transferencia o respuesta al impulso se expresa como:

H[z] = \frac{X[z]}{Y[z]} = \frac{z^2}{z^2 - \frac{3}{4} z + \frac{1}{8}}

usandolas raices del polinomio Q(E)

H[z] = \frac{z^2}{(z - \frac{1}{4})(z - \frac{1}{2})}

para facilitar las operaciones se usan fracciones parciales modificadas,

\frac{H[z]}{z} = \frac{z}{(z - \frac{1}{4})(z - \frac{1}{2})} = \frac{k_1}{z - \frac{1}{4}} + \frac{k_2}{z - \frac{1}{2}}

Usando el método de «cubrir» de Heaviside:

k_1 = \frac{z}{\cancel{(z - \frac{1}{4})}(z - \frac{1}{2})} \Big|_{z=1/4} = \frac{1/4}{1/4 - \frac{1}{2}} = -1 k_2 = \frac{z}{(z - \frac{1}{4})\cancel{(z - \frac{1}{2})}} \Big|_{z=1/2} = \frac{1/2}{1/2 - \frac{1}{4}} = 2

reemplazando k1, k2 y restaurando a fracciones parciales al multiplicar ambos lados por z,

H[z] = \frac{-z}{z - \frac{1}{4}} + \frac{2z}{z - \frac{1}{2}}

se puede usar la tabla de transformadas z para obtener el mismo resultado que el desarrolo anterior con operador ‘E’

h[n] = - \Big( \frac{1}{4} \Big) ^n \mu [n] + 2 \Big( \frac{1}{2} \Big) ^n \mu [n]

Ejercicio: 1Eva2016TII_T3 LTI DT Sistema 1er orden con constante a

A partir del diagrama se tiene que:

literal a.1 ecuación que relaciona entrada-salida

El sistema es discreto de primer orden,

y[n] = x[n] + a y[n-1] y[n] - a y[n-1] = x[n]

literal a.2 Respuesta al impulso

Para la respuesta de impulso se escribe la expresión en notación de operador E, con x[n]=δ[n]

y[n+1] - a y[n] = x[n+1] Ey[n] - a y[n] = E x[n] (E -a) y[n] = E x[n]

para determinan las raíces del Q[E]

Q[E] = (\gamma-a) = 0 \gamma = a

que establece la ecuación

y_c[n] = c_1 a^n

Para encontrar el valor de la constante se evalua la expresión del sistema con  n=0, teniendo en cuenta que la ecuación general de respuesta a impulso:

h[n] = \frac{b_N}{a_N} \delta (n) + y_c[n] \mu [n] h[n] = y_c[n] \mu [n] = c_1 a^n \mu [n] y[n] = x[n] +a y[n-1] h[n] = \delta [n] +a h[n-1] h[0] = \delta [0] +a h[0-1]

El sistema es causal si para n<0 los valores son cero, h[-1] =0

h[0] = 1 +a (0) = 1

con lo que  par encontrar la constante c₁,

h[0] = 1 = c_1 a^0 \mu [0] =c_1 (1)(1) = c_1

la constante c₁ =1, quedando com respuesta a impulso:

h[n] = a^n \mu [n]

literal a.3 Respuesta de paso

s[n] = \sum_{k=-\infty}^{n} h[k] = \sum_{k=-\infty}^{n} a^k \mu [k]

Siendo:

\sum_{k=0}^{n} \alpha^k = \frac{1-\alpha^{n+1}}{1-\alpha} \mu [n]

se tiene que:

s[n] = \frac{1-a^{n+1}}{1-a} \mu [n]

Solución alterna, El mismo resultado se obtiene mediante:

s[n] = h[n] \circledast \mu [n]

usando la tabla de convolucion discreta:

= \sum_{k=- \infty}^{\infty} a^k \mu[k] \mu[n-k] = \sum_{k=0}^{n} a^k s[n] = \frac{1-a^{n+1}}{1-a} \mu [n]

---

literal b.

dado que h[n] no es de la forma k δ[n], el sistema es con memoria.

Si las raíces características, valores característicos o frecuencias naturales de un sistema, se encuentran dentro del círculo de radio unitario, el sistema es asintóticamente estable e implica que es BIBO estable.

h[n] = aⁿ μ[n] el sistema es de tipo IIR.

---

literal c. Sistema inverso

h[n] \circledast h_{inv} = \delta[n] y[n] = x[n] + a y[n-1] h[n] = \delta[n] + a h[n-1] h[n] - a h[n-1] = \delta[n] h[n] \circledast \delta [n] - a h[n] \circledast \delta [n-1] = \delta[n] h[n] \circledast (\delta [n] - a \delta [n-1]) = \delta[n] h_{inv}[n] = (\delta [n] - a \delta [n-1]) = \delta[n]

h[n] no es de la forma k δ[n], por lo que el sistema inverso es con memoria.

h[n]=0 para n<0, se entiende que el sistema inverso es Causal.

La respuesta impulso del sistema inverso es absolutamente sumable o convergente, por lo que el sistema es BIBO estable.

la forma de h_inv[n] el sistema es de tipo FIR.

---

literal d. Diagrama de bloques del sistema inverso

El diagrama del sistema inverso sería:

 

Ejercicio: 1Eva2016TII_T2 LTI CT bloques en paralelo-serie con Laplace ,  1Eva2012TII_T4 LTI CT bloques en paralelo-serie con Laplace, 1Eva2011TII_T3 LTI CT H(s) desde expresión con operadores D

Ejercicio resuelto: [ transformada de Laplace ] [integral convolución]

..

---

literal a. Funcion H(s) global

en el diagrama se muestran dos sistemas LTIC de primer orden, ambos sistemas se encuentran multiplicados por una constante y en paralelo.

La función de transferencia de un sistema LTIC de primer orden es
H(s) = 1/(s-a)

Con lo que el sistema se puede reescribir como:

H(s) = 3\frac{1}{s+7} + 12 \frac{1}{s-4}

Ceros y polos de H(s)

H(s) = \frac{3(s-4)+12(s+7)}{(s+7)(s-4)} = \frac{3s-12+12s+84}{(s+7)(s-4)} = \frac{15s+72}{(s+7)(s-4)}

los ceros se toman del numerador:

15s+72 = 0 s=\frac{-72}{15} = -\frac{24}{5}

los polos se toman del denominador:

(s+7)(s-4) = 0 s=-7 ; s= 4

literal b. La respuesta impulso h(t)

Los polos tienen signo diferente, lo que indica que el intervalo donde se encuentran incluyen al eje imaginario en el intervalo, por lo que el sistema es BIBO inestable. Por tener un polo a derecha del plano es asintoticamente inestable, su respuesta tiene componentes que crecen en el tiempo.

Como la región de convergencia ROC no se encuentra a la derecha de todos los polos, se tiene concluye que el sistema NO es causal.

h(t) = \mathscr{L}^{-1} [H(s)] = \mathscr{L}^{-1} \Big[ 3\frac{1}{s+7} + 12 \frac{1}{s-4}\Big] = \mathscr{L}^{-1} \Big[ 3\frac{1}{s+7} \Big] + \mathscr{L}^{-1} \Big[ 12 \frac{1}{s-4}\Big]

usando la tabla de transformadas o Sympy de Python

h(t) = 3e^{-7t} \mu (t) + 12 e^{4t} \mu (t)

literal c. Salida ante entrada x(t)

x(t) = e^{-5t} \mu (t)

X(s) = \frac{1}{s+5} Y(s) = X(s) H(s) =\frac{1}{s+5} \Bigg[\frac{15s+72}{(s+7)(s-4)}\Bigg] =\frac{15s+72}{(s+5)(s+7)(s-4)}

se usa fracciones parciales

=-\frac{3}{2(s+7)} + \frac{1}{6(s+5)}+\frac{4}{3(s-4)} y(t) = \mathscr{L}^{-1} [Y(s)] y(t) = \mathscr{L}^{-1} \Bigg[-\frac{3}{2(s+7)} + \frac{1}{6(s+5)}+\frac{4}{3(s-4)} \Bigg]

usando la tabla de transformadas de Laplace :

y(t) = -\frac{3}{2} e^{-7t} \mu (t) + \frac{1}{6}e^{-5t} \mu (t) +\frac{4}{3}e^{4t} \mu (-t)

---

Algoritmo en Python

realizado a partir de LTIC Laplace – Algoritmo Python para analizar estabilidad H(s), Y(s) con entrada cero, estado cero, condiciones iniciales

 H(s) = P(s)/Q(s):
  3       12 
----- + -----
s + 7   s - 4
 H(s) en factores:
  3*(5*s + 24) 
---------------
(s - 4)*(s + 7)

 h(t) :
/    4*t      -7*t\             
\12*e    + 3*e    /*Heaviside(t)

polosceros:
Q_polos : {4: 1, -7: 1}
P_ceros : {-24/5: 1}

Estabilidad de H(s):
 n_polos_real : 2
 n_polos_imag : 0
 enRHP : 1
 unicos : 0
 repetidos : 0
 asintota : inestable

 X(s): 
  1  
-----
s + 5

Respuesta entrada cero ZIR H(s) y condiciones iniciales
term_cero : 0
ZIR :
0
yt_ZIR :
0

 ZSR respuesta estado cero:
ZSR :
      3           1           4    
- --------- + --------- + ---------
  2*(s + 7)   6*(s + 5)   3*(s - 4)
yt_ZSR :
/   4*t    -5*t      -7*t\             
|4*e      e       3*e    |             
|------ + ----- - -------|*Heaviside(t)
\  3        6        2   /             

 Y(s)_total = ZIR + ZSR:
      3           1           4    
- --------- + --------- + ---------
  2*(s + 7)   6*(s + 5)   3*(s - 4)

 y(t)_total = ZIR + ZSR:
/   4*t    -5*t      -7*t\             
|4*e      e       3*e    |             
|------ + ----- - -------|*Heaviside(t)
\  3        6        2   /  

Instrucciones en Python

Usando los bloques desarrollados en la Unidad 4 Sistemas LTI – Laplace  y las funciones resumidas como telg1001.py que pueden ser usados en cada pregunta:

# Y(s) Respuesta total con entada cero y estado cero
# Qs Y(s) = Ps X(s) ; H(s)=Ps/Qs
# http://blog.espol.edu.ec/telg1001/
import sympy as sym
import matplotlib.pyplot as plt
import telg1001 as fcnm

# INGRESO
s = sym.Symbol('s')
t = sym.Symbol('t', real=True)
d = sym.DiracDelta(t)
u = sym.Heaviside(t)

# H(s) y estabilidad
Hs = 3/(s+7) + 12/(s-4)
#Hs = 1+0*s cuando es constante

# X(s) Señal de entrada
xt = sym.exp(-5*t)*u

# condiciones iniciales, [y'(0),y(0)] orden descendente
t0 = 0
cond_inicio = [0, 0] # estado cero no se usan

# Grafica, intervalo tiempo [t_a,t_b]
t_a = -0.2 ; t_b = 0.5
muestras = 101  # 51 resolucion grafica

# PROCEDIMIENTO
Hs = fcnm.apart_s(Hs) # fracciones parciales
Hs_fc = fcnm.factor_exp(Hs) # en factores
Hs_Qs2 = fcnm.Q_cuad_s_parametros(Hs_fc)

polosceros = fcnm.busca_polosceros(Hs)
Q_polos = polosceros['Q_polos']
P_ceros = polosceros['P_ceros']

estable = fcnm.estabilidad_asintotica_s(Q_polos)

# H(t) respuesta al impulso
ht = 0*s
term_suma = sym.Add.make_args(Hs)
for term_k in term_suma:
    ht_k = sym.inverse_laplace_transform(term_k,s,t)
    # simplifica log(exp()) ej: e**(-2s)/(s**2)
    if ht_k.has(sym.log):
        ht_k = sym.simplify(ht_k,inverse=True)
    ht  = ht + ht_k
lista_escalon = ht.atoms(sym.Heaviside)
ht = sym.expand(ht,t) # terminos suma
ht = sym.collect(ht,lista_escalon)

# PROCEDIMIENTO Respuesta ZIR, ZSR
Xs = fcnm.laplace_transform_suma(xt)

# ZIR_s respuesta entrada cero de s
sol_ZIR = fcnm.respuesta_ZIR_s(Hs,cond_inicio)
ZIR = sol_ZIR['ZIR']
yt_ZIR = sol_ZIR['yt_ZIR']

# ZSR respuesta estado cero, Y(s) a entrada X(s)
sol_ZSR = fcnm.respuesta_ZSR_s(Hs,Xs)
ZSR = sol_ZSR['ZSR']
yt_ZSR = sol_ZSR['yt_ZSR']

# Respuesta total Y(s) y y(t)
Ys = ZIR + ZSR
Ys = fcnm.apart_s(Ys)
yt = yt_ZIR + yt_ZSR
lista_escalon = yt.atoms(sym.Heaviside)
yt = sym.collect(yt,lista_escalon)

# SALIDA
print(' H(s) = P(s)/Q(s):')
sym.pprint(Hs)
print(' H(s) en factores:')
sym.pprint(Hs_fc)
if len(Hs_Qs2)>0:
    print('\nH(s) parámetros cuadraticos:')
    fcnm.print_resultado_dict(Hs_Qs2)

print('\n h(t) :')
sym.pprint(ht)

print('\npolosceros:')
fcnm.print_resultado_dict(polosceros)

print('\nEstabilidad de H(s):')
for k in estable:
    print('',k,':',estable[k])

print('\n X(s): ')
sym.pprint(Xs)
print('\nRespuesta entrada cero ZIR H(s) y condiciones iniciales')

if not(sol_ZIR == sym.nan): # existe resultado
    fcnm.print_resultado_dict(sol_ZIR)
else:
    print(' insuficientes condiciones iniciales')
    print(' revisar los valores de cond_inicio[]')

print('\n ZSR respuesta estado cero:')
fcnm.print_resultado_dict(sol_ZSR)

print('\n Y(s)_total = ZIR + ZSR:')
sym.pprint(Ys)
print('\n y(t)_total = ZIR + ZSR:')
sym.pprint(yt)

# Graficas polos, H(s), con polos h(t) --------
muestras_H = 201
figura_s  = fcnm.graficar_Fs(Hs_fc,Q_polos,P_ceros,f_nombre='H',solopolos=True)
figura_Hs = fcnm.graficar_Fs(Hs_fc,Q_polos,P_ceros,muestras=muestras_H,f_nombre='H')
figura_ht = fcnm.graficar_ft(ht,t_a,t_b,muestras,f_nombre='h')
# GRAFICAS y(t),x(t),h(t) ---------------------
figura_ft = fcnm.graficar_xh_y(xt,ht,yt,t_a,t_b,muestras)
plt.show()

Ejercicio resuelto: [ transformada de Laplace ] [integral convolución]
..

---

Ejercicio resuelto con integral de convolución, unidad 3

Algoritmo desarrollado con LTI CT Respuesta del Sistema Y(s)=ZIR+ZSR con Sympy-Python

 ZIR(t):
0

 h(t):
/    4*t      -7*t\             
\12*e    + 3*e    /*Heaviside(t)

 ZSR(t):
xh :
    4*t  -9*tau                                     
12*e   *e      *Heaviside(tau)*Heaviside(t - tau) + 

     -7*t  2*tau            
+ 3*e    *e     *Heaviside(tau)*Heaviside(t - tau)
xcausal : True
hcausal : True
[tau_a,tau_b] : [0, t]
intercambia : False
cond_graf : True
ZSR :
/   4*t    -5*t      -7*t\             
|4*e      e       3*e    |             
|------ + ----- - -------|*Heaviside(t)
\  3        6        2   /             

 y(t) = ZIR(t)+ZSR(t):
/   4*t    -5*t      -7*t\             
|4*e      e       3*e    |             
|------ + ----- - -------|*Heaviside(t)
\  3        6        2   /    

Las gráficas resultan iguales a las mostradas

Instrucciones con Python

# Respuesta total del sistema
# y(t) = ZIR(t) + ZSR(t)
# http://blog.espol.edu.ec/telg1001/lti-ct-yszirzsr-respuesta-del-sistema-con-sympy-python/
# Revisar causalidad de x(t) y h(t)
import numpy as np
import matplotlib.pyplot as plt
import sympy as sym
equivalentes = [{'DiracDelta': lambda x: 1*(x==0)},
                {'Heaviside': lambda x,y: np.heaviside(x, 1)},
                'numpy',]
import telg1001 as fcnm

# INGRESO
t = sym.Symbol('t',real=True)
tau = sym.Symbol('tau',real=True)
y = sym.Function('y')
x = sym.Function('x')
h = sym.Function('h')
u = sym.Heaviside(t)

# ecuacion: lado izquierdo = lado derecho
#           Left Hand Side = Right Hand Side
LHS = sym.diff(y(t),t,2) + 3*sym.diff(y(t),t,1) - 28*y(t)
RHS = 15*sym.diff(x(t),t,1,evaluate=False) + 72*x(t)
ecuacion = sym.Eq(LHS,RHS)

# condiciones iniciales [y'(t0),y(t0)]
t0 = 0
cond_inicio = [0,0]

# entrada x(t)
x = sym.exp(-5*t)*u

# grafica intervalo [t_a,t_b]
t_a = 0; t_b = .5
muestras = 201

# PROCEDIMIENTO
# Respuesta entrada cero ZIR
sol_ZIR = fcnm.respuesta_ZIR(ecuacion,cond_inicio,t0)
ZIR = sol_ZIR['ZIR']

# Respuesta al impulso h(t)
sol_h = fcnm.respuesta_impulso_h(ecuacion)
h = sol_h['h']

# respuesta a estado cero ZSR
sol_ZSR = fcnm.respuesta_ZSR(x,h)
ZSR = sol_ZSR['ZSR']
xh  = sol_ZSR['xh']

# respuesta a y(t) = ZIR(t)+ZSR(t)
y_total = ZIR+ZSR

# revisa si grafica ZSR
if not(sol_ZSR['cond_graf']):
    print('revisar acortar x(t) o h(t) para BIBO')
    
# SALIDA
print('\n ZIR(t):')
sym.pprint(ZIR)

print('\n h(t):')
sym.pprint(h)

print('\n ZSR(t):')
fcnm.print_resultado_dict(sol_ZSR)
if sol_ZSR['hcausal']==False:
    print('revisar causalidad de h(t)')
if sol_ZSR['xcausal']==False:
    print('revisar causalidad de x(t)')
if sol_ZSR['intercambia']:
    print('considere intercambiar h(t)con x(t)')
if not(sol_ZSR['cond_graf']):
    print('revisar acortar x(t) o h(t) para BIBO')

print('\n y(t) = ZIR(t)+ZSR(t):')
sym.pprint(y_total)

# GRAFICA
figura_ZIR = fcnm.graficar_ft(ZIR,t_a,t_b,
                              muestras,'ZIR')
figura_h   = fcnm.graficar_ft(h,t_a,t_b,
                              muestras,'h')
# grafica animada de convolución
n_archivo = '' # sin crear archivo gif animado 
#n_archivo = '1Eva2016TII_T2_ZSR' # requiere 'imagemagick'
if sol_ZSR['cond_graf']:
    fig_ZSR = fcnm.graficar_xh_y(x,h,ZSR,t_a,t_b,
                                 muestras,y_nombre='ZSR')
    fig_ytotal = fcnm.graficar_xhy(ZIR,ZSR,y_total,t_a,t_b,
                                   muestras,x_nombre='ZIR',
                                   h_nombre='ZSR',y_nombre='y')
    figura_animada = fcnm.graf_animada_xh_y(x,h,ZSR,-t_b,t_b,
                      muestras, reprod_x = 4,y_nombre='ZSR',
                      archivo_nombre = n_archivo)
plt.show()

Ejercicio: 1Eva2016TII_T1 LTI CT Sistema en paralelo-serie

a. respuestas impulso de los subsistemas SS1, SS2 y SS3

realizadas a partir de las respuestas de paso, x(t) = μ(t), entrada escalón unitario:

s_1(t) = r(t+1) - r(t-1) s_2(t) = s_3(t) = r(t-1) - r(t-2)

---

h_1 (t) = \frac{\delta}{\delta t} s_1(t) h_1 (t) = \frac{\delta}{\delta t} [ r(t+1) - r(t-1)] = \frac{\delta}{\delta t}[(t+1)\mu (t+1) - (t-1)\mu (t-1)] = (1) \mu (t+1) +(t+1) \delta(t+1) -[ (1)\mu (t-1) + (t-1)\delta(t-1)] = \mu (t+1) +0 -[ (1)\mu (t-1) + 0] = \mu (t+1) - \mu (t-1)

---

h_2 (t) = \frac{\delta}{\delta t} s_2(t) h_2 (t) = \frac{\delta}{\delta t} [(t-1) \mu (t-1) - (t-2) \mu (t-2)

siguiendo el desarrollo para h₁(t)

h_2 (t) = \mu (t-1) - \mu (t-2)

por lo que también:

h_3 (t) = h_2 (t) =\mu (t-1) - \mu (t-2)

respuesta con el algoritmo:

 literal a: Respuestas de paso
s1:  -(t - 1)*Heaviside(t - 1) + (t + 1)*Heaviside(t + 1)
s2:  -(t - 2)*Heaviside(t - 2) + (t - 1)*Heaviside(t - 1)
s3:  -(t - 2)*Heaviside(t - 2) + (t - 1)*Heaviside(t - 1)
 literal a: Respuestas impulso
h1:  -(t - 1)*DiracDelta(t - 1) + (t + 1)*DiracDelta(t + 1)
     - Heaviside(t - 1) + Heaviside(t + 1)
h2:  -(t - 2)*DiracDelta(t - 2) + (t - 1)*DiracDelta(t - 1)
     - Heaviside(t - 2) + Heaviside(t - 1)
h3:  -(t - 2)*DiracDelta(t - 2) + (t - 1)*DiracDelta(t - 1)
     - Heaviside(t - 2) + Heaviside(t - 1)

Instrucciones en Python

# 1Eva2016TII_T1 Sistema LTIC en paralelo-serie
import numpy as np
import matplotlib.pyplot as plt
import sympy as sym
equivalentes = [{'DiracDelta': lambda x: 1*(x==0)},
                {'Heaviside': lambda x,y: np.heaviside(x, 1)},
                'numpy',]
# INGRESO
t = sym.Symbol('t', real=True)
u = sym.Heaviside(t) 
r = t*u

# literal a, repuesta de paso
s1 = r.subs(t,t+1) - r.subs(t,t-1)
s2 = r.subs(t,t-1) - r.subs(t,t-2)
s3 = r.subs(t,t-1) - r.subs(t,t-2)

t_a = -2 ; t_b = 3

# PROCEDIMIENTO
muestras = (t_b-t_a)*(20+1)
ti = np.linspace(t_a,t_b,muestras)
s1n = sym.lambdify(t,s1, modules=equivalentes)
s2n = sym.lambdify(t,s2, modules=equivalentes)
s1i = s1n(ti)
s2i = s2n(ti)

# literal a, respuesta impulso
h1 = sym.diff(s1,t,1)
h2 = sym.diff(s2,t,1)
h3 = sym.diff(s3,t,1)

h1n = sym.lambdify(t,h1, modules=equivalentes)
h2n = sym.lambdify(t,h2, modules=equivalentes)
h3n = sym.lambdify(t,h3, modules=equivalentes)
h1i = h1n(ti)
h2i = h2n(ti)
h3i = h3n(ti)

# SALIDA
print(' literal a: Respuestas de paso')
print('s1: ',s1)
print('s2: ',s2)
print('s3: ',s3)
print(' literal a: Respuestas impulso')
print('h1: ',h1)
print('h2: ',h2)
print('h3: ',h3)

# Gráfica
plt.subplot(211)
plt.plot(ti,s1i,label ='s1(t)')
plt.plot(ti,s2i,label ='s2(t), s3(t)')
plt.axvline(0, linestyle='dashed',color='grey')
plt.legend()
plt.grid()

plt.subplot(212)
plt.plot(ti,h1i,label ='h1(t)')
plt.plot(ti,h2i,label ='h2(t), h3(t)')
plt.axvline(0, linestyle='dashed',color='grey')
plt.ylabel('Respuesta impulso')
plt.xlabel('t')
plt.legend()
plt.grid()
plt.show()

---

b. respuestas impulso h₁₂(t) y respuesta de paso (escalón unitario) s₁₂(t)

los sistemas SS1 y SS2 se encuentran con un operador suma en paralelo ,restando SS2, por lo que las respuestas al impulso son:

h_{12} (t) = h_1 (t) - h_2 (t) = [\mu (t+1) - \mu (t-1)] - [\mu (t-1) - \mu (t-2)] = \mu (t+1) - 2 \mu (t-1) + \mu (t-2)

la «respuesta de paso» se encuentran como:

s_{12} (t) = \int_{-\infty}^{\infty} h_{12}(t) \delta t = h_{12} (t) \circledast \mu (t) s_{12} (t) = [\mu (t+1) - 2 \mu (t-1) - \mu (t-2)] \circledast \mu (t)

Usando la tabla de integrales de convolución, fila 3:

s_{12} (t) = r(t+1) -2 r(t-1) + r(t-2)

---

c. respuesta impulso del sistema global  h₁₂₃(t)

A partir de h₁₂(t) y h₃(t), que se encuentran en serie (cascada), se tiene que:

h_{123} (t) = h_{12} (t) \circledast h_3 (t) \frac{\delta}{\delta t}h_{123} (t) = \frac{\delta}{\delta t}[h_{12} (t) \circledast h_3 (t)] = \frac{\delta}{\delta t}h_{12} (t) \circledast h_3 (t) = h_{12} (t) \circledast \frac{\delta}{\delta t}h_3 (t)

usando la primera expresión equivalente de la convolución:

\frac{\delta}{\delta t}h_{12} (t) = \frac{\delta}{\delta t}[\mu (t+1) - 2 \mu (t-1) + \mu (t-2)] = \delta (t+1) - 2 \delta (t-1) + \delta (t-2)

por lo que

\frac{\delta}{\delta t}h_{123} (t) = [\delta (t+1) - 2 \delta (t-1) + \delta (t-2)] \circledast h_3 (t) = \delta (t+1) \circledast h_3 (t) - 2 \delta (t-1) \circledast h_3 (t) + \delta (t-2) \circledast h_3 (t)

Usando la tabla de integrales de convolución, fila 1:

= h_3 (t+1) - 2 h_3 (t-1) + h_3 (t-2)

y sustituyendo las expresiones con los deplazamientos en t,

= [\mu ((t+1)-1) - \mu ((t+1)-2)] -2[\mu ((t-1)-1) - \mu ((t-1)-2)] + [\mu ((t-2)-1) - \mu ((t-2)-2)]

realizado las operaciones en los paréntesis,

= \mu (t) - \mu (t-1) - 2\mu (t-2) + 2\mu (t-3) + \mu (t-3) - \mu (t-4)

uniendo términos iguales, se simplifica,

\frac{\delta}{\delta t} h_{123} (t) = \mu (t) - \mu (t-1)- 2\mu (t-2) + 3\mu (t-3) - \mu (t-4)

ahora se puede calcular h₁₂₃(t) como

h_{123} (t) =\frac{\delta}{\delta t} h_{123} (t) \circledast \mu (t) = [\mu (t) - \mu (t-1)- 2\mu (t-2) + 3\mu (t-3) - \mu (t-4)] \circledast \mu (t) = \mu (t)\circledast \mu (t) - \mu (t-1)\circledast \mu (t) -2\mu (t-2)\circledast \mu (t)+ + 3\mu (t-3)\circledast \mu (t) - \mu (t-4) \circledast \mu (t)

Usando la tabla de integral de convolución, fila 3:

h_{123} (t) = r(t) - r(t-1) -2 r(t-2)+ 3 r(t-3) - r(t-4)

también se puede escribir en función de μ(t)

h_{123} (t) = t \mu(t) - (t-1) \mu (t-1) -2 (t-2) \mu(t-2)+ +3 (t-3) \mu(t-3) - (t-4)\mu(t-4)

Con lo que se que se obtiene la gráfica de las funciones requeridas en el literal b.

el resultado del algoritmo es:

literal b. h123(t)
h12:  (t - 2)*DiracDelta(t - 2) - 2*(t - 1)*DiracDelta(t - 1)
    + (t + 1)*DiracDelta(t + 1) + Heaviside(t - 2)
    - 2*Heaviside(t - 1) + Heaviside(t + 1)
h123:  t*Heaviside(t) - (t - 4)*Heaviside(t - 4) 
     + 3*(t - 3)*Heaviside(t - 3) -2*(t - 2)*Heaviside(t - 2)
     - (t - 1)*Heaviside(t - 1)

las instrucciones adicionales en Python son:

t_a = -2 ; t_b = 5
# PROCEDIMIENTO
muestras = (t_b-t_a)*(20+1)
ti = np.linspace(t_a,t_b,muestras)

# b. respuesta impulso y paso del sistema 12 en paralelo
h12  = h1 - h2
h12n = sym.lambdify(t,h12, modules=equivalentes)
h12i = h12n(ti)

# respuesta impulso global sistema 123
h123  = r-r.subs(t,t-1)-2*r.subs(t,t-2)
h123  = h123 + 3*r.subs(t,t-3)-r.subs(t,t-4)
h123n = sym.lambdify(t,h123, modules=equivalentes)
h123i = h123n(ti)

# SALIDA
print('\nliteral b. h123(t)')
print('h12: ', h12)
print('h123: ',h123)

# Grafica
plt.plot(ti,h12i,label ='h12(t)')
plt.axvline(0, linestyle='dashed'
            ,color='grey')
plt.plot(ti,h123i,label ='h123(t)')
plt.ylabel('Respuesta impulso')
plt.xlabel('t')
plt.legend()
plt.grid()

plt.show()

---

litera b. Tabla de respuestas

Subsistema LTIC SS1

• h₁(t) no tiene la forma kδ(T), por lo que SSI es con memoria.
• h₁(t) ≠ 0, t<0, el sistema no es causal.
• La respuesta al impulso es absolutamente integrable, por lo que es BIBO estable

Subsistema LTIC SS2 y SS3

• h₂(t) y h₂(t) no tienen la forma kδ(T), por lo que SS2 y SS3 tienen memoria.
• h₂(t) = h₃(t) = 0, t<0, los sistemas SS2 y SS3 son causales.
• La respuesta al impulso es absolutamente integrable, por lo que SS2 y SS3 son BIBO estables

Subsistema LTIC en paralelo SS1-SS2

• h₁₂(t) no tiene la forma kδ(T), por lo que SS1-SS2 en paralelo es con memoria.
• h₁₂(t) ≠ 0 t<0, el sistema en paralelo SS1-SS2 no es causal.
• La respuesta al impulso es absolutamente integrable, por lo que el sistema en paralelo SS1-SS2 es BIBO estable

Subsistema LTIC global SS1-SS2-SS3

• h₁₂₃(t) no tiene la forma kδ(T), por lo que el sistema global es con memoria.
• h₁₂(t) = 0 t<0, el sistema global es causal.
• La respuesta al impulso es absolutamente integrable, por lo que el sistema global es BIBO estable
  

  ---

  literal d. salida w(t)

La combinación en paralelo del sistema SS1 y SS2 a partir de la entrada x(t) dada es:

w(t) = x(t) \circledast h_{12} (t) = h_{12} (t) \circledast x(t) w(t) = h_{12} (t) \circledast \sum_{k=-\infty}^{\infty} \delta (t-4k) = \sum_{k=-\infty}^{\infty} [h_{12} (t) \circledast\delta (t-4k)] = \sum_{k=-\infty}^{\infty} h_{12} (t-4k)

que es una función periódica con T_k = 4.

Por ser una señal periódica, la potencia y energía se determinan en un periodo:

E_{w(t)} = \int_{-1}^{3} |w(t)|^2 \delta t = \int_{-1}^{1} |1|^2 \delta t + \int_{1}^{2} |-1|^2 \delta t + \int_{2}^{3} |0|^2 \delta t = \int_{-1}^{1} (1) \delta t + \int_{1}^{2} (1) \delta t = t \bigg|_{-1}^{1} + t \bigg|_{1}^{2} =2+1 =3 E_{w(t)} = 3 P_{w(t)} = \frac{E_{w(t)}}{T_0} = \frac{3}{4}

---

literal e. salida y(t) sistema global

y(t) = x(t) \circledast h_{123} (t) = h_{123} (t) \circledast x(t) = h_{123} (t) \circledast \sum_{k=-\infty}^{\infty} \delta (t-4k) = \sum_{k=-\infty}^{\infty} [h_{123} (t) \circledast \delta (t-4k)] y(t) = \sum_{k=-\infty}^{\infty} h_{123}(t-4k)

siendo una respuesta de tipo periódica con T₀ = 4, por lo que la potencia y energía se determinan en un periodo,

E_{y(t)} = \int_{0}^{4} |y(t)|^2 \delta t = \int_{0}^{1} |t|^2 \delta t + \int_{1}^{2} |1|^2 \delta t +\int_{2}^{3} |5-2t|^2 \delta t + \int_{3}^{4} |t-4|^2 \delta t = \frac{t^3}{3} \Big|_0^1 + t\Big|_1^2 + \int_{2}^{3}(25-20t+4t^2) \delta t+ \int_{3}^{4} |t^2-8t+16| \delta t = (0+\frac{1}{3}) + (2-1) + [25t-10t^2+\frac{4}{3}t^3] \Big|_2^3 + [\frac{t^3}{3}-4[t^2]+16t] \Big|_3^4 = \frac{1}{3} + 1 + \Big[\big(25(3)-10(3)^2+\frac{4}{3}(3)^3\big) -\big(25(2)-10(2)^2+\frac{4}{3}(2)^3\big)\Big] + + \Big[\big(\frac{4^3}{3}-4[4^2]+16(4)\big) - \big(\frac{3^3}{3}-4[3^2]+16(3) \big)\Big] = \frac{4}{3} + \Big[\big(75-90+36\big) -\big(50-40+\frac{32}{3}\big)\Big] + + \Big[\big(\frac{64}{3}-64 +64\big) - \big(9-36+48 \big)\Big] = \frac{4}{3} + \frac{2}{3} = \frac{6}{3} = 2 E_{y(t)} = 2 P_{y(t)} =\frac{E_{y(t)}}{T_0} = \frac{2}{4} = \frac{1}{2}

Referencia: 1Eva2010TII_T3 LTI CT H(s) de bloques en paralelo y retraso

El diagrama de bloques del sistema consta de dos sistema de primer orden en paralelo y el resultado en serie con un bloque retraso en tiempo.

La ecuación de respuesta a impulso H(s), siguiendo el diagrama se presenta como:

H(s) =\Big[ \frac{1}{s+2}+\frac{1}{s+3} \Big] e^{-2s}

literal a

Para el desarrollo analítico se simplifica el problema, separando el bloque de atraso para el final, dado que el sistema es LTI los desplazamietos en el tiempo de la entrada tendrán semejante respuesta en la salida.

La función de transferencia H(s) o respuesta al impulso será:

H(s) =\Big[ H_1(s)\Big] e^{-2s} H_1(s) = \frac{1}{s+2}+\frac{1}{s+3}

Los componentes por ser de primer orden y estar en paralelo, no se requiere aplicar fracciones parciales.

Los polos del sistema se encuentran en el lado izquierdo del plano, por lo que sus componentes en el tiempo son decrecientes.

{polos,veces}:  {-2: 1, -3: 1}
 polos reales:  2  complejos:  0
 sobre lado derecho RHP: 0
 sobre Eje Imaginario, repetidos:  0  unicos: 0
 asintoticamente:  estable

NO existen polos en el lado derecho del plano, por lo que el sistema es asintoticamente estable, en consecuencia BIBO estable.

literal b

Para la transformada inversa de Laplace, se recuerda que se tiene un componente de retraso en cascada, por lo que se ajusta H(s)*retraso en fracciones parciales, se presentan dos componentes:

 h(t) :
 4 - 2*t                     6 - 3*t                 
e       *Heaviside(t - 2) + e       *Heaviside(t - 2)

que tienen la forma decreciente de la función, Para la gráfica sympy usa como θ(t)=μ(t)=Heaviside(t)

literal c

A partir del diagrama de bloques se tiene:

H(s) =\frac{Y(s)}{X(s)}= \Big[ \frac{2s+5}{s^2+5s+6} \Big] e^{-2s} (s^2+5s+6)Y(s)=(2s+5)e^{-2s} X(s) s^2Y(s)+5sY(s)+6Y(s)=(2sX(s)+5X(s))e^{-2s}

que al convertir al dominio del tiempo se escribe como:

\frac{\delta^2}{\delta t^2}y(t)+5\frac{\delta}{\delta t}y(t)+6y(t)=2\frac{\delta}{\delta t}x(t-2)+5x(t-2)

literal d

la respuesta ante la entrada escalon requiere que x(t) = μ(t), no se especifican condiciones iniciales del problema, por lo que se asumen iguales a cero. De la tabla de transformadas se obtiene X(s) = 1/s

H(s) =\Big[ \frac{1}{s+2}+\frac{1}{s+3} \Big] e^{-2s} Y(s) = H(s)X(s) =\Big[ \frac{1}{s+2}+\frac{1}{s+3} \Big] e^{-2s} \frac{1}{s}

que separando en fracciones parciales se convierte en:

Y(s) =\Big[\frac{5/6}{s} -\frac{1/3}{s+3}-\frac{1/2}{s+2} \Big] e^{-2s} y(t) =\Big[\frac{5}{6} -\frac{1}{3}e^{-3(t-2)}-\frac{1}{2}e^{-2(t-2)}\Big] \mu (t-2)

el resultado usando algoritmos es:

 H(s) = P(s)/Q(s):
/  1       1  \  -2*s
|----- + -----|*e    
\s + 3   s + 2/      
 H(s) en factores:
           -2*s
(2*s + 5)*e    
---------------
(s + 2)*(s + 3)

 h(t) :
/ 4  -2*t    6  -3*t\                 
\e *e     + e *e    /*Heaviside(t - 2)

polosceros:
exp(-2*s) : {'Q_polos': {-2: 1, -3: 1}, 'P_ceros': {-5/2: 1}, 'Hs_k': (2*s + 5)/((s + 2)*(s + 3))}
Q_polos : {-2: 1, -3: 1}
P_ceros : {-5/2: 1}

Estabilidad de H(s):
 n_polos_real : 2
 n_polos_imag : 0
 enRHP : 0
 unicos : 0
 repetidos : 0
 asintota : estable

 X(s): 
1
-
s

Respuesta entrada cero ZIR H(s) y condiciones iniciales
term_cero : 0
ZIR :
0
yt_ZIR :
0

 ZSR respuesta estado cero:
ZSR :
/      1           1        5 \  -2*s
|- --------- - --------- + ---|*e    
\  3*(s + 3)   2*(s + 2)   6*s/      
yt_ZSR :
/     4  -2*t    6  -3*t\                 
|5   e *e       e *e    |                 
|- - -------- - --------|*Heaviside(t - 2)
\6      2          3    /                 

 Y(s)_total = ZIR + ZSR:
/      1           1        5 \  -2*s
|- --------- - --------- + ---|*e    
\  3*(s + 3)   2*(s + 2)   6*s/      

 y(t)_total = ZIR + ZSR:
/     4  -2*t    6  -3*t\                 
|5   e *e       e *e    |                 
|- - -------- - --------|*Heaviside(t - 2)
\6      2          3    /                 
>>>

Instrucciones en Python

Usando los bloques desarrollados en la Unidad 4 Sistemas LTI – Laplace  y las funciones resumidas como telg1001.py que pueden ser usados en cada pregunta.

# Y(s) Respuesta total con entada cero y estado cero
# Qs Y(s) = Ps X(s) ; H(s)=Ps/Qs
# http://blog.espol.edu.ec/telg1001/
import sympy as sym
import matplotlib.pyplot as plt
import telg1001 as fcnm

# INGRESO
s = sym.Symbol('s')
t = sym.Symbol('t', real=True)
d = sym.DiracDelta(t)
u = sym.Heaviside(t)

# H(s) y estabilidad
Hs = (1/(s+2)+1/(s+3))*sym.exp(-2*s)
#Hs = 1+0*s cuando es constante

# X(s) Señal de entrada
xt = u

# condiciones iniciales, [y'(0),y(0)] orden descendente
t0 = 0
cond_inicio = [0, 0] # estado cero no se usan

# Grafica, intervalo tiempo [t_a,t_b]
t_a = -1 ; t_b = 5
muestras = 101  # 51 resolucion grafica

# PROCEDIMIENTO
Hs = fcnm.apart_s(Hs) # fracciones parciales
Hs_fc = fcnm.factor_exp(Hs) # en factores
Hs_Qs2 = fcnm.Q_cuad_s_parametros(Hs_fc)

polosceros = fcnm.busca_polosceros(Hs)
Q_polos = polosceros['Q_polos']
P_ceros = polosceros['P_ceros']

estable = fcnm.estabilidad_asintotica_s(Q_polos)

# H(t) respuesta al impulso
ht = 0*s
term_suma = sym.Add.make_args(Hs)
for term_k in term_suma:
    ht_k = sym.inverse_laplace_transform(term_k,s,t)
    # simplifica log(exp()) ej: e**(-2s)/(s**2)
    if ht_k.has(sym.log):
        ht_k = sym.simplify(ht_k,inverse=True)
    ht  = ht + ht_k
lista_escalon = ht.atoms(sym.Heaviside)
ht = sym.expand(ht,t) # terminos suma
ht = sym.collect(ht,lista_escalon)

# PROCEDIMIENTO Respuesta ZIR, ZSR
Xs = fcnm.laplace_transform_suma(xt)

# ZIR_s respuesta entrada cero de s
sol_ZIR = fcnm.respuesta_ZIR_s(Hs,cond_inicio)
ZIR = sol_ZIR['ZIR']
yt_ZIR = sol_ZIR['yt_ZIR']

# ZSR respuesta estado cero, Y(s) a entrada X(s)
sol_ZSR = fcnm.respuesta_ZSR_s(Hs,Xs)
ZSR = sol_ZSR['ZSR']
yt_ZSR = sol_ZSR['yt_ZSR']

# Respuesta total Y(s) y y(t)
Ys = ZIR + ZSR
Ys = fcnm.apart_s(Ys)
yt = yt_ZIR + yt_ZSR
lista_escalon = yt.atoms(sym.Heaviside)
yt = sym.collect(yt,lista_escalon)

# SALIDA
print(' H(s) = P(s)/Q(s):')
sym.pprint(Hs)
print(' H(s) en factores:')
sym.pprint(Hs_fc)
if len(Hs_Qs2)>0:
    print('\nH(s) parámetros cuadraticos:')
    fcnm.print_resultado_dict(Hs_Qs2)

print('\n h(t) :')
sym.pprint(ht)

print('\npolosceros:')
fcnm.print_resultado_dict(polosceros)

print('\nEstabilidad de H(s):')
for k in estable:
    print('',k,':',estable[k])

print('\n X(s): ')
sym.pprint(Xs)
print('\nRespuesta entrada cero ZIR H(s) y condiciones iniciales')

if not(sol_ZIR == sym.nan): # existe resultado
    fcnm.print_resultado_dict(sol_ZIR)
else:
    print(' insuficientes condiciones iniciales')
    print(' revisar los valores de cond_inicio[]')

print('\n ZSR respuesta estado cero:')
fcnm.print_resultado_dict(sol_ZSR)

print('\n Y(s)_total = ZIR + ZSR:')
sym.pprint(Ys)
print('\n y(t)_total = ZIR + ZSR:')
sym.pprint(yt)

# Graficas polos, H(s), con polos h(t) --------
muestras_H = 201
figura_s  = fcnm.graficar_Fs(Hs_fc,Q_polos,P_ceros,f_nombre='H',solopolos=True)
figura_Hs = fcnm.graficar_Fs(Hs_fc,Q_polos,P_ceros,muestras=muestras_H,f_nombre='H')
figura_ht = fcnm.graficar_ft(ht,t_a,t_b,muestras,f_nombre='h')
# GRAFICAS y(t),x(t),h(t) ---------------------
figura_ft = fcnm.graficar_xh_y(xt,ht,yt,t_a,t_b,muestras)
plt.show()

Referencia: 1Eva2009TII_T5 LTI DT bloques H[z] en serie

1. Las respuestas impulso de cada subsistema

H_1[z] = \frac{z}{z-(0.7)} = \frac{z}{z-0.7}

usando la tabla de transformadas z

h_1[n] = (0.7)^n \mu[n]

Continuando con el subsistema de la derecha

H_2[z] = \frac{z}{z-(-0.5)} = \frac{z}{z+0.5} h_2[n] = (-0.5)^n \mu[n]

El sistema total:

H[z] = H_1[z] H_2[z] = \frac{z}{(z-0.7)} \frac{z}{(z+0.5)} = \frac{z^2}{(z-0.7)(z+0.5)}

fracciones parciales modificadas, multiplica ambos lados por 1/z

\frac{H[z]}{z} = \Big( \frac{1}{z} \Big) \frac{z^2}{(z-0.7)(z+0.5)}= \frac{z}{(z-0.7)(z+0.5)} \frac{H[z]}{z} = \frac{z}{(z-0.7)(z+0.5)} = \frac{k_1}{z-0.7} +\frac{k_2}{z+0.5} k_1 = \frac{z}{\cancel{(z-0.7)}(z+0.5)} \Big|_{z=0.7} = \frac{0.7}{(0.7+0.5)} = 0.5833 k_2 = \frac{z}{(z-0.7)\cancel{(z+0.5)}} \Big|_{z=-0.5} = \frac{-0.5}{(-0.5-0.7)} = 0.4166 \frac{H[z]}{z} = \frac{0.5833}{z-0.7} +\frac{0.4166}{z+0.5}

Restaura fracciones parciales, multiplica ambos lados por z

H[z] = \frac{0.5833 z}{z-0.7} +\frac{0.4166z}{z+0.5}

usando la tabla de transformadas z

h[n] = 0.5833 \Big(0.7 \Big)^n \mu[n] +0.4166 \Big(-0.5\Big)^n \mu[n]

factor común μ[n]

h[n] = \Bigg( 0.5833 \Big(0.7 \Big)^n +0.4166 \Big(-0.5\Big)^n \Bigg) \mu[n]

Revisando el resultado con el algoritmo en Python

 Hz:
          2        
         z         
-------------------
(z - 0.7)*(z + 0.5)

 Hz/z:
          z          
---------------------
     2               
1.0*z  - 0.2*z - 0.35

 Hz/z.apart:
0.416666666666667   0.583333333333333
----------------- + -----------------
   1.0*z + 0.5         1.0*z - 0.7   

 Hz = (Hz/z)*z
0.416666666666667*z   0.583333333333333*z
------------------- + -------------------
    1.0*z + 0.5           1.0*z - 0.7    
 
polos:     {-0.500000000000000: 1, 0.700000000000000: 1}

 polos Re:  [-1/2, 7/10]

Tarea: 2. Su respuesta y[n]=s]n], expresada a la mínima expresión frente a la siguiente excitación x[n]=μ[n], esquematícela.

Instrucciones en Python

Algoritmos desarrollados en X[z] Fracciones parciales modificadas con Python

y la parte gráfica de Transformada z con Sympy-Python

# Transformada z- Fracciones parciales
# Polos únicos, repetidos y complejos
# Lathi Ejercicio 5.3c pd495
# blog.espol.edu.ec/telg1001
import sympy as sym
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
z = sym.Symbol('z')

Pz = z**2
Qz = (z-0.7)*(z+0.5)

# PROCEDIMIENTO
P = Pz.as_poly(z)
Q = Qz.as_poly(z)
Xz = Pz/Qz

# Raices Denominador
Q_raiz = sym.roots(Q)
Q_raizRe = sym.real_roots(Q)
rcompleja = len(Q_raiz)-len(Q_raizRe)

# Raices reales, únicas y repetidas
if (rcompleja<=0 and len(Q_raizRe)>0):
    # fracciones parciales modificadas
    Xzz = (P/Q)/z
    Xzm = Xzz.apart()
    # fracciones parciales restaurada
    terminos = Xzm.args
    Xzp = 0*z
    for untermino in terminos:
        Xzp = Xzp + untermino*z

def parametro_cuadratico(untermino):
    unparametro ={}
    # revisa denominador cuadratico
    [numerador,denominador] = (untermino).as_numer_denom()
    gradoD = 0
    coeficientesD = denominador
    gradoN = 0
    coeficientesN = numerador
    if not(denominador.is_constant()):
        denominador = denominador.as_poly()
        gradoD = denominador.degree()
        coeficientesD = denominador.coeffs()
    if not(numerador.is_constant()):
        numerador = numerador.as_poly()
        gradoN = numerador.degree()
        coeficientesN = numerador.coeffs()
    if gradoD == 2 and gradoN==2:
        a = float(coeficientesD[1])/2
        gamma2 = float(coeficientesD[2])
        gamma = np.sqrt(gamma2)
        A = float(coeficientesN[0])
        B = float(coeficientesN[1])
        rN = (A**2)*gamma2 + B**2 - 2*A*a*B
        rD = gamma2 - a**2
        r = np.sqrt(rN/rD)
        beta = np.arccos(-a/gamma)
        thetaN = A*a-B
        thetaD = A*np.sqrt(gamma2-a**2)
        theta = np.arctan(thetaN/thetaD)
        unparametro = {'r':r,
                       'gamma':gamma,
                       'beta':beta,
                       'theta':theta}
    return (unparametro)

# Terminos cuadraticos
parametros = [] # denominador cuadratico
if (rcompleja>0 and len(Q_raizRe)>0):
    # fracciones parciales modificadas
    Xzz = (P/Q)/z
    Xzm = Xzz.apart()
    # fracciones parciales restaurada
    terminos = Xzm.args
    Xzp = 0*z
    for untermino in terminos:
        Xzp = Xzp + untermino*z
        unparam = parametro_cuadratico(untermino*z)
        if len(unparam)>0:
            parametros.append(unparam)
if (rcompleja>0 and len(Q_raizRe)==0):
    Xzp = P/Q
    parametros.append(parametro_cuadratico(P/Q))

# SALIDA
print('\n Hz:')
sym.pprint(Xz)
if (len(Q_raizRe)>0):
    print('\n Hz/z:')
    sym.pprint(Xzz)
    print('\n Hz/z.apart:')
    sym.pprint(Xzm)
    print('\n Hz = (Hz/z)*z')
    sym.pprint(Xzp)
    print('\n polos:    ', Q_raiz)
print('\n polos Re: ', Q_raizRe)
if len(parametros)>0:
    for unparam in parametros:
        print('parametros cuadraticos: ')
        for cadauno in unparam.keys():
            print(cadauno,'\t',unparam[cadauno])


# grafica plano z imaginario
figura, grafROC = plt.subplots()
# limite
radio1 = plt.Circle((0,0),1,color='lightgreen',
                    fill=True)
radio2 = plt.Circle((0,0),1,linestyle='dashed',
                    color='lightgreen',fill=False)
grafROC.add_patch(radio1)
for raiz in Q_raiz.keys():
    [r_real,r_imag] = raiz.as_real_imag()
    radio_raiz = np.abs(raiz)
    nROC = plt.Circle((0,0),radio_raiz,
                      color='red',fill=True)
    grafROC.add_patch(nROC)
grafROC.add_patch(radio2) # borde r=1
grafROC.axis('equal')
# marcas de r=1 y valor a
for raiz in Q_raiz.keys():
    [r_real,r_imag] = raiz.as_real_imag()
    grafROC.plot(r_real,r_imag,'o',color='orange',
             label ='polo:'+str(float(raiz))+';'+str(Q_raiz[raiz]))
grafROC.plot(1,0,'o',color='green',
         label ='radio:'+str(1))

plt.axhline(0,color='grey')
plt.axvline(0,color='grey')
plt.grid()
plt.legend()
plt.xlabel('Re[z]')
plt.ylabel('Imag[z]')
untitulo = 'ROC H[z]='+str(Xz)
plt.title(untitulo)

# h[n] usando tabla de transformadas
m = 10
n = sym.Symbol('n')
hn = 0.5833*((0.7)**n)*sym.Heaviside(n)+0.4166*((-0.5)**n)*sym.Heaviside(n)
fn = sym.lambdify(n,hn)
ki = np.arange(0,m,1)
xnk = fn(ki)

# grafica h[n]
figura, grafxn = plt.subplots()
plt.stem(ki,xnk)
plt.xlabel('ki')
plt.ylabel('h[n]')
plt.title('h[n]= '+str(hn))
plt.show()

Ejercicio: 1Eva2009TII_T3 LTI CT y(t) desde h(t) y x(t) con términos escalón desplazados

La función de transferencia h(t) y la señal de entrada x(t) son,

x(t) = 2 μ(t-1) – 2 μ(t-3)

h(t) = μ(t+1) – 2 μ(t-1) + μ(t-3)

La primera observación es que h(t) h(t) tiene un componente No causal, que se adelanta en tiempo μ(t+1) a x(t). La transformada unilateral de Laplace no aplica para este término, por lo que para el algoritmo se usa la entrada X(s) y se evita el error en la transformada. Por lo demás el algoritmo funciona bien.
Tarea: Revisar y justificar

Usando la función de transferencia h(t) con las transformadas de Laplace H(s)

H(s) = \frac{1}{s}e^{s} - 2\frac{1}{s}e^{-s}+ \frac{1}{s} e^{-3s}

simplificando la expresión como F(s)*(terminos exponenciales)

H(s) = \frac{1}{s} \Big[ e^{s} - 2e^{-s}+ e^{-3s} \Big]

tiene la forma gráfica,

La señal de entrada usando las transformadas de Laplace X(s)

X(s) = 2\frac{1}{s}e^{-s} - 2\frac{1}{s}e^{-3s} X(s) = \frac{2}{s} \Big[e^{-s} - e^{-3s} \Big]

La señal de salida Y(s)=H(s)*X(s)

Y(s) = \frac{2}{s^2} \Big[ e^{s} - 2e^{-s}+ e^{-3s} \Big] \Big[e^{-s} - e^{-3s} \Big]

multiplicando los términos de exponenciales

Y(s) = \frac{2}{s^2} \Big[ e^{s}e^{-s} - 2e^{-s}e^{-s}+ e^{-3s}e^{-s} - e^{s}e^{-3s} + 2e^{-s}e^{-3s} - e^{-3s}e^{-3s} \Big] Y(s) = \frac{2}{s^2} \Big[ 1 - 2e^{-2s}+ e^{-4s}- e^{-2s} + 2e^{-4s} - e^{-6s} \Big] Y(s) = \frac{2}{s^2} \Big[ 1 - 3e^{-2s}+ 3e^{-4s} - e^{-6s} \Big]

usando la tabla de transformadas de Laplace en forma inversa:

y(t) = 2 (t) \mu (t) -6 (t-2) \mu (t-2) +6(t-4) \mu (t-4) -2(t-6) \mu(t-6) \Big]

La respuesta al impulso H(s)no tiene polos en el lado derecho del plano s, por lo que las salidas son acotadas, en consecuencia el sistema es asintoticamente estable y también BiBO estable.

---

usando el algoritmo, considerando que las condiciones iniciales son cero,:

 H(s) = P(s)/Q(s):
 s      -s    -3*s
e    2*e     e    
-- - ----- + -----
s      s       s  
 H(s) en factores:
 s      -s    -3*s
e    2*e     e    
-- - ----- + -----
s      s       s  

 h(t) :
Heaviside(t - 3) - 2*Heaviside(t - 1) + Heaviside(t + 1)

polosceros:
exp(s) : {'Q_polos': {0: 1}, 'P_ceros': {}, 'Hs_k': 1/s}
exp(-3*s) : {'Q_polos': {0: 1}, 'P_ceros': {}, 'Hs_k': 1/s}
exp(-s) : {'Q_polos': {0: 1}, 'P_ceros': {}, 'Hs_k': -2/s}
Q_polos : {0: 1}
P_ceros : {}

Estabilidad de H(s):
 n_polos_real : 0
 n_polos_imag : 1
 enRHP : 0
 unicos : 0
 repetidos : 0
 asintota : estable

 X(s): 
   -s      -3*s
2*e     2*e    
----- - -------
  s        s   

Respuesta entrada cero ZIR H(s) y condiciones iniciales
term_cero : 0
ZIR :
0
yt_ZIR :
0

 ZSR respuesta estado cero:
ZSR :
        -2*s      -4*s      -6*s
2    6*e       6*e       2*e    
-- - ------- + ------- - -------
 2       2         2         2  
s       s         s         s   
yt_ZSR :
2*t*Heaviside(t) + (12 - 6*t)*Heaviside(t - 2) + (12 - 2*t)*Heaviside(t - 6) +
 (6*t - 24)*Heaviside(t - 4)

 Y(s)_total = ZIR + ZSR:
        -2*s      -4*s      -6*s
2    6*e       6*e       2*e    
-- - ------- + ------- - -------
 2       2         2         2  
s       s         s         s   

 y(t)_total = ZIR + ZSR:
2*t*Heaviside(t) + (12 - 6*t)*Heaviside(t - 2) + (12 - 2*t)*Heaviside(t - 6) +
 (6*t - 24)*Heaviside(t - 4)
>>>

Usando los bloques desarrollados en la Unidad 4 Sistemas LTI – Laplace  y las funciones resumidas como telg1001.py que pueden ser usados en cada pregunta.

# Y(s) Respuesta total con entada cero y estado cero
# Qs Y(s) = Ps X(s) ; H(s)=Ps/Qs
# http://blog.espol.edu.ec/telg1001/
import sympy as sym
import matplotlib.pyplot as plt
import telg1001 as fcnm

# INGRESO
s = sym.Symbol('s')
t = sym.Symbol('t', real=True)
d = sym.DiracDelta(t)
u = sym.Heaviside(t)

# H(s) respuesta impulso
Hs = sym.exp(s)/s - 2*sym.exp(-s)/s + sym.exp(-3*s)/s

# X(s) Señal de entrada
xt = 2*u.subs(t,t-1) - 2*u.subs(t,t-3)

# condiciones iniciales, [y'(0),y(0)] orden descendente
t0 = 0
cond_inicio = [0] # estado cero no se usan

# Grafica, intervalo tiempo [t_a,t_b]
t_a = -2 ; t_b = 8
muestras = 101  # 51 resolucion grafica

# PROCEDIMIENTO
Hs = fcnm.apart_s(Hs) # fracciones parciales
Hs_fc = fcnm.factor_exp(Hs) # en factores
Hs_Qs2 = fcnm.Q_cuad_s_parametros(Hs_fc)

polosceros = fcnm.busca_polosceros(Hs)
Q_polos = polosceros['Q_polos']
P_ceros = polosceros['P_ceros']

estable = fcnm.estabilidad_asintotica_s(Q_polos)

# H(t) respuesta al impulso
ht = 0*s
term_suma = sym.Add.make_args(Hs)
for term_k in term_suma:
    ht_k = sym.inverse_laplace_transform(term_k,s,t)
    # simplifica log(exp()) ej: e**(-2s)/(s**2)
    if ht_k.has(sym.log):
        ht_k = sym.simplify(ht_k,inverse=True)
    ht  = ht + ht_k
lista_escalon = ht.atoms(sym.Heaviside)
ht = sym.expand(ht,t) # terminos suma
ht = sym.collect(ht,lista_escalon)

# PROCEDIMIENTO Respuesta ZIR, ZSR
Xs = fcnm.laplace_transform_suma(xt)

# ZIR_s respuesta entrada cero de s
sol_ZIR = fcnm.respuesta_ZIR_s(Hs,cond_inicio)
ZIR = sol_ZIR['ZIR']
yt_ZIR = sol_ZIR['yt_ZIR']

# ZSR respuesta estado cero, Y(s) a entrada X(s)
sol_ZSR = fcnm.respuesta_ZSR_s(Hs,Xs)
ZSR = sol_ZSR['ZSR']
yt_ZSR = sol_ZSR['yt_ZSR']

# Respuesta total Y(s) y y(t)
Ys = ZIR + ZSR
Ys = fcnm.apart_s(Ys)
yt = yt_ZIR + yt_ZSR
lista_escalon = yt.atoms(sym.Heaviside)
yt = sym.collect(yt,lista_escalon)

# SALIDA
print(' H(s) = P(s)/Q(s):')
sym.pprint(Hs)
print(' H(s) en factores:')
sym.pprint(Hs_fc)
if len(Hs_Qs2)>0:
    print('\nH(s) parámetros cuadraticos:')
    fcnm.print_resultado_dict(Hs_Qs2)

print('\n h(t) :')
sym.pprint(ht)

print('\npolosceros:')
fcnm.print_resultado_dict(polosceros)

print('\nEstabilidad de H(s):')
for k in estable:
    print('',k,':',estable[k])

print('\n X(s): ')
sym.pprint(Xs)
print('\nRespuesta entrada cero ZIR H(s) y condiciones iniciales')

if not(sol_ZIR == sym.nan): # existe resultado
    fcnm.print_resultado_dict(sol_ZIR)
else:
    print(' insuficientes condiciones iniciales')
    print(' revisar los valores de cond_inicio[]')

print('\n ZSR respuesta estado cero:')
fcnm.print_resultado_dict(sol_ZSR)

print('\n Y(s)_total = ZIR + ZSR:')
sym.pprint(Ys)
print('\n y(t)_total = ZIR + ZSR:')
sym.pprint(yt)

# Graficas polos, H(s), con polos h(t) --------
muestras_H = 101
figura_s  = fcnm.graficar_Fs(Hs_fc,Q_polos,P_ceros,f_nombre='H',solopolos=True)
figura_Hs = fcnm.graficar_Fs(Hs_fc,Q_polos,P_ceros,muestras=muestras_H,f_nombre='H')
figura_ht = fcnm.graficar_ft(ht,t_a,t_b,muestras,f_nombre='h')
# GRAFICAS y(t),x(t),h(t) ---------------------
figura_ft = fcnm.graficar_xh_y(xt,ht,yt,t_a,t_b,muestras)
plt.show()