Ejercicio: 2Eva2016TII_T4 resolver en dominio de frecuencia
Partiendo de,
se tiene también que:
A = 1/3
B = 3
Curso con Python – TELG1037/TELG1001 – FIEC – ESPOL
Ejercicio: 2Eva2016TII_T4 resolver en dominio de frecuencia
Partiendo de,
se tiene también que:
A = 1/3
B = 3
Ejercicio: 2Eva2016TII_T3 LTI DT sistemas en serie
usando transformada z:
S1:
S2:
sustituyendo la ecuacion de S1 para W(z)
SG:
comparando con la ecuación de S2
comprobar con
se confirma que α = 1/4 y β=1
la función de transferencia es:
usando las raices para:
y la parte derecha de la ecuación:
despejando para C1 y haciendo z=1/4,
despejando para C2 y haciendo z=1/2,
se H(z) se resume en,
Para obtener h[n] usando la antitransformada,
siendo la forma de la respuesta un impulso, es un sistema IIR.
Usando la expresión H(z) se obtiene:
Hz: 2 z ------------ 2 3*z 1 z - --- + - 4 8 Hz en fracciones parciales z 2*z - ------- + ------- z - 1/4 z - 1/2 Hz en factores 2 z -------------------- (z - 0.5)*(z - 0.25) {Q_polos:veces}: {1/2: 1, 1/4: 1} {P_ceros:veces}: {0: 2} estabilidad asintótica en z: circ1_dentro : 2 circ1_repetidos : 0 circ1_sobre : 0 circ1_fuera : 0 unicos : 2 repetidos : 0 asintota : estable h[n]: / n n\ \- 0.25 + 2*0.5 /*Heaviside(n) >>>
añadiendo instrucciones para graficar h[n] se obtiene
señal discreta h[n] n : [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] h[n]: [1. 0.75 0.4375 0.234375 0.12109375 0.06152344 0.03100586 0.01556396 0.00779724 0.00390244]
strong>Nota: cuando se produzca el siguiente error con Numpy para evaluar una expresión con exponente negativo,
Traceback (most recent call last): File "D:\MATG1052Ejemplos\Transformadaz\ejercicio....py", line 93, in fi = f_n(ki) File "", line 2, in _lambdifygenerated return (9/59)*4**(-n)*Heaviside(n, 1/2) ValueError: Integers to negative integer powers are not allowed.
proceda actualizando los valores a evaluar como tipo real (dtype float), tan solo usando en la línea de ki con lo siguiente:
ki = np.arange(0,muestras_fn,1.0)
quedando las instrucciones de la siguiente forma, que si evalua valores para realizar gráficas.
# Transformada z- Fracciones parciales # https://blog.espol.edu.ec/telg1001/lti-dt-transformada-z-xz-fracciones-parciales-con-python/ import numpy as np import sympy as sym import matplotlib.pyplot as plt import telg1001 as fcnm #sym.SYMPY_DEBUG=True # INGRESO z = sym.Symbol('z') n = sym.Symbol('n', real=True) # coeficientes como racional en dominio 'ZZ' enteros a0 = sym.Rational(3,4) a1 = sym.Rational(1,8) Pz = z**2 Qz = z**2-a0*z+a1 #Pz = z*z**2 #Qz = (z-1)*(z**2-(a0)*z+a1) F = Pz/Qz # para graficar f_nombre = 'H' # nombre de función[z]: H,X,Y, etc muestras_fn = 10 # muestras para f[n] # PROCEDIMIENTO Fz = fcnm.apart_z(F) Fz_factor = sym.factor(F.evalf()) Fz_factor = fcnm._round_float_is_int(Fz_factor) # polos y ceros de Hz [P,Q] = Fz.as_numer_denom() P = sym.poly(P,z) Q = sym.poly(Q,z) P_ceros = sym.roots(P) Q_polos = sym.roots(Q) estable_z = fcnm.estabilidad_asintotica_z(Q_polos) # Inversa de transformada z fn = 0*n ; Fz_revisar = [] ; Qz2_term =[] term_sum = sym.Add.make_args(Fz) for term_k in term_sum: term_kn = fcnm.inverse_z_transform(term_k,z,n) if type(term_kn)==tuple: fn = fn + term_kn[0] elif term_kn is not None: fn = fn + term_kn elif term_kn is None: f_noeval = f_noeval + term_k Qz2 = fcnm.Q_cuad_z_parametros(term_k) if Qz2: Qz2_term.append(Qz2) fn = fn.collect(sym.Heaviside(n)) fn = fn.collect(sym.DiracDelta(n)) fn = fcnm._round_float_is_int(fn) # SALIDA print('\n '+f_nombre+'z:') sym.pprint(F) print('\n '+f_nombre+'z en fracciones parciales') sym.pprint(Fz) print('\n '+f_nombre+'z en factores') sym.pprint(Fz_factor) print('\n {Q_polos:veces}:',Q_polos) print(' {P_ceros:veces}:',P_ceros) if len(Qz2_term)>0: print('\nparametros cuadraticos: ') for i in range(0,len(Qz2_term),1): for unterm in Qz2_term[i]: print(' termino:',unterm) fcnm.print_resultado_dict(Qz2_term[i][unterm]) print('\nestabilidad asintótica en z:') fcnm.print_resultado_dict(estable_z) print('\n '+f_nombre.lower()+'[n]:') sym.pprint(fn) if len(Fz_revisar)>0: print('revisar terminos sin transformada de tabla:') for un_term in Fz_revisar: print(un_term) # # GRAFICA ----------- fig_ROC = fcnm.graficar_Fz_polos(Fz_factor,Q_polos,P_ceros, muestras=101,f_nombre=f_nombre) fig_Fz = fcnm.graficar_Fs(Fz_factor,Q_polos,P_ceros, muestras=101, f_nombre=f_nombre) # graficar f[n] ------- f_n = sym.lambdify(n,fn.expand(),modules=fcnm.equivalentes) ki = np.arange(0,muestras_fn,1.0) fi = f_n(ki) print('\nseñal discreta '+f_nombre.lower()+'[n]') print('n :',ki) print(f_nombre.lower()+'[n]:',fi) # graficar f[n] fig_fn, grafxn = plt.subplots() plt.axvline(0,color='grey') plt.stem(ki,fi) plt.grid() plt.xlabel('n') plt.ylabel(f_nombre.lower()+'[n]') etiqueta = r''+f_nombre.lower()+'[n]= $'+str(sym.latex(fn))+'$' plt.title(etiqueta) plt.show()
revisando los polos y ceros:
ceros : z = 0 y z = 0 polos: z=1/4 y z=1/2
Dado que todos los polos se encuentran dentro del círculo de radio unitario , el sistema es asintóticamente estable, por lo que es BIBO o EASA estable
aplicando el mismo método anterior, se tiene:
# coeficientes como racional en dominio 'ZZ' enteros a0 = sym.Rational(3.4) a1 = sym.Rational(1,8) Pz = z*z**2 Qz = (z-1)*(z**2-(a0)*z+a1) F = Pz/Qz # para graficar f_nombre = 'S' # nombre de función[z]: H,X,Y, etc muestras_fn = 10 # muestras para f[n]
con resultado:
Sz: 3 z ---------------------- / 2 3*z 1\ (z - 1)*|z - --- + -| \ 4 8/ Sz en fracciones parciales z 2*z 8*z ----------- - ------- + --------- 3*(z - 1/4) z - 1/2 3*(z - 1) Sz en factores 3 z ---------------------------- (z - 1)*(z - 0.5)*(z - 0.25) {Q_polos:veces}: {1: 1, 1/2: 1, 1/4: 1} {P_ceros:veces}: {0: 3} s[n]: / n \ |0.25 n 8| |----- - 2*0.5 + -|*Heaviside(n) \ 3 3/
aplicando la transformada inversa
señal discreta s[n] n : [0 1 2 3 4 5 6 7 8 9] h[n]: [1. 1.75 2.1875 2.421875 2.54296875 2.60449219 2.63549805 2.65106201 2.65885925 2.66276169]
Ejercicio: 2Eva2016TII_T2 LTI CT Circuito RC respuesta de frecuencia H(ω), impulso h(t)
La respuesta impulso del filtro LPF, se obtiene mediante:
Método 1: usando la respuesta de frecuencia
método 2:
usando fasores:
En la salida, existe un factor de atenuación de 0.04 y un retardo de 87.70°.
Como la señal de entrada se reproduce de manera exacta en su salida a pesar tener amplitud diferente y un retardo en el tiempo.
Ejercicio: 2Eva2012TI_T3 LTI DT causal, coeficientes de respuesta impulso h[n]
La ecuación de diferencias descrita se usa para crear el diagrama de bloques.
La forma para usar transformadas z requiere que se desplazar tres unidades.
las raíces del denominador obtenidas con Sympy-Python:
>>> sym.roots(Pz) {1/2: 1, 0: 2} >>> sym.factor(Pz) z**2*(2*z - 1)/2 >>> sym.factor(Qz) (4*z - 1)*(9*z**2 - 9*z - 2)/36 >>> sym.roots(Qz) {1/4: 1, 1/2 - sqrt(17)/6: 1, 1/2 + sqrt(17)/6: 1} >>>
Observación: existe una raíz con distancia al origen superior al radio=1, por lo que habría un termino creciente no acotado.
que se observa también como:
El modelo se puede plantear como:
para usar fracciones parciales modificadas, se multiplica cada lado por 1/z:
Se puede plantear un modelo de respuesta por cada raíz como:
usando el método de Heaviside,
con lo que ahora en la expresión se convierte en:
Usando el método de los factores cuadráticos, se multiplica ambos lados por z y z→∞
se divide numerador y denominador del lado izquierdo para 1/z3 y el lado derecho el primer termino 1/z y el segundo termino 1/z2
y cuando z→∞
con lo que K2=50/59 , para encontrar K3 se usa un valor conveniente de z=0
y restaurando en fracciones parciales al multiplicar por z cada lado
los valores no se ajustan al modelo planteado en el enunciado, y existe un polo con radio>1, por lo que el sistema es creciente,y otro polo en posición r<0.
obtenga entonces los valores pertinentes.
a= 9/59 = 0.1525 | b= … creciente sin cota, con polo mayor a 1 | c=… con polo negativo, lo que es un término con signo alternado. |
α= 1/4 = 0.25 | β = 1/2 + np.sqrt(17)/6 = 1.1871842709362768 | γ = 1/2 – np.sqrt(17)/6 = -0.18718427093627676 |
Se encuentra que hay un término que no se puede usar para encontrar la transformada z.
Hz: 2 3 z z - -- 2 ------------------- 2 3 5*z z 1 z - ---- + -- + -- 4 36 18 Hz en fracciones parciales 50*z*(z - 4/25) 9*z --------------- + ------------ / 2 2\ 59*(z - 1/4) 59*|z - z - -| \ 9/ Hz en factores 2 z *(z - 0.5) --------------------------------------- / 2 \ (z - 0.25)*\z - z - 0.222222222222222/ {Q_polos:veces}: {1/4: 1, 1/2 - sqrt(17)/6: 1, 1/2 + sqrt(17)/6: 1} {P_ceros:veces}: {1/2: 1, 0: 2} parametros cuadraticos: termino: 50*z*(z - 4/25)/(59*(z**2 - z - 2/9)) r : 120.72788283210394 gamma : None beta : None theta : None estabilidad asintótica en z: circ1_dentro : 2 circ1_repetidos : 0 circ1_sobre : 0 circ1_fuera : 1 unicos : 3 repetidos : 0 asintota : inestable h[n]: -n 9*4 *Heaviside(n) ------------------ 59 revisar terminos sin transformada de tabla: 50*z*(z - 4/25)/(59*(z**2 - z - 2/9)) señal discreta h[n] n : [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] h[n]: [1.52542373e-01 3.81355932e-02 9.53389831e-03 2.38347458e-03 5.95868644e-04 1.48967161e-04 3.72417903e-05 9.31044756e-06 2.32761189e-06 5.81902973e-07]
Desarrollo con las expresiones iniciales, sin corrección sobre los parámetros que se indican en el enunciado.
Nota: cuando se produzca el siguiente error con Numpy para evaluar una expresión con exponente negativo,
Traceback (most recent call last): File "D:\MATG1052Ejemplos\Transformadaz\ejercicio03.py", line 93, in fi = f_n(ki) File "", line 2, in _lambdifygenerated return (9/59)*4**(-n)*Heaviside(n, 1/2) ValueError: Integers to negative integer powers are not allowed.
proceda actualizando los valores a evaluar como tipo real (dtype float), tan solo usando en la línea de ki con lo siguiente:
ki = np.arange(0,muestras_fn,1.0)
quedando las instrucciones de la siguiente forma, que si evalúa valores para realizar gráficas.
# Transformada z- Fracciones parciales # https://blog.espol.edu.ec/telg1001/lti-dt-transformada-z-xz-fracciones-parciales-con-python/ import numpy as np import sympy as sym import matplotlib.pyplot as plt import telg1001 as fcnm #sym.SYMPY_DEBUG=True # INGRESO z = sym.Symbol('z') n = sym.Symbol('n', real=True) # coeficientes como racional en dominio 'ZZ' enteros a0 = sym.Rational(1,2) a1 = sym.Rational(5,4) a2 = sym.Rational(1,36) a3 = sym.Rational(1,18) Pz = z**3-a0*z**2 Qz = z**3-a1*z**2+a2*z+a3 F = Pz/Qz # para graficar f_nombre = 'H' # nombre de función[z]: H,X,Y, etc muestras_fn = 10 # muestras para f[n] # PROCEDIMIENTO Fz = fcnm.apart_z(F) Fz_factor = sym.factor(F.evalf()) Fz_factor = fcnm._round_float_is_int(Fz_factor) # polos y ceros de Hz [P,Q] = F.as_numer_denom() P = sym.poly(P,z) Q = sym.poly(Q,z) P_ceros = sym.roots(P) Q_polos = sym.roots(Q) estable_z = fcnm.estabilidad_asintotica_z(Q_polos) # Inversa de transformada z fn = 0*n ; f_noeval = 0*n ; Qz2_term =[] term_sum = sym.Add.make_args(Fz) for term_k in term_sum: term_kn = fcnm.inverse_z_transform(term_k,z,n) if type(term_kn)==tuple: fn = fn + term_kn[0] elif term_kn is not None: fn = fn + term_kn elif term_kn is None: f_noeval = f_noeval + term_k Qz2 = fcnm.Q_cuad_z_parametros(term_k) if Qz2: Qz2_term.append(Qz2) fn = fn.collect(sym.Heaviside(n)) fn = fn.collect(sym.DiracDelta(n)) # SALIDA print('\n '+f_nombre+'z:') sym.pprint(F) print('\n '+f_nombre+'z en fracciones parciales') sym.pprint(Fz) print('\n '+f_nombre+'z en factores') sym.pprint(Fz_factor) print('\n {Q_polos:veces}:',Q_polos) print(' {P_ceros:veces}:',P_ceros) if len(Qz2_term)>0: print('\nparametros cuadraticos: ') for i in range(0,len(Qz2_term),1): for unterm in Qz2_term[i]: print(' termino:',unterm) fcnm.print_resultado_dict(Qz2_term[i][unterm]) print('\nestabilidad asintótica en z:') fcnm.print_resultado_dict(estable_z) print('\n '+f_nombre.lower()+'[n]:') sym.pprint(fn) if not f_noeval==sym.S.Zero: print('revisar terminos sin transformada de tabla:') print(f_noeval) # # GRAFICA ----------- fig_ROC = fcnm.graficar_Fz_polos(Fz_factor,Q_polos,P_ceros, muestras=101,f_nombre=f_nombre) fig_Fz = fcnm.graficar_Fs(Fz_factor,Q_polos,P_ceros, muestras=101, f_nombre=f_nombre) # graficar f[n] ------- f_n = sym.lambdify(n,fn.expand(),modules=fcnm.equivalentes) ki = np.arange(0,muestras_fn,1.0) fi = f_n(ki) print('\nseñal discreta '+f_nombre.lower()+'[n]') print('n :',ki) print(f_nombre.lower()+'[n]:',fi) # graficar f[n] fig_fn, grafxn = plt.subplots() plt.axvline(0,color='grey') plt.stem(ki,fi) plt.grid() plt.xlabel('n') plt.ylabel(f_nombre.lower()+'[n]') etiqueta = r''+f_nombre.lower()+'[n]= $'+str(sym.latex(fn))+'$' plt.title(etiqueta) plt.show()
Ejercicio: 2Eva2011TI_T2 LTI DT Determinar H[z] desde bloques
El diagrama de bloques del enunciado se reordena de la siguiente forma:
El nuevo diagrama muestra que el sistema tiene dos sub-componentes en paralelo.
como existen varios componentes, se pueden tratar de forma separada.
los polos y ceros de H1
{Q_polos:veces}: {2: 1, -1: 1} {P_ceros:veces}: {-14/11: 1}
usando fracciones parciales modificadas
usando el algoritmo se tiene:
restaurando a fracciones parciales, al multiplicar cada lado por z, se obtiene la función de transferencia H[z] completa como componentes en paralelo junto con H1
usando la tabla de transformadas z
Usando el algoritmo de la sección X[z] Fracciones parciales modificadas con Python para H1[z]
con entrada:
# coeficientes como racional en dominio 'ZZ' enteros
a0 = sym.Rational(11,2)
Pz = -(a0*z+7)
Qz = z**2-z-2
se obtiene:
Hz: 11*z - ---- - 7 2 ---------- 2 z - z - 2 Hz en fracciones parciales z 3*z 7 - --------- - ----- + - 2*(z + 1) z - 2 2 Hz en factores -3.5*(0.785714285714286*z + 1) ------------------------------- (0.5*z - 1)*(z + 1) {Q_polos:veces}: {2: 1, -1: 1} {P_ceros:veces}: {-14/11: 1} estabilidad asintótica en z: circ1_dentro : 0 circ1_repetidos : 0 circ1_sobre : 1 circ1_fuera : 1 unicos : 2 repetidos : 0 asintota : inestable h[n]: / n \ | (-1) n| 7*DiracDelta(n) |- ----- - 3*2 |*Heaviside(n) + --------------- \ 2 / 2 señal discreta h[n] n : [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] h[n]: [ 0. -5.5 -12.5 -23.5 -48.5 -95.5 -192.5 -383.5 -768.5 -1535.5]
resultado que se completan con los términos de los otros componentes, al incorporar la expresión con los elementos en paralelo como se desarrolla en el siguiente literal.
Instrucciones en Python
# Transformada z- Fracciones parciales # https://blog.espol.edu.ec/telg1001/lti-dt-transformada-z-xz-fracciones-parciales-con-python/ import numpy as np import sympy as sym import matplotlib.pyplot as plt import telg1001 as fcnm #sym.SYMPY_DEBUG=True # INGRESO z = sym.Symbol('z') n = sym.Symbol('n', real=True) # coeficientes como racional en dominio 'ZZ' enteros a0 = sym.Rational(11,2).limit_denominator(100) Pz = -(a0*z+7) Qz = z**2-z-2 F = Pz/Qz # para graficar f_nombre = 'H' # nombre de función[z]: H,X,Y, etc muestras_fn = 10 # muestras para f[n] # PROCEDIMIENTO Fz = fcnm.apart_z(F) Fz_factor = sym.factor(F.evalf()) # polos y ceros de Hz [P,Q] = F.as_numer_denom() P = sym.poly(P,z) Q = sym.poly(Q,z) P_ceros = sym.roots(P) Q_polos = sym.roots(Q) estable_z = fcnm.estabilidad_asintotica_z(Q_polos) # Inversa de transformada z fn = 0*n ; Fz_revisar = [] ; Qz2_term =[] term_sum = sym.Add.make_args(Fz) for term_k in term_sum: term_kn = fcnm.inverse_z_transform(term_k,z,n) if type(term_kn)==tuple: fn = fn + term_kn[0] elif term_kn is not None: fn = fn + term_kn elif term_kn is None: f_noeval = f_noeval + term_k Qz2 = fcnm.Q_cuad_z_parametros(term_k) if Qz2: Qz2_term.append(Qz2) fn = fn.collect(sym.Heaviside(n)) fn = fn.collect(sym.DiracDelta(n)) #fn = fcnm._round_float_is_int(fn) # SALIDA print('\n '+f_nombre+'z:') sym.pprint(F) print('\n '+f_nombre+'z en fracciones parciales') sym.pprint(Fz) print('\n '+f_nombre+'z en factores') sym.pprint(Fz_factor) print('\n {Q_polos:veces}:',Q_polos) print(' {P_ceros:veces}:',P_ceros) if len(Qz2_term)>0: print('\nparametros cuadraticos: ') for i in range(0,len(Qz2_term),1): for unterm in Qz2_term[i]: print(' termino:',unterm) fcnm.print_resultado_dict(Qz2_term[i][unterm]) print('\nestabilidad asintótica en z:') fcnm.print_resultado_dict(estable_z) print('\n '+f_nombre.lower()+'[n]:') sym.pprint(fn) if len(Fz_revisar)>0: print('revisar terminos sin transformada de tabla:') for un_term in Fz_revisar: print(un_term) # # GRAFICA ----------- fig_ROC = fcnm.graficar_Fz_polos(Fz_factor,Q_polos,P_ceros, muestras=101,f_nombre=f_nombre) fig_Fz = fcnm.graficar_Fs(Fz_factor,Q_polos,P_ceros, muestras=101, f_nombre=f_nombre) # graficar f[n] ------- f_n = sym.lambdify(n,fn.expand(),modules=fcnm.equivalentes) ki = np.arange(0,muestras_fn,1.0) fi = f_n(ki) print('\nseñal discreta '+f_nombre.lower()+'[n]') print('n :',ki) print(f_nombre.lower()+'[n]:',fi) # graficar f[n] fig_fn, grafxn = plt.subplots() plt.axvline(0,color='grey') plt.stem(ki,fi) plt.grid() plt.xlabel('n') plt.ylabel(f_nombre.lower()+'[n]') etiqueta = r''+f_nombre.lower()+'[n]= $'+str(sym.latex(fn))+'$' plt.title(etiqueta) plt.show()
Se realiza la conversión por la suma de cada componente (en paralelo):
Para y1[n]:
Para y2[n]:
Para y3[n]:
se suman las expresiones obtenidas de Y1[z] + Y2[z]+Y3[z]
la ecuación de diferencias simplificada es;
El sistema global se puede reescribir nuevamente en z como
se tiene que el sistema tienen polos en 0 y 1, que se encuentran dentro del radio 1 del plano z.
H[z] se obtiene a partir de la última ecuación
aplicando fracciones parciales modificadas:
restaurando fracciones parciales al multiplicar por z
usando la tabla de transformada z se tiene:
usando el algoritmo con entrada:
# coeficientes como racional en dominio 'ZZ' enteros a0 = sym.Rational(11,2) a1 = sym.Rational(9,2) a2 = sym.Rational(23,2) #F = -(a0*z+7)/(z**2-z-2) + z/2 -a1 F = -(5*z+a2)/(z*(z-1))
se tiene como resultado:
Hz: -5*z - 23/2 ----------- z*(z - 1) Hz en fracciones parciales 16.5*z 11.5 - ------ + 16.5 + ---- z - 1 z Hz en factores -11.5*(0.434782608695652*z + 1) -------------------------------- z*(z - 1) {Q_polos:veces}: {1: 1, 0: 1} {P_ceros:veces}: {-2.30000000000000: 1} estabilidad asintótica en z: circ1_dentro : 1 circ1_repetidos : 0 circ1_sobre : 1 circ1_fuera : 0 unicos : 2 repetidos : 0 asintota : marginalmente estable h[n]: 16.5*DiracDelta(n) + 11.5*DiracDelta(n - 1) - 16.5*Heaviside(n) señal discreta h[n] n : [0. 1. 2. 3. 4. 5. 6.] h[n]: [ 0. -5. -16.5 -16.5 -16.5 -16.5 -16.5]
Ejercicio: 2Eva2010TI_T3 LTI CT simplificar H(s) por Bloques
Se ubican algunos puntos de referencia sobre el diagrama de bloques para plantear las ecuaciones, dejando para el último el bloque en serie del exponencial e(-3s) o retraso en tiempo
Se plantea la simplificación de H(s) =W4(s)/X(s), dejando el término exponencial o retraso de tiempo para el final. Por lo que se despeja W4(s)
La respuesta al impulso H1(s) tiene polos en s=-3 y s=-4, que se encuentran en el lado izquierdo del plano imaginario s. Por lo que sus componentes en el dominio del tiempo son exponenciales decrecientes, el sistema es asintóticamente estable.
El grado del polinomio P del numerador es menor al grado del polinomio Q del numerador.
Separando en fracciones parciales para H1(s) :
Finalmente, añadiendo el término exponencial, que es el retraso en tiempo del sistema:
se observa el comportamiento de H(s) junto a los polos en la parte real e imaginaria:
el resultado con el algoritmo para el literal a es:
H(s) = P(s)/Q(s): / 2 4 \ -3*s |- ----- + -----|*e \ s + 4 s + 3/ H(s) en factores: -3*s 2*(s + 5)*e --------------- (s + 3)*(s + 4) h(t) : / 9 -3*t 12 -4*t\ \4*e *e - 2*e *e /*Heaviside(t - 3) polosceros: exp(-3*s) : {'Q_polos': {-3: 1, -4: 1}, 'P_ceros': {-5: 1}, 'Hs_k': 2*(s + 5)/((s + 3)*(s + 4))} Q_polos : {-3: 1, -4: 1} P_ceros : {-5: 1} Estabilidad de H(s): n_polos_real : 2 n_polos_imag : 0 enRHP : 0 unicos : 0 repetidos : 0 asintota : estable
Usando la tabla de transformadas de Laplace, para la línea 5 y la propiedad de desplazamiento en t, se obtiene:
La señal de salida Y(s)=H(s)X(s) ante una entrada X(s)=1/(s+5) que es la transformada de Laplace de x(t)=e-5t μ(t)
Tarea: Realizar el desarrollo analítico y revisar los resultados del algoritmo
al realizar las fracciones parciales, se obtiene:
Con transformada inversa de Laplace, usando nuevamete la tabla de transformadas de Laplace, para la línea 5 y la propiedad de desplazamiento en t, se obtiene:
El resultado del algoritmo para el literal c del ejercicio es:
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 : / 2 2 \ -3*s |- ----- + -----|*e \ s + 4 s + 3/ yt_ZSR : / 9 -3*t 12 -4*t\ \2*e *e - 2*e *e /*Heaviside(t - 3) Y(s)_total = ZIR + ZSR: / 2 2 \ -3*s |- ----- + -----|*e \ s + 4 s + 3/ y(t)_total = ZIR + ZSR: / 9 -3*t 12 -4*t\ \2*e *e - 2*e *e /*Heaviside(t - 3) >>>
Usando los bloques desarrollados en la telg1001.py que pueden ser usados en cada pregunta.
y las funciones resumidas como# Y(s) Respuesta total con entada cero y estado cero # Qs Y(s) = Ps X(s) ; H(s)=Ps/Qs # https://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) # Literal a. H(s) y estabilidad Hs = 2*(s+5)/((s+4)*(s+3)) * sym.exp(-3*s) #Hs = 1+0*s cuando es constante # literal c. 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 ; 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()
Ejercicio: 2Eva2010TI_T1 LTI DT Bloques de H[z] para ecuación de diferencias
El diagrama mostrado se reordena y añade anotaciones para facilitar la escritura de la ecuación de diferencias:
Dado que hay dos bloques (1/z) o de retraso hacia abajo, se identifica que los polinomios son de segundo orden (N=2).
Los coeficientes de retraso se leen de arriba hacia abajo como a0,-a1,-a2 ordenados en la siguiente tabla:
retraso | adelanto |
a0 = 1 | b0 = 0 |
a1 = -(1.6) = -1.6 | b1 = 4 |
a2 = -(-0.63) = 0.63 | b2 = -4 |
Se aplica lo mismo para los coeficientes de adelanto y se completa el modelo para los polinomios del numerador y denominador:
Con el polinomio del denominador Qz se encuentran las raíces
polos: {0.70: 1, 0.90: 1}
se aplican fracciones parciales modificadas al dividir cada lado para z,
aplicando el método de Heaviside:
restaurando a fracciones parciales al multiplicar por z
usando la tabla de transformadas z
Usando el algoritmo de la sección X[z] Fracciones parciales modificadas con Python
con entrada:
Pz = 4*z-4 Qz = z**2-1.6*z+0.63
y resultado:
Hz: 4*z - 4 ----------------- 2 z - 1.6*z + 0.63 Hz en fracciones parciales 8.57142857142857*z 2.22222222222222*z ------------------ - ------------------ - 6.34920634920635 z - 0.7 z - 0.9 Hz en factores 4*(z - 1) ------------------- (z - 0.9)*(z - 0.7) {Q_polos:veces}: {0.700000000000000: 1, 0.900000000000000: 1} {P_ceros:veces}: {1: 1} estabilidad asintótica en z: circ1_dentro : 2 circ1_repetidos : 0 circ1_sobre : 0 circ1_fuera : 0 unicos : 2 repetidos : 0 asintota : estable h[n]: / n n\ \8.57142857142857*0.7 - 2.22222222222222*0.9 /*Heaviside(n) - 6.34920634920635*DiracDelta(n) señal discreta h[n] n : [0 1 2 3 4 5 6 7 8 9] h[n]: [ 0. 4. 2.4 1.32 0.6 0.1284 -0.17256 -0.356988 -0.462468 -0.51504636]
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.
x(t) = cos(1500t) = cos (2πf) con intervalo de muestreo Ts = 0.0015 = 1/fs.
De la señal de entrada se tiene que 2πf=1500, por lo que f = 1500/(2π)
Para un buen muestreo de la señal de entrada, se debe cumplir la frecuencia de Nyquist, es decir fs>2f
que cumple con la frecuencia mínima de muestreo y no se presentan inconvenientes para el funcionamiento de la señal por sub-muestreo
# Transformada z- Fracciones parciales # https://blog.espol.edu.ec/telg1001/lti-dt-transformada-z-xz-fracciones-parciales-con-python/ import numpy as np import sympy as sym import matplotlib.pyplot as plt import telg1001 as fcnm #sym.SYMPY_DEBUG=True # INGRESO z = sym.Symbol('z') n = sym.Symbol('n', real=True) # coeficientes como racional en dominio 'ZZ' enteros Pz = 4*z-4 Qz = z**2-1.6*z+0.63 F = Pz/Qz # para graficar f_nombre = 'H' # nombre de función[z]: H,X,Y, etc muestras_fn = 10 # muestras para f[n] # PROCEDIMIENTO Fz = fcnm.apart_z(F) Fz_factor = sym.factor(F.evalf()) Fz_factor = fcnm._round_float_is_int(Fz_factor) # polos y ceros de Hz [P,Q] = F.as_numer_denom() P = sym.poly(P,z) Q = sym.poly(Q,z) P_ceros = sym.roots(P) Q_polos = sym.roots(Q) estable_z = fcnm.estabilidad_asintotica_z(Q_polos) # Inversa de transformada z fn = 0*n ; Fz_revisar = [] ; Qz2_term =[] term_sum = sym.Add.make_args(Fz) for term_k in term_sum: term_kn = fcnm.inverse_z_transform(term_k,z,n) if type(term_kn)==tuple: fn = fn + term_kn[0] elif term_kn is not None: fn = fn + term_kn elif term_kn is None: f_noeval = f_noeval + term_k Qz2 = fcnm.Q_cuad_z_parametros(term_k) if Qz2: Qz2_term.append(Qz2) fn = fn.collect(sym.Heaviside(n)) fn = fn.collect(sym.DiracDelta(n)) fn = fcnm._round_float_is_int(fn) # SALIDA print('\n '+f_nombre+'z:') sym.pprint(F) print('\n '+f_nombre+'z en fracciones parciales') sym.pprint(Fz) print('\n '+f_nombre+'z en factores') sym.pprint(Fz_factor) print('\n {Q_polos:veces}:',Q_polos) print(' {P_ceros:veces}:',P_ceros) if len(Qz2_term)>0: print('\nparametros cuadraticos: ') for i in range(0,len(Qz2_term),1): for unterm in Qz2_term[i]: print(' termino:',unterm) fcnm.print_resultado_dict(Qz2_term[i][unterm]) print('\nestabilidad asintótica en z:') fcnm.print_resultado_dict(estable_z) print('\n '+f_nombre.lower()+'[n]:') sym.pprint(fn) if len(Fz_revisar)>0: print('revisar terminos sin transformada de tabla:') for un_term in Fz_revisar: print(un_term) # # GRAFICA ----------- fig_ROC = fcnm.graficar_Fz_polos(Fz_factor,Q_polos,P_ceros, muestras=101,f_nombre=f_nombre) fig_Fz = fcnm.graficar_Fs(Fz_factor,Q_polos,P_ceros, muestras=101, f_nombre=f_nombre) # graficar f[n] ------- f_n = sym.lambdify(n,fn.expand(),modules=fcnm.equivalentes) ki = np.arange(0,muestras_fn,1.0) fi = f_n(ki) print('\nseñal discreta '+f_nombre.lower()+'[n]') print('n :',ki) print(f_nombre.lower()+'[n]:',fi) # graficar f[n] fig_fn, grafxn = plt.subplots() plt.axvline(0,color='grey') plt.stem(ki,fi) plt.grid() plt.xlabel('n') plt.ylabel(f_nombre.lower()+'[n]') etiqueta = r''+f_nombre.lower()+'[n]= $'+str(sym.latex(fn))+'$' plt.title(etiqueta) plt.show()
Ejercicio: 2Eva2009TII_T2 LTI DT Dado h[n], y[n] determine X[n]
Con los datos de h[n] y y[n], se obtienen las transformadas H[z] y Y[z],
la transformada z es:
Para la señal de salida Yc[z] conocida:
la transformada z es:
La señal de entrada x[n]
La señal de salida Y[z] esperada en dominio z se obtiene como Y[z] = H[z]X[z], la expresión se escribe como:
igualando las expresiones con Y[z] conocida con Y[z] esperada:
para que el denominador quede (z+2), se iguala el término con (z-c), con lo que c=-2
comparando el término z, se tiene que a=-3, quedando solo la parte constante para determinar el valor de b
se tiene que b= 7
teniendo la expresión de la entrada como:
Se inicia con los datos de H[z]
Para el diagrama de bloques se desplaza para despejar y[n]
Observaciones:
Las raíces características o frecuencias naturales del sistema H[z] se encuentran dentro del círculo de radio unitario. El sistema es asintóticamente estable, que implica que es BIBO estable.
Ejercicio: 1Eva2016TII_T4 LTI DT Sistema 2do orden
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:
Para usar los operadores ‘E’ y encontrar el polinomio característico, dado que el sistema es LTI – DT, se puede desplazar 2 unidades:
La expresión usando notación de operadores ‘E’ es:
donde el numerador P[E] = E2
y el denominador Q[E] = E2 – (3/4)E +(1/8)
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
usando la fórmula o el algoritmo se busca las raices del polinomio Q(E):
Siendo raices reales y no repetidas, la respuesta del sistema tiene la forma:
se convierte a la forma:
Para encontrar los coeficientes c1 y c2, 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]
donde el impulso tiene valor de 1 solo en n=0, haciendo equivalente h[n] equivale a y[n] , entonces:
n = 0
n=1
con lo que es posible encontrar c1 y c2,
resolviendo:
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.
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 >>>
# 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()
considerando que:
se reemplaza con:
un método mas detallado es:
considerando que:
se tiene lo siguiente,
que es el mismo resultado que con el método presentado al inicio del literal.
Revisar: LTID Transformada z – X[z] Fracciones parciales modificadas con Python
A partir de la ecuación de diferencias:
en transformada z (unidad 7), que es semejante a operador ‘E’,
la función de transferencia o respuesta al impulso se expresa como:
usandolas raices del polinomio Q(E)
para facilitar las operaciones se usan fracciones parciales modificadas,
Usando el método de «cubrir» de Heaviside:
reemplazando k1, k2 y restaurando a fracciones parciales al multiplicar ambos lados por z,
se puede usar la tabla de transformadas z para obtener el mismo resultado que el desarrolo anterior con operador ‘E’
Ejercicio: 1Eva2016TII_T3 LTI DT Sistema 1er orden con constante a
A partir del diagrama se tiene que:
El sistema es discreto de primer orden,
Para la respuesta de impulso se escribe la expresión en notación de operador E, con x[n]=δ[n]
para determinan las raíces del Q[E]
que establece la ecuació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:
El sistema es causal si para n<0 los valores son cero, h[-1] =0
con lo que par encontrar la constante c1,
la constante c1 =1, quedando com respuesta a impulso:
Siendo:
se tiene que:
Solución alterna, El mismo resultado se obtiene mediante:
usando la tabla de convolucion discreta:
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] = an μ[n] el sistema es de tipo IIR.
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 hinv[n] el sistema es de tipo FIR.
El diagrama del sistema inverso sería: