# --------------------------------------------------------------------------- # N = 2: # Filtro Chebyshev Tipo I: z1, p1, k1 = sig.cheb1ap(my_N[0], eps) NUM1, DEN1 = sig.zpk2tf(z1, p1, k1) tf_ch1 = tf(NUM1, DEN1) # Filtro Chebyshev Tipo II o Chebyshev Inverso: z2, p2, k2 = sig.cheb2ap(my_N[0], alfa_min) NUM2, DEN2 = sig.zpk2tf(z2, p2, k2) tf_ch2 = tf(NUM2, DEN2) analyze_sys([tf_ch1, tf_ch2], ['Cheby Tipo I Orden 2', 'Cheby Tipo II o Inverso Orden 2']) # --------------------------------------------------------------------------- # N = 3: # Filtro Chebyshev Tipo I: z1, p1, k1 = sig.cheb1ap(my_N[1], eps) NUM1, DEN1 = sig.zpk2tf(z1, p1, k1) tf_ch1 = tf(NUM1, DEN1) # Filtro Chebyshev Tipo II o Chebyshev Inverso: z2, p2, k2 = sig.cheb2ap(my_N[1], alfa_min) NUM2, DEN2 = sig.zpk2tf(z2, p2, k2) tf_ch2 = tf(NUM2, DEN2)
eps = np.sqrt(10**(this_ripple / 10) - 1) num, den = sig.zpk2tf(z, p, k) num, den = sig.lp2lp(num, den, eps**(-1 / this_order)) z, p, k = sig.tf2zpk(num, den) elif aprox_name == 'Chebyshev1': z, p, k = sig.cheb1ap(this_order, this_ripple) elif aprox_name == 'Chebyshev2': z, p, k = sig.cheb2ap(this_order, this_ripple) elif aprox_name == 'Bessel': z, p, k = sig.besselap(this_order, norm='mag') elif aprox_name == 'Cauer': z, p, k = sig.ellipap(this_order, this_ripple, this_att) num, den = sig.zpk2tf(z, p, k) all_sys.append(sig.TransferFunction(num, den)) filter_names.append(aprox_name + '_ord_' + str(this_order) + '_rip_' + str(this_ripple) + '_att_' + str(this_att)) analyze_sys(all_sys, filter_names)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Wed May 8 23:19:00 2019 @author: mariano """ import scipy.signal as sig import numpy as np from splane import analyze_sys, pzmap, grpDelay, bodePlot z, p, k = sig.buttap(3) num_lp, den_lp = sig.zpk2tf(z, p, k) eps = np.sqrt(10**(0.1) - 1) num_lp_d, den_lp_d = sig.lp2lp(num_lp, den_lp, eps**(-1 / 3)) num_hp_d, den_hp_d = sig.lp2hp(num_lp_d, den_lp_d) num_hp_d, den_hp_d = sig.lp2hp(num_lp, den_lp, eps**(-1 / 3)) #%matplotlib qt5 analyze_sys([sig.TransferFunction(num_lp, den_lp)], ['mp_norm']) analyze_sys([sig.TransferFunction(num_lp_d, den_lp_d)], ['mp_desnorm'])
# ---------------------------------------------------------------------------- # Ploteo de las Señales, Respuestas, y Filtros: my_tfs = [my_tf_bw , my_tf_ch, my_tf_bessel] # # Respuesta de Módulo y Fase # # Diagrama de Polos Y Ceros # for i in range ( len(my_tfs) ): # bodePlot ( my_tfs[i], 1) # plt.legend (['Filtro LP Butter Orden 5', 'Filtro LP Cheby Orden 5']) # pzmap ( my_tfs[i], 2 ) analyze_sys(my_tfs, ['Butter', 'Cheby', 'Bessel']) tt, y1, x = sig.lsim2 ((NUM1, DEN1), train_pulse, t ) tt, y2, x = sig.lsim2 ((NUM2, DEN2), train_pulse, t ) tt, y3, x = sig.lsim2 ((NUM3, DEN3), train_pulse, t ) fig5 = plt.figure () fig5.suptitle ("Tren de Pulsos de Amplitud 1V y de 0.125 [rad/seg] Muestreado a Ts = 2.425 seg durante 240 seg") plt.plot (t, train_pulse) plt.grid() plt.xlabel ('t[seg]') plt.ylabel ('x[t] [V]') # plt.xlim (0, 450) plt.ylim (-0.1, 1.1)
print('\n', my_tf_be) #pretty_print_lti(my_tf_be) print('Denominador Factorizado de la Transferencia Normalizada:', convert2SOS(my_tf_be)) # ---------------------------------------------------------------------------- # ---------------------------------------------------------------------------- # Ploteo de las Señales, Respuestas, y Filtros: my_tfs = [my_tf_bw, my_tf_ch, my_tf_be] # Respuesta de Módulo y Fase # Diagrama de Polos Y Ceros analyze_sys(my_tfs, ['Butter Orden 5', 'Cheby Orden 5', 'Bessel Orden 5']) # ---------------------------------------------------------------------------- # Ploteo de la Señal "Escalón": t0 = -(N // 8) * Ts tf = np.ceil(N / 2) * Ts tt = np.linspace(t0, tf, N) fig10 = plt.figure() fig10.suptitle('Unit Step Function') plt.plot(tt, u(tt), 'k') plt.xlabel('time [seg]') plt.ylabel('Step Fuction $u(t)$ [V]') plt.xlim(t0, tf / 2)
from splane import tfadd, tfcascade, analyze_sys, pzmap, grpDelay, bodePlot, pretty_print_lti nn = 2 # orden ripple = 3 # dB eps = np.sqrt(10**(ripple/10)-1) z,p,k = sig.besselap(nn, norm='delay') # z,p,k = sig.buttap(nn) num_lp, den_lp = sig.zpk2tf(z,p,k) num_lp, den_lp = sig.lp2lp(num_lp, den_lp, eps**(-1/nn) ) num_hp, den_hp = sig.lp2hp(num_lp,den_lp) lp_sys = sig.TransferFunction(num_lp,den_lp) hp_sys = sig.TransferFunction(num_hp,den_hp) xover = tfadd(lp_sys, hp_sys) bandpass = tfcascade(lp_sys, hp_sys) pretty_print_lti(lp_sys) pretty_print_lti(hp_sys) pretty_print_lti(xover) pretty_print_lti(bandpass) analyze_sys([lp_sys, hp_sys, xover, bandpass], ['lp', 'hp', 'xover', 'bandpass'])
tf = sig.TransferFunction(num, den) print("*Coeficientes de la transferencia Besselworth NORMALIZADA:\n") print("\tNumerador:") for c in tf.num: print(f"\t\t{c:.3f}") print("\tDenominador:") for c in tf.den: print(f"\t\t{c:.3f}") print("\n") print("*Polos y ceros de la transferencia Besselworth NORMALIZADA:\n") print("\tPolos:") for c in tf.poles: print(f"\t\t{c:.3f}") print("\tCeros:") for c in tf.zeros: print(f"\t\t{c:.3f}") all_sys.append(tf) filter_names.append("Besselworth orden 4") #Defino el rango a imprimir y el punto a mostrar ini = 0.1 end = 10.1 n = 100000 bode_lenght = np.linspace(ini, end, n) printW = 1 #imprimo todos los Bode analyze_sys(all_sys, filter_names, bode_lenght, printW=printW)
# bodePlot(this_lti, label = 'HP', fig_id=fig_id, axes_hdl=axes_hdl ) # all_sys += [this_lti] # str_aux = 'Sección HP' # str_labels += [str_aux] # print( str_aux ) # print( '-' * len(str_aux) ) # pretty_print_lti(this_lti) # print( '\n\n') # for ii in np.arange(1, p_bp_n.shape[0]/2, dtype='int'): # this_k = 1 # this_z = [] # this_p = p_bp_n[ii*2:ii*2+2] # this_lti = sig.TransferFunction(sig.lti(this_z,this_p,this_k)) # str_aux = 'Sección LP' # print( str_aux ) # print( '-' * len(str_aux) ) # pretty_print_lti(this_lti) # print( '\n\n') # all_sys += [this_lti] # str_labels += [str_aux] analyze_sys(all_sys, str_labels)
this_order = force_order else: this_order = besselord(omega_p, omega_s, alfa_max, alfa_min, omega_d, max_pc_delay) z, p, k = sig.besselap(this_order, norm='mag') elif aprox_name == 'Cauer': if force_order > 0: this_order = force_order else: this_order, _ = sig.ellipord(omega_p, omega_s, alfa_max, alfa_min, analog=True) z, p, k = sig.ellipap(this_order, alfa_max, alfa_min) if (tipo_de_filtro == "Pasa_Alto"): z, p, k = sig.lp2hp_zpk(z, p, k) this_lti = sig.ZerosPolesGain(z, p, k).to_tf() #this_lti = sig.ZerosPolesGain(z, p, k).to_tf() pretty_print_lti(this_lti) analyze_sys([this_lti], [aprox_name], [ideal_filter])
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Wed May 8 23:14:49 2019 @author: mariano """ import scipy.signal as sig import numpy as np from splane import tfadd, tfcascade, analyze_sys, pzmap, grpDelay, bodePlot, pretty_print_lti kn = 1 # num qn = 1e6 wn = 2 # num qd = np.sqrt(2)/2 wd = 1 tf_bicuad = sig.TransferFunction(kn*np.array([1, wn/qn, wn**2]), np.array([1, wd/qd, wd**2])) pretty_print_lti(tf_bicuad) analyze_sys([tf_bicuad], ['bicuad'])
# num qn = -2 wn = 10 # den qp = 2 wp = 10 # kn = 1/wn**2 # kp = 1/wp**2 kn = -1 kp = 1 # coeficientes # num = kn * np.array([1, 0, wn**2]) # # Omega y Q num = kn * np.array([1, wn / qn, wn**2]) den = kp * np.array([1, wp / qp, wp**2]) # todavía tiene algunos bugs ... # tf_bicuad_sos = tf2sos_analog(num, den) tf_bicuad_sos = np.hstack((num, den)).reshape((1, 6)) pretty_print_SOS(tf_bicuad_sos, mode='omegayq') plt.close('all') analyze_sys(tf_bicuad_sos, 'mi_bicuad')
print_console_alert('Order forced to {:d}'.format(force_order)) print_console_subtitle('Total transfer function') pretty_print_lti(lowpass_proto_lti) if p.shape[0] > 2: print_console_subtitle('Cascade of second order systems (SOS' 's)') lowpass_sos_proto = zpk2sos_analog(z, p, k) # pretty_print_SOS(lowpass_sos_proto) pretty_print_SOS(lowpass_sos_proto, mode='omegayq') print_console_subtitle('Respuesta en frecuencia') analyze_sys(lowpass_sos_proto, str_designed_filter) else: print_console_subtitle('Respuesta en frecuencia') analyze_sys(lowpass_proto_lti, '{:s} orden {:d}'.format(aprox_name, this_order)) # Freq. transformation ####################### if aprox_type != 'LP': print_console_alert('Frequency transformation LP -> ' + aprox_type) if aprox_type == 'HP':