""" from splane import bodePlot, pzmap from matplotlib import pyplot as plt import scipy.signal as sig from scipy.signal import TransferFunction as tf import numpy as np plt.close('all') ripple_ = 3 # Ripple en la Banda de Paso, alfa_máx en dB fp = 1000 #wp = 2*np.pi*fp wp = 1 # Omega_p Normalizado. order_filter = 2 z, p, k = sig.buttap(order_filter) # No Le Interesa el valor de epsilon. NUM, DEN = sig.zpk2tf(z, p, k) my_tf = tf(NUM, DEN) #Ploteo: bodePlot(my_tf) pzmap(my_tf) # Plano $ - Diagrama de Polos y Ceros
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)
# 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) NUM_HP_n, DEN_HP_n = sig.zpk2tf(z_hp_n, p_hp_n, k_hp_n)
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 )
# --------------------------------------------------------------------------- # --------------------------------------------------------------------------- # 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')
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()
num = np.array([1, wc]) den = np.array([1, wp]) H = sig.TransferFunction(num, den) # Graficamos el diagrama de polos y ceros # Graficamos la respuesta en frecuencia para el modulo y la fase. _, axes_hdl = bodePlot(H) # para que se vea como uno intuye el módulo. Probar comentar las siguientes 2 líneas plt.sca(axes_hdl[0]) plt.ylim([-1, 1]) plt.gca pzmap(H) plt.show() #%% Con valores normalizados en frecuencia norma = 1e3 #Calculo norma = wo = 1000 wc_n = wc / norma wp_n = wp / norma num_n = np.array([1, wc_n]) den_n = np.array([1, wp_n]) Hn = sig.TransferFunction(num_n, den_n) # Graficamos el diagrama de polos y ceros # Graficamos la respuesta en frecuencia para el modulo y la fase.
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)
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')
from scipy import signal import matplotlib.pyplot as plt from splane import bodePlot, pzmap R = 1000 # 1KOhm C = 0.000001 # 1uF # Esta normalizado # Docs https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.TransferFunction.html num = [1, -1] dem = [1, 1] sys = signal.TransferFunction(num, dem) # Docs https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.bode.html w, mag, phase = signal.bode(sys) plt.figure() plt.semilogx(w, mag) # Bode magnitude plot plt.ylim([-1, 1]) plt.figure() plt.semilogx(w, phase) # Bode phase plot pzmap(sys) # Diagrama de polos y ceros. Función con efectos colaterales. plt.show()
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)) print('C = %s nF' % (C * 1e9)) print('Q = %s' % Q)