plt.xlim(t0, tf) fig4 = plt.figure ( ) plt.plot (tt, s_filtrada, 'r') plt.grid ('True') plt.title ( 'Señal Filtrada' ) plt.xlabel ('$t[seg]$', fontsize = 12) plt.ylabel(' Señal Filtrada [V]', fontsize = 10) plt.xlim (t0, tf) # --------------------------------------------------------------------------- # Respuesta en Frecuencia: bodePlot (my_tf_lp, 'Filtro Prototipo - Low Pass') pzmap (my_tf_lp) bodePlot (my_tf_hp, 'Filtro Destino - High Pass') pzmap (my_tf_hp) # --------------------------------------------------------------------------- # Espectro de las Señales: # Grilla de Sampleo Frecuencial: f0 = 0 df = Fs/N ff = (N-1)*df f_f = np.linspace(f0, ff, N )
R1 = 0.25 # 2500 R2 = 1 # 10**3 C1 = 1 # 100e-6 C2 = C1 # 100e-6 ############################################################################## # Desarrollo de la Transferencia del Filtro Pasa-Banda Pasivo Según la # Estructura Usada: NUM = [1 / R2 * C2, 0] DEN = [ 1, (1 / (C1 * R2) + 1 / (C1 * R1) + 1 / (C2 * R2)), 1 / (R1 * R2 * C1 * C2) ] # Transferencia Normalizada de mi Filtro Pasa-Banda Pasivo: my_tf = tf(NUM, DEN) ############################################################################## # Levanto la Imagen de mi Circuito Pasivo a Utilizar: fp_imagen = './Circuito_Ejercicio3_PasaBanda.jpg' i = im.open(fp_imagen, 'r') # Abro la Imagen. i.show() # Muestro la Imagen en una Ventana. ############################################################################## # Ploteo de la Respuesta de Módulo y Respuesta de Fase y el Retardo de Grupo: bodePlot(my_tf) pzmap(my_tf) grpDelay(my_tf)
w03 = 1 * wnb * 1000 Q3 = 2.247 K3 = 1 num3 = np.array([K3 * w03**2]) den3 = np.array([1., w03 / Q3, w03**2]) w04 = 1 * wnb * 1000 K4 = 1 num4 = np.array([K4 * w04]) den4 = np.array([1., w04]) numer = np.polymul(num1, num2) denom = np.polymul(den1, den2) numer = np.polymul(numer, num3) denom = np.polymul(denom, den3) numer = np.polymul(numer, num4) denom = np.polymul(denom, den4) H = sig.TransferFunction(numer, denom) _, axes_hdl = bodePlot(H) plt.sca(axes_hdl[0]) plt.gca pzmap(H) plt.show()
# Transformación en Frecuencia: ====> w_hp = -1 / w_lp wp_lp_n = -1 / wp_hp_n wp_lp_n = np.abs(wp_lp_n) w_zt_lp_n = -1 / w_zt_hp_n w_zt_lp_n = np.abs(w_zt_lp_n) z_lp_n, p_lp_n, k_lp_n = sig.buttap(orden_filtro) NUM_LP_n, DEN_LP_n = sig.zpk2tf(z_lp_n, p_lp_n, k_lp_n) NUM_LP_n = [1, 0, 9] # Le agrego el cero de transmisión. my_tf_lp_n = transf_f(NUM_LP_n, DEN_LP_n) bodePlot(my_tf_lp_n) pzmap(my_tf_lp_n) # ---------------------------------------------------------------------------- # Filtro Destino High-Pass: NUM_HP_n, DEN_HP_n = sig.lp2hp(NUM_LP_n, DEN_LP_n) z_hp_n, p_hp_n, k_hp_n = sig.tf2zpk(NUM_HP_n, DEN_HP_n) my_tf_hp_n = transf_f(NUM_HP_n, DEN_HP_n) bodePlot(my_tf_hp_n) pzmap(my_tf_hp_n) # Si ahora quiero que para w--> inf haya 0dB: k_hp_n = k_hp_n * (1 / 9)
from scipy import signal as sig #import numpy as np #from numpy.polynomial import Polynomial as P from splane import bodePlot, pzmap # $+9$^3 #poli=P([0,1,0,9]) #num_r=poli.roots() #print("Numerador -->",num_r) #1+2S+2s^2+s^3 #poli2=P([9,18,18,9]) #deno_r=poli2.roots() #print("Denominador -->",deno_r) #num = list(np.array([0.-0.33333333j, 0.+0.j, 0.+0.33333333j])) #print("num: ",num) #den = list(np.array([-1 +0j , -0.5-0.8660254j, -0.5+0.8660254j])) #print("dem: ",den) #H = sig.TransferFunction( num, den ) #bodePlot(H) #pzmap(H) myFilter = sig.TransferFunction([9, 0, 1, 0], [9, 18, 18, 9]) print('Poles:', myFilter.poles) print('Zeros:', myFilter.zeros) bodePlot(myFilter) pzmap(myFilter)
# --------------------------------------------------------------------------- # --------------------------------------------------------------------------- # Llevo mi Filtro Prototipo (Low-Pass) a mi Filtro Destino (High-Pass) if (eps != 1): # Caso de Máxima Planicidad!! wb_hp = 1 / abs(wb_lp) # Omega de Butterworth High Pass NUM_hp, DEN_hp = sig.lp2hp(NUM, DEN, wb_hp) # Renormalizo con wb_hp else: NUM_hp, DEN_hp = sig.lp2hp(NUM, DEN) # Caso de Butterworth # --------------------------------------------------------------------------- # --------------------------------------------------------------------------- # Calculo la Transferencia de mi Filtro Objetivo (High-Pass) my_tf_lp = tf(NUM_lp, DEN_lp) my_tf_hp = tf(NUM_hp, DEN_hp) # --------------------------------------------------------------------------- # --------------------------------------------------------------------------- # Ploteo bodePlot(my_tf_hp, 'Filtro High Pass') pzmap(my_tf_hp, 'none', 'Filtro Destino - High Pass') pzmap(my_tf_lp, 'none', 'Filtro Prototipo - Low Pass')
this_lti = sig.TransferFunction(num_bp_n, den_bp_n) pretty_print_lti(this_lti) print('\n\n') #%matplotlib qt5 # visualizo el modelo matemático normalizado #analyze_sys([sig.TransferFunction(num_bp_n,den_bp_n)], ['mp']) # o el modelo matemático desnormalizado #analyze_sys([sig.TransferFunction(num_bp,den_bp)], ['mp']) # visualización de cada sección fig_id = 1 this_lti = sig.TransferFunction(num_bp_n, den_bp_n) _, axes_hdl = bodePlot(this_lti, label='Total', fig_id=fig_id) all_sys = [this_lti] str_labels = ['total'] ## # Factorización en BP - BP ########################### this_k = k_bp_n this_z = z_bp_n[0] this_p = p_bp_n[0:2] this_lti = sig.TransferFunction(sig.lti(this_z, this_p, this_k)) bodePlot(this_lti, label='Sect {:d}'.format(0), fig_id=fig_id, axes_hdl=axes_hdl)
from scipy import signal from sympy import * from splane import pzmap, grpDelay, bodePlot num = [1, 0, 0, 0, 0] den = [1, 1.87, 6.71, 7.48, 12.43, 7.48, 6.71, 1.87, 1] sys = signal.TransferFunction(num, den) bodePlot(sys) pzmap(sys) grpDelay(sys) """ S = symbols('S') este seria el caso de Wb print(expand((S**2+S*1.93+ 1)*(S**2+S*1.414+ 1)*(S**2+S*0.518+ 1))) num = [1] den = [1,3.86,7.46,9.137,7.46,3.862,1] print("Complete") """ """ S = symbols('S')
#%matplotlib qt5 # visualizo el modelo matemático normalizado #analyze_sys([sig.TransferFunction(num_bp_n,den_bp_n)], ['mp']) # o el modelo matemático desnormalizado #analyze_sys([sig.TransferFunction(num_bp,den_bp)], ['mp']) # visualización de cada sección ## # Factorización en BP - BP ########################### fig_id = 1 _, axes_hdl = bodePlot(sig.TransferFunction(num_bp_n, den_bp_n), label='Total', fig_id=fig_id) this_k = k_bp_n this_z = z_bp_n[0] this_p = p_bp_n[0:2] bodePlot(sig.TransferFunction(sig.lti(this_z, this_p, this_k)), label='Sect {:d}'.format(0), fig_id=fig_id, axes_hdl=axes_hdl) str_aux = 'Section {:d}'.format(0) print(str_aux) print('-' * len(str_aux)) this_lti = sig.TransferFunction(sig.lti(this_z, this_p, this_k))
RB * (100 + tol / 2) / 100, size=NN) plt.close('all') # analizaremos cada iteración resultante for (this_C, this_R, this_RB) in zip(all_C, all_R, all_RB): this_KK = 1 + this_RB / this_R this_QQ = 1 / (3 - this_KK) this_w0 = 1 / this_R / this_C my_tf = TransferFunction([this_KK * (this_w0**2)], [1, this_w0 / this_QQ, this_w0**2]) _, axes_hdl = bodePlot(my_tf, 1) # finalmente ploteamos también la transferencia con los valores esperados # sin incertidumbre alguna sobre sus valores. KK = 1 + RB / RR QQ = 1 / (3 - KK) WW0 = 1 / RR / CC my_tf = TransferFunction([KK * (WW0**2)], [1, WW0 / QQ, WW0**2]) w, mag, phase = my_tf.bode(n=300) (mag_ax_hdl, phase_ax_hdl) = axes_hdl plt.sca(mag_ax_hdl) plt.semilogx(w, mag, '-r', linewidth=3) # Bode magnitude plot
import matplotlib as mpl from matplotlib import pyplot as plt mpl.rcParams['figure.figsize'] = (10, 10) #%% Esto tiene que ver con cuestiones de presentación de los gráficos, # NO ES IMPORTANTE fig_sz_x = 14 fig_sz_y = 13 fig_dpi = 80 # dpi #fig_font_family = 'Ubuntu' fig_font_size = 16 plt.rcParams.update({'font.size': fig_font_size}) #plt.rcParams.update({'font.family':fig_font_family}) from splane import bodePlot, pzmap _, axes_hdl = bodePlot(tf) plt.gca pzmap(tf) plt.show() ############################################################### # calculo de los componentes normalizados # imponiendo C y usando R1=R C = 100e-9 # impongo C de forma que la desnormalizada sea C_n = C * N_w1 k = num / den[2] Q = m.sqrt(den[2]) / den[1] R = 1 / (C_n * m.sqrt(den[2])) print('R = %s kΩ' % (R / 1000))