"""
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)