def func_tranf(self):
chebyshev.raizes_unit(self)
poli = np.poly(self.Sk)
coef = poli.real
D = list()
aux = 0
for i in range(-self.N, 1):
D.append(coef[aux] * pow(self.Wp, i))
aux = aux + 1
if self.N % 2 != 0:
if self.tipo == "PB":
num, den = signal.lp2lp(coef[-1], coef, self.Wp)
H = signal.TransferFunction(num[-1], den)
elif self.tipo == "PA":
num, den = signal.lp2hp(coef[-1], coef, self.Wp)
H = signal.TransferFunction(num, den)
else:
aux = 1 / np.sqrt(1 + self.e**2)
if self.tipo == "PB":
num, den = signal.lp2lp(coef[-1], coef, self.Wp)
H = signal.TransferFunction(num * aux, den)
elif self.tipo == "PA":
num, den = signal.lp2hp(coef[-1], coef, self.Wp)
H = signal.TransferFunction(num * aux, den)
self.H = H
return H
def _transform(b, a, Wn, analog, output):
"""
Shift prototype filter to desired frequency, convert to digital with
pre-warping, and return in various formats.
"""
Wn = np.asarray(Wn)
if not analog:
if np.any(Wn < 0) or np.any(Wn > 1):
raise ValueError("Digital filter critical frequencies "
"must be 0 <= Wn <= 1")
fs = 2.0
warped = 2 * fs * tan(pi * Wn / fs)
else:
warped = Wn
# Shift frequency
b, a = lp2lp(b, a, wo=warped)
# Find discrete equivalent if necessary
if not analog:
b, a = bilinear(b, a, fs=fs)
# Transform to proper out type (pole-zero, state-space, numer-denom)
if output in ('zpk', 'zp'):
return tf2zpk(b, a)
elif output in ('ba', 'tf'):
return b, a
elif output in ('ss', 'abcd'):
return tf2ss(b, a)
elif output in ('sos'):
raise NotImplementedError('second-order sections not yet implemented')
else:
raise ValueError('Unknown output type {0}'.format(output))
def func_tranf(self):
chebyshev.raizes_unit(self)
poli_polos = np.poly(self.Sk)
polos = poli_polos.real
poli_zeros = list()
zeros = list()
for i in range(1, self.Nv+1):
Wz = 1 / np.cos((2*i - 1) * np.pi / (2*self.N))
poli_zeros.append(complex(0, -Wz))
poli_zeros.append(complex(0, Wz))
poli_zeros = np.poly(poli_zeros)
zeros = poli_zeros.real
aux = polos[-1]
for i in range(0, len(polos)):
polos[i] = polos[i] * zeros[-1]
for i in range(0, len(zeros)):
zeros[i] = zeros[i] * aux
if self.tipo == "PB":
num, den = signal.lp2lp(zeros, polos, self.Ws)
elif self.tipo == "PA":
num, den = signal.lp2hp(zeros, polos, self.Ws)
elif self.tipo == "PF":
num, den = signal.lp2bp(zeros, polos, self.Wo, self.Bs)
elif self.tipo == "RF":
num, den = signal.lp2bs(zeros, polos, self.Wo, self.Bs)
H = signal.TransferFunction(num, den)
self.H = H
return H
def TransfFreq(self, zeros, polos, Kp):
if self.tipo == "PB":
num, den = signal.lp2lp(zeros, polos, Kp)
elif self.tipo == "PA":
num, den = signal.lp2hp(zeros, polos, Kp)
elif self.tipo == "PF":
num, den = signal.lp2bp(zeros, polos, Kp, self.Bp)
elif self.tipo == "RF":
num, den = signal.lp2bs(zeros, polos, Kp, self.Bp)
H = signal.TransferFunction(num, den)
return H
def func_tranf(self):
butterworth.raizes_unit(self)
poli = list()
poli = np.poly(self.Sk)
coefReal = poli.real
self.Wc = butterworth.freq_corte(self)
if self.tipo == "PB":
num, den = signal.lp2lp(coefReal[-1], coefReal, self.Wc)
H = signal.TransferFunction(num, den)
elif self.tipo == "PA":
num, den = signal.lp2hp(coefReal[-1], coefReal, self.Wc)
H = signal.TransferFunction(num, den)
self.H = H
return H
def fun_trans(self):
k = self.raizes()
wc = self.freq_corte()
Bw = (wc[2] - wc[1])
self.nden = np.real(np.poly(k)) #denominador normalizado
den = np.zeros(
len(k)) #criando o array para o denominador transformado
if self.tipo == 'Passa-baixa':
[num, den] = sig.lp2lp(self.nden[-1], self.nden, wc[0])
FT = sig.TransferFunction(num,
den) #gerando a FT para a freq. de corte
if self.tipo == 'Passa-alta':
[num, den] = sig.lp2hp(self.nden[-1], self.nden, wc[0])
FT = sig.TransferFunction(num, den)
if self.tipo == 'Passa-faixa':
[num, den] = sig.lp2bp(self.nden[-1], self.nden, wc[0], Bw)
FT = sig.TransferFunction(num, den)
if self.tipo == 'Rejeita-faixa':
[num, den] = sig.lp2bs(self.nden[-1], self.nden, wc[0], Bw)
FT = sig.TransferFunction(num, den)
return FT
# Obtengo los Coeficientes de mi Transferencia.
NUM1, DEN1 = sig.zpk2tf(z1, p1, k1)
# Cálculo de wb:
wb = eps**(-1 / orden_filtro)
# Obtengo la Transferencia Normalizada
my_tf_bw = tfunction(NUM1, DEN1)
print('\n', my_tf_bw)
#pretty_print_lti(my_tf_bw)
print('\nDenominador Factorizado de la Transferencia Normalizada:',
convert2SOS(my_tf_bw))
NUM1, DEN1 = sig.lp2lp(NUM1, DEN1, wb)
my_tf_bw = tfunction(NUM1, DEN1)
# ----------------------------------------------------------------------------
print('\n\nFiltro Chebyshev de Orden 5:\n')
# Filtro de Chebyshev: Uso de los Métodos dentro del Paquete signal de Scipy.
z2, p2, k2 = sig.cheb1ap(orden_filtro, eps)
# Obtengo los Coeficientes de mi Transferencia.
NUM2, DEN2 = sig.zpk2tf(z2, p2, k2)
# Obtengo la Transferencia Normalizada
my_tf_ch = tfunction(NUM2, DEN2)
print('\n', my_tf_ch)
import numpy as np 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'])
from scipy import signal
import matplotlib.pyplot as plt
lp = signal.lti([1.0], [1.0, 1.0])
lp2 = signal.lti(*signal.lp2lp(lp.num, lp.den, 2))
w, mag_lp, p_lp = lp.bode()
w, mag_lp2, p_lp2 = lp2.bode(w)
plt.plot(w, mag_lp, label='Lowpass')
plt.plot(w, mag_lp2, label='Transformed Lowpass')
plt.semilogx()
plt.grid()
plt.xlabel('Frequency [rad/s]')
plt.ylabel('Magnitude [dB]')
plt.legend()
# ---------------------------------------------------------------------------
# ---------------------------------------------------------------------------
# Genero el Numerador y Denominador de mi Filtro:
NUM, DEN = sig.zpk2tf ( my_z, my_p, my_k )
# ---------------------------------------------------------------------------
# ---------------------------------------------------------------------------
# Se ejecuta Únicamente si estoy en el Caso de MÁXIMA PLANICIDAD !!! eps != 1
if ( eps != 1 ):
wb = eps**(-1/order_filter) #Omega de Butterworth
norma_frec = 1 / (R1*C1) # Calculo la Norma de Desnormalización
NUM, DEN = sig.lp2lp ( NUM, DEN, norma_frec ) # Desnormalizo usando la norma de Frecuencia.
# ---------------------------------------------------------------------------
# ---------------------------------------------------------------------------
# Calculo de la Transferencia
my_tf = tf ( NUM, DEN )
# ---------------------------------------------------------------------------
# ---------------------------------------------------------------------------
# Ploteo
bodePlot ( my_tf )
pzmap ( my_tf )
# ---------------------------------------------------------------------------
# Genero el Numerador y Denominador de mi Filtro:
NUM, DEN = sig.zpk2tf(my_z, my_p, my_k)
# ---------------------------------------------------------------------------
# ---------------------------------------------------------------------------
# Se ejecuta Únicamente si estoy en el Caso de MÁXIMA PLANICIDAD !!! eps != 1
if (eps != 1):
wb = eps**(-1 / order_filter) #Omega de Butterworth
# NUM, DEN = sig.lp2lp ( NUM, DEN, wb ) # Renormalizo para wb
# Vuelvo a Calcular el valor de norma_frec con los valores desnormalizados.
norma_frec = 1 / np.sqrt(R3_1 * R4_1 * C2_1 * C5_1)
# Desnormalizo a Nivel de Frecuencia / norma_frec = wp
NUM, DEN = sig.lp2lp(NUM, DEN, norma_frec)
# ---------------------------------------------------------------------------
# ---------------------------------------------------------------------------
# Calculo de la Transferencia
my_tf = tf(NUM, DEN)
# ---------------------------------------------------------------------------
# ---------------------------------------------------------------------------
# Ploteo
bodePlot(my_tf)
pzmap(my_tf)
# Requerimientos de plantilla
ripple = 3
attenuation = 40
order2analyze = 2
all_sys = []
filter_names = []
# Butter
z, p, k = sig.buttap(order2analyze)
eps = np.sqrt(10**(ripple / 10) - 1)
num, den = sig.zpk2tf(z, p, k)
num, den = sig.lp2lp(num, den, eps**(-1 / order2analyze))
z, p, k = sig.tf2zpk(num, den)
num, den = sig.zpk2tf(z, p, k)
all_sys.append(sig.TransferFunction(num, den))
filter_names.append('Butter_ord_' + str(order2analyze))
# Chebyshev
z, p, k = sig.cheb1ap(order2analyze, ripple)
num, den = sig.zpk2tf(z, p, k)
import scipy.signal as sig
import numpy as np
from splane import analyze_sys, pzmap, grpDelay, bodePlot, pretty_print_lti
nn = 2 # orden
ripple = 1 # dB
eps = np.sqrt(10**(ripple / 10) - 1)
# Diseño un Butter.
z, p, k = sig.buttap(nn)
num_lp, den_lp = sig.zpk2tf(z, p, k)
# paso de un Butter. a maxima planicidad si eps != 1
num_lp_butter, den_lp_butter = sig.lp2lp(num_lp, den_lp, eps**(-1 / nn))
# obtengo la transferencia normalizada del pasabanda
num_bp_n, den_bp_n = sig.lp2bp(num_lp_butter, den_lp_butter, wo=1, bw=1 / .253)
# obtengo la transferencia desnormalizada del pasabanda
num_bp, den_bp = sig.lp2bp(num_lp_butter, den_lp_butter, wo=8.367, bw=33)
# Averiguo los polos y ceros
z_bp_n, p_bp_n, k_bp_n = sig.tf2zpk(num_bp_n, den_bp_n)
str_aux = 'Pasabanda normalizado'
print(str_aux)
print('-' * len(str_aux))
this_lti = sig.TransferFunction(num_bp_n, den_bp_n)
