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