Laboratorio 3_2 PDS

Objetivo

● Conocer y manejar los filtros desde el punto de vista computacional

● Diseñar filtros FIR e IIR

Código de ética

Recuerde que existe el siguiente acuerdo de los estudiantes expuesto en el Sistema de Gestión del
Silabo Docente que dice:

Ser honesto, no copiar, no mentir

Además, está vigente el código de ética de la institución en la siguiente dirección

.https://usgn.espe.edu.ec/base-legal-espe/

Declaración

Declaro respetar y acatar el código de ética

Si x No

Instrucciones

1. Revisar el video Filtros digitales (que están en la página de classroom)

2. Revisar y ejecutar las prácticas del libro de Soria de las páginas 336-355. Los filtros
FIR son de la 336-348 y los IIR están en 348-355.
3. Reescribir el punto 2 usando Python y sus correspondientes librerías. En este caso,
contrastar los resultados generados con los dos programas para ver su similitud o
diferencia. ¿Qué programa elegiría para trabajar de aquí en adelante?. Justificar la
respuesta.
4. Revisar y hacer un resumen de los enlaces adjuntos (que están en la página de
classroom) y ejecutar los programas correspondientes en Python y anotar y comentar
los resultados que arrojan los programas.

Desarrollo:

1) En este video de Filtro Digitales, no habla sobre el concepto de un filtro digital, cabe
la redundancia, nos menciona que un filtro digital es un tipo de filtro que, a diferencia
de un filtro analógico o clásico, se implementa en software y no en hardware. Esto
implica una serie de ventajas y como consecuencia también desventajas que lo hace
ideal o no ideal dependiendo las situaciones a las que se exponga. (TutoElectro, 2020)

Alguna de sus ventajas y desventajas que tiene los filtros digitales:

 Ventajas:

• Son más versátiles

• Su respuesta puede ser lineal (FIR)
• Su respuesta a nivel practico puede ser mucho mejor
• Su respuesta no cambia con el tiempo

Desventajas:

• Se necesita digitalizar la señal

• Depende mucho de la velocidad de muestreo del ADC
• Se necesita un procesador un mucha mas potencia para que su respuesta sea
más veloz
• El coste de desarrollo puede ser más costoso.

2) Programas en Matlab de filtros FIR e IIR del libro de Soria

a) Estudio de la propiedades de los filtros FIR

CÓDIGO

b1 = [1 2 1 2 1];
b2 = [1 0 0 0 0 -1];
b3 = [1 6 11 6];

figure;
impz(b1,1);
grid on
xlabel('n')
ylabel('h1(n)')
figure;
z1=impz(b1,1);
grpdelay(z1)

figure;
impz(b2,1);
grid on
xlabel('n')
ylabel('h2(n)')
figure;
z2=impz(b2,1);
grpdelay(z2);

figure;
impz(b3,1);
grid on
xlabel('n')
ylabel('h3(n)')
figure;
z3=impz(b3,1);
grpdelay(z3)

RESULTADOS

Respuesta impulsional de 3 sistemas :

Retardo de los 3 sistemas anteriores:

CÓDIGO
%A)
fm=20000;
fc=5000;
N=20;
pto=1000;
br=fir1(N,2*fc/fm,boxcar(N+1));
bh=fir1(N,2*fc/fm,hamming(N+1));
[h,w]=freqz(br,1,pto,fm);
[h2,w]=freqz(bh,1,pto,fm);
ideal=ones(size(1:pto));
nfc=pto*2*fc/fm;
ideal(nfc:pto)=zeros(size(nfc:pto));
plot(w,ideal,'k')
hold on
plot(w,abs(h),'k--')
plot(w,abs(h2),'k:')
legend('F. Ideal','V. Rectangular','V. Hanning')
xlabel('Frecuencia (Hz)')
ylabel('|H(\omega)|')
disp('Pulse una tecla para continuar...')
pause;
axis(1000*[0 5.1152 0.0009 0.0011])

%B)
fm=20000;
fc=5000;
N=20;
pto=1000;
A=10:20:90; %Atenuaci_on en dB
for(i=1:length(A))
if(A(i)<=21)
beta=0;
elseif (A(i)>=50)
beta=0.1102*(A(i)-8.7);
else
beta=0.5842*(A(i)-21)^0.4+0.07886*(A(i)-21);
end
b=fir1(N,2*fc/fm,kaiser(N+1,beta));
[h(:,i),w]=freqz(b,1,pto,fm);
end
modulo=20*log10(abs(h));
figure;
plot(w,modulo(:,1),'k-',w,modulo(:,2),'k:',w,modulo(:,3),'k.-',...
w,modulo(:,4),'k--',w,modulo(:,5),'k-')
legend('A=10','A=30','N=50','A=70','A=90')

%C)
fm=20000;
fc=5000;
pto=1000;
A=60;
beta=0.1102*(A-8.7);
D=(A-7.95)/14.36;
BT=500:500:2000; %Anchura de la banda de transici_on
N=1+D*fm./(BT); %Determinanos el orden para diversos valores de BR
N=ceil(N); %Redondeamos el orden por exceso
for(i=1:length(N))
b=fir1(N(i),2*fc/fm,kaiser(N(i)+1,beta));
[h(:,i),w]=freqz(b,1,pto,fm);
end
modulo=20*log10(abs(h));
figure;
plot(w,modulo(:,1),'k-',w,modulo(:,2),'k:',...
w,modulo(:,3),'k.-',w,modulo(:,4),'k--')
legend('BT=500, N=146','BT=1000, N=74','BT=1500, N=50','BT=1500,
N=50','BT=2000, N=38')
grid

RESULTADOS
La función fir1 permite diseñar filtros digitales por el método de las ventanas
La ventana de Kaiser tiene la ventaja de permitir un control en el rizado.

Este resultado es similar al anterior de la ventana de Kaiser, pero con el parámetro

variable es la anchura de la banda de transición.
CÓDIGO

%Muestreo en frecuencia para filtros FIR de tipo I (orden impar

simétricos)
clear
fm=1000;
f1=200;
f2=250;
bt=f2-f1;
pto=1000;
nb=input('Número de puntos en la banda de transición: ');
delta=bt/nb; % Adem_as delta=pi/N --> obtenemos N
N=fm/delta;
if (rem(N,2)==0) %Aseguramos que el n_umero de t_erminos es impar
N=N+1;
end
delta=fm/N;
M=(N-1)/2;
%Muestreamos la respuesta en frecuencia equiespaciadamente
mp=round(0:f1/delta); %Muestras en banda pasante
mt=round(f1/delta)+1:round(f2/delta); %Muestras en banda de
transici_on
ma=round(f2/delta)+1:M; %Muestras en banda no pasante
A=[ones(size(mp)) mt*delta*(-1/bt)+f2/bt zeros(size(ma))];
%Función creada
h=impul(A);
subplot(211)
stem(h);
grid
xlabel('n')
ylabel('h(n)')
subplot(212)
[h,w]=freqz(h,1,pto,fm);
plot(w,abs(h));
hold on
stem((0:M)*delta,A,'r')
xlabel('Frecuencia (Hz)')
ylabel('|H(\omega)|')

RESULTADOS
Respuesta impulsional y respuesta en módulo para 1 muestra en la banda de
transición.

CÓDIGO
fm=1000; %Frecuencia de muestreo
RP=3; %Rizado en la banda pasante en DB
RS=20:5:100 %Rizado en la banda atenuada en DB sin signo
F1=200; %Inicio de la banda de transici_on
W=[1 0]; %Valores ideales del filtro
aa=10^(RP/20);
r1=(aa-1)/(aa+1); %Rizado en la banda pasante en escala lineal
r2=10.^(-RS/20); %Rizado en la banda atenuada en escala lineal
F2=220 ; %Fin de la banda de transici_on
for i=1:length(RS)
[n(i),fo,mo,w] = remezord( [F1 F2], W, [r1 r2(i)], fm );
end
plot(RS,n,'k*',RS,n,'k')
grid
xlabel('Rizado de la banda atenuada (dB)');
ylabel('Orden del filtro');

b = remez(n(i),fo,mo,w);
freqz(b,1,1024,fm)
 RESULTADOS

Respuesta en frecuencia en modulo y fase de un filtro FIR, con la aproximación

de Tchebyshev

b) Estudio de la propiedades de los filtros IIR

CÓDIGO

b=[1/4 0 0 0 -1/4];
a=[1 -1];

%Para dibujar el diagrama de polos y ceros hemos

% de introducir los coeficientes en potencias de Z
NUM=[1/4 0 0 0 -1/4]
DEN=[1 -1 0 0 0]

zplane(a,b)
disp('Pulse una tecla para continuar ...')
xlabel('Parte Real')
ylabel('Parte Imaginaria')

pause
[h,w]=freqz(NUM,DEN);
plot(w,abs(h));
%%resfre_mo(b,a,'l')
pause
plot(w,angle(h));
%%resfre_fa(b,a)
disp('Pulse una tecla para continuar ...')
pause
impz(b,a);
xlabel('n')
ylabel('h(n)')
disp('Pulse una tecla para continuar ...')
pause
disp('Se trata de un filtro FIR implementado de forma recursiva')

RESULTADOS
CÓDIGO
fm=1000;% frecuecia de muetreo
fc1=200;% frecuenciq de corte 1
Rp=2; %Rizado en la banda pasante en db
Rs=40; %Rizado en la banda atenuada en db
fc2=300; %Fc+anchura de la banda de trasnsicion

wp=2*pi*fc1;
ws=2*pi*fc2;
[n,wn]=buttord(wp,ws,Rp,Rs,'s');
[Z,P,K]=buttap(n);
[NUM,DEN]=zp2tf(Z,P,K);
[NUMT,DENT]=lp2lp(NUM,DEN,wp);
%figure;
%zplane(NUM,DEN);
% ahora la transformacion a digitos por el metodo del impulso invariable
[BZ,AZ]=impinvar(NUMT,DENT,fm);
% con la transformada bilineal
wpa=tan(wp/(2*fm))*2*fm;
wsa=tan(ws/(2*fm))*2*fm;
[n,wn]=buttord(wpa,wsa,Rp,Rs,'s');
[Z,P,K]=buttap(n);
[NUM,DEN]=zp2tf(Z,P,K);
[NUMT,DENT]=lp2lp(NUM,DEN,wp);
[NUMd,DENd]=bilinear(NUM,DEN,fm);

[n,wn]=buttord(2*fc1/fm,2*fc2/fm,Rp,Rs);
[B,A]=butter(n,wn);

Rs=40;
Rp=0.1:0.1:4;
for i=1:length(Rp)
[Nb(i),wn]=buttord(2*fc1/fm,2*fc2/fm,Rp(i),Rs);
[Nc1(i),wn]=cheb1ord(2*fc1/fm,2*fc2/fm,Rp(i),Rs);
[Nc2(i),wn]=cheb2ord(2*fc1/fm,2*fc2/fm,Rp(i),Rs);
[Ne(i),wn]=ellipord(2*fc1/fm,2*fc2/fm,Rp(i),Rs);
end
figure;
plot(Rp,Nb,'K-',Rp,Nc1,'k:',Rp,Nc2,'k.-',Rp,Ne,'k--')
legend('butterwirth','chevishev I','chevishev II','Eliptico')
xlabel('rizado en la banda pasante db')
ylabel('orden del filtro')
title('variacion del orden con Rp=40')
%clf
clear Nb,Nc1,Nc2,Ne;

Rp=2;
Rs=10:1:100;
for i=1:length(Rs)
[Nb(i),wn]=buttord(2*fc1/fm,2*fc2/fm,Rp,Rs(i));
[Nc1(i),wn]=cheb1ord(2*fc1/fm,2*fc2/fm,Rp,Rs(i));
[Nc2(i),wn]=cheb2ord(2*fc1/fm,2*fc2/fm,Rp,Rs(i));
[Ne(i),wn]=ellipord(2*fc1/fm,2*fc2/fm,Rp,Rs(i));
end
figure;
plot(Rs,Nb,'K-',Rs,Nc1,'k:',Rs,Nc2,'k.-',Rs,Ne,'k--')
legend('butterwirth','chevishev I','chevishev II','Eliptico')
xlabel('rizado en la banda pasante db')
ylabel('orden del filtro')
title('variacion del orden del filtro conRp=2')
clear all;

RESULTADOS
Modificación del orden de varios filtros IIR diseñados mediante la transformación
bilineal la variar la atenuación:

Modificación del orden de varios filtros IIR diseñados mediante la transformación

bilineal la variar el rizado de la banda pasante:
3) Programas del punto 2 en Python

a) Estudio de la propiedades de los filtros FIR

CÓDIGO
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal

# Primera respuesta en frecuencia H1(z)

b1 = [1, 2, 1, 2, 1]
# Segunda respuesta en frecuencia H2(z)
b2 = [1, 0, 0, 0, 0, -1]
# Tercera respuesta en frecuencia H3(z)
b3 = [1, 6, 11, 6]

# Con signal.ifilter() se obtiene la respuesta al impulso, es decir la

TZI de b1
# b2 y b3, cuando a su entrada x[n] = delta[n]

# Para b1
x = np.zeros(len(b1))
x[0] = 1
h = signal.lfilter(b1, 1, x)
w1, gd1 = signal.group_delay((b1, 1))
plt.plot(w1,gd1)
plt.grid()
plt.show()
plt.grid()
plt.xlabel('n')
plt.ylabel('h1(n)')
plt.stem(h)
plt.show()

# Para b2
x = np.zeros(len(b2))
x[0] = 1
h = signal.lfilter(b2, 1, x)
w2, gd2 = signal.group_delay((b2, 1))
plt.plot(w2,gd2)
plt.grid()
plt.show()
plt.grid()
plt.xlabel('n')
plt.ylabel('h2(n)')
plt.stem(h)
plt.show()

# Para b2
x = np.zeros(len(b3))
x[0] = 1
h = signal.lfilter(b3, 1, x)
w, gd = signal.group_delay((b3, 1))
plt.plot(w,gd)
plt.grid()
plt.show()
plt.grid()
plt.xlabel('n')
plt.ylabel('h3(n)')
plt.stem(h)
plt.show()

RESULTADOS
Respuesta impulsional de 3 sistemas :
Retardo de los 3 sistemas anteriores:

CÓDIGO

from scipy import signal

import matplotlib.pyplot as plt
import numpy as np
#Frecuencia de muestreo
fm = 20000
#Frecuencia de corte
fc = 5000
#Orden
N=20
#a)
#Ventana rectangular
br=signal.firwin(N+1,2*fc/fm,window='boxcar')
#Ventana hamming
bh=signal.firwin(N+1,2*fc/fm,window='hamming')
#Filtro con ventana rectangular
w, h =signal.freqz(br,[1],fm);
#Filtro con ventana hamming
w, h2 =signal.freqz(bh,[1],fm);
#Filtro ideal
ideal=np.ones(len(w))
nfc=int(len(w)*2*fc/fm)
ideal[nfc:len(w)]=np.zeros(len(w)-nfc)
#Representación gráfica
#Magnitud
plt.plot(w*fm/(2*np.pi),abs(h),'k--',label='V. rectangular')
plt.plot(w*fm/(2*np.pi),abs(h2),'k:',label='V. hamming')
plt.plot(w*fm/(2*np.pi),ideal,'k',label='F.Ideal')
plt.xlabel('$Frecuencia(Hz)$')
plt.ylabel('$|H(\omega)|$')
plt.legend()
plt.grid()
plt.axis([0,5000,0.9,1.1])
plt.show()
#Magnitud en dB
plt.plot(w*fm/(2*np.pi),20*np.log10(abs(h)),'k--',label='V. rectangular')
plt.plot(w*fm/(2*np.pi),20*np.log10(abs(h2)),'k:',label='V. hamming')
plt.xlabel('$Frecuencia(Hz)$')
plt.ylabel('$|H(\omega)|[dB]$')
plt.legend()
plt.grid()
plt.show()
#b)
#Ventana kaiser
#Atenuación en dB
A=np.arange(10,91,20)
h=np.empty((len(A), len(w)),dtype=complex)
#Condición de B según A
for i in range(len(A)):
if A[i]<=21:
beta=0
elif A[i]>=50:
beta=0.1102*(A[i]-8.7)
else:
beta=0.5842*(A[i]-21)*0.4+0.07886*(A[i]-21)
b=signal.firwin(N+1,2*fc/fm,window=('kaiser', beta))
w, h[i,:]=signal.freqz(b,[1],fm)
#Modulo en dB
modulo=20*np.log10(abs(h))
#Representación gráfica
plt.plot(w*fm/(2*np.pi),modulo[0,:],'k-',label='A=10')
plt.plot(w*fm/(2*np.pi),modulo[1,:],'k:',label='A=30')
plt.plot(w*fm/(2*np.pi),modulo[2,:],'k--',label='A=50')
plt.plot(w*fm/(2*np.pi),modulo[3,:],'k:',label='A=70')
plt.plot(w*fm/(2*np.pi),modulo[4,:],'k-',label='A=90')
plt.xlabel('$Frecuencia(Hz)$')
plt.ylabel('$|H(\omega)|[dB]$')
plt.legend()
plt.grid()
plt.show()
#c)
#Atenuación en la banda en dB
A=60
beta=0.1102*(A-8.7)
D=(A-7.95)/14.36
#Anchura de la banda de transicion
BT=np.arange(500,2001,500)
#Determinanos el orden para diversos valores de BR
N=1+D*fm/(BT)
#Redondeamos el orden por exceso
N=np.ceil(N)
h=np.empty((len(N), len(w)),dtype=complex)
#Filtros para distintos N
for i in range(len(N)):
b=signal.firwin(N[i]+1,2*fc/fm,window=('kaiser', beta))
w, h[i,:]=signal.freqz(b,[1],fm)
#Modulo en dB
modulo=20*np.log10(abs(h))
#Representación gráfica
plt.plot(w*fm/(2*np.pi),modulo[0,:],'k-',label='BT=500')
plt.plot(w*fm/(2*np.pi),modulo[1,:],'k:',label='BT=1000')
plt.plot(w*fm/(2*np.pi),modulo[2,:],'k--',label='BT=1500')
plt.plot(w*fm/(2*np.pi),modulo[3,:],'k:',label='BT=2000')
plt.xlabel('$Frecuencia(Hz)$')
plt.ylabel('$|H(\omega)|[dB]$')
plt.legend()
plt.grid()
plt.show()

RESULTADOS
La función fir1 permite diseñar filtros digitales por el método de las ventanas

La ventana de Kaiser tiene la ventaja de permitir un control en el rizado.

Este resultado es similar al anterior de la ventana de Kaiser, pero con el parámetro
variable es la anchura de la banda de transición.
CÓDIGO
import numpy as np
import matplotlib.pyplot as plt
import scipy
from scipy import signal

def impul(A):
M = np.max(len(A)) - 1
N = 2 * M + 1
x = np.zeros(M)
for i in range(0, M):
aux = A[0]
for k in range(2, M + 1):
aux = aux + 2 * A[k] * np.cos(2 * np.pi * (k - 1) * (i - M) / N)
x[i] = aux / N
y = np.zeros(len(x))
y = x[::-1]
x = np.append(x, y[:M + 1])

return x
# Muestreo en frecuencia para filtros FIR tipo I (orden impar simétricos)

fm = 1000
f1 = 200
f2 = 250

bt = f2 - f1
pto = 1000
nb = int(input('Número de puntos en la banda de trasnsición: '))
# Como delta = pi/N, entonce se obtiene N
delta = bt / nb
N = fm / delta
if (np.remainder(N, 2) == 0):
N = N + 1
delta = fm / N
M = (N - 1) / 2
# Se muestrea la respuesta en frecuencia de forma equiespaciada
mp = np.round(np.arange(0, f1 / delta)) # muestras en banda pasante
# muestras en banda de transición
mt = np.round(f1 / delta) + np.arange(1, np.round(f2 / delta) - 3)
# muestras en banda no pasante
ma = np.round(f2 / delta) + np.arange(1, M - 4)

A1 = np.append(np.ones(len(mp)), mt * delta * (-1 / bt) + f2 / bt)

A = np.append(A1, np.zeros(len(ma)))
# print(N)
# De la función creada
h = impul(A)

plt.subplot(211)
plt.stem(h)
plt.grid()
plt.xlabel('n')
plt.ylabel('h[n]')

plt.subplot(212)
w, h = signal.freqz(h, [1], fm)
plt.plot(w, np.abs(h))
# plt.stem(np.arange(0,M)*delta, A)
plt.xlabel('Frecuencia (Hz)')
plt.ylabel('|H(\omega)|')
plt.show()

RESULTADOS
CÓDIGO
from scipy import signal
import matplotlib.pyplot as plt
import numpy as np

def plot_response(fs, w, h, title):

"Utility function to plot response functions"
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(0.5*fs*w/np.pi, 20*np.log10(np.abs(h)))
ax.set_ylim(-100, 5)
ax.set_xlim(0, 0.5*fs)
ax.grid(True)
ax.set_xlabel('Frequency (Hz)')
ax.set_ylabel('Gain (dB)')
ax.set_title(title)
fs = 20000.0 # Sample rate, Hz
cutoff = 2300.0 # Desired cutoff frequency, Hz
f1 = 200 # Width of transition from pass band to stop band, Hz

numtaps = 400 # Size of the FIR filter.

taps = signal.remez(numtaps, [0, cutoff, cutoff + f1, 0.5*fs], [1, 0],
Hz=fs)
w, h = signal.freqz(taps, [1], worN=2000)
plot_response(fs, w, h, "Low-pass Filter")
plt.show()
 RESULTADO
Respuesta en frecuencia en modulo y fase de un filtro FIR, con la aproximación
de Tchebyshev

b) Estudio de la propiedades de los filtros IIR

CÓDIGO:

import matplotlib.pyplot as plt

import numpy as np
from math import pi
from scipy import signal
from scipy import zeros
from scipy.signal import lfilter

b = [1 / 4, 0, 0, 0, -1 / 4]
# np.array([1/4,0,0,0,-1/4])
a = [1, -1]
# np.array([1,-1])

w1, v1 = signal.freqz(b, a)
plt.rcParams["figure.figsize"] = (14, 8)
plt.plot(w1, abs(v1))
plt.show()
plt.plot(w1, np.angle(v1))
z1, p1, k1 = signal.tf2zpk(b, a)
plt.show()
print(len(p1))
theta = np.linspace(-pi, pi, 201)
plt.rcParams["figure.figsize"] = (10, 10)
plt.plot(np.cos(theta), np.sin(theta))

def pinta(z11, p11):

plt.scatter(np.real(z11), np.imag(z11))
plt.scatter(np.real(p11), np.imag(p11))
plt.show()

pinta(z1, p1)
def impz(b, a):
"""Pseudo implementation of the impz method of MATLAB"""
p = np.roots(a)
N = stableNmarginal_length(p, 0.00005, 0)
N = len(b) * len(b) * len(b) # MATLAB AUTOFINDS THE SIZE HERE...

x = zeros(N)
x[0] = 1
h = lfilter(b, a, x)

n = np.arange(0, 125)
plt.stem(n, h)

plt.xlim(0, 9)
# plt.show()
return h
impz([1 / 4, 0, 0, 0, -1 / 4], [1, -1, 0, 0, 0])

RESULTADOS:
CÓDIGO
import matplotlib.pyplot as plt
import numpy as np
from math import pi
from scipy import signal

fm = 1000 # frecuecia de muetreo

fc1 = 200 # frecuenciq de corte 1
Rp = 2 # Rizado en la banda pasante en db
Rs = 40 # Rizado en la banda atenuada en db
fc2 = 300 # Fc+anchura de la banda de trasnsicion
wp = 2 * pi * fc1
ws = 2 * pi * fc2
n, w1 = signal.buttord(wp, ws, Rp, Rs, 's')
Z, P, K = signal.buttap(n)
NUM, DEN = signal.zpk2tf(Z, P, K)
NUMT, DENT = signal.lp2lp(NUM, DEN, wp)
BZ, AZ = signal.bilinear(NUMT, DENT, fm)
wpa = np.tan(wp / (2 * fm)) * 2 * fm
wsa = np.tan(ws / (2 * fm)) * 2 * fm
[n, wn] = signal.buttord(wpa, wsa, Rp, Rs, 's')
[Z, P, K] = signal.buttap(n)
NUM, DEN = signal.zpk2tf(Z, P, K)
[NUMT, DENT] = signal.lp2lp(NUM, DEN, wp)
[NUMd, DENd] = signal.bilinear(NUM, DEN, fm)
# ----------------------
[n, wn] = signal.buttord(2 * fc1 / fm, 2 * fc2 / fm, Rp, Rs)
[B, A] = signal.butter(n, wn)
Rs = 40
Rp = np.arange(0.1, 4, 0.1)

Nb = np.arange(len(Rp))
Nc1 = np.arange(len(Rp))
Nc2 = np.arange(len(Rp))
Ne = np.arange(len(Rp))
for i in range(0, len(Rp)):
[Nb[i], wn] = signal.buttord(2 * fc1 / fm, 2 * fc2 / fm, Rp[i], Rs)
[Nc1[i], wn] = signal.cheb1ord(2 * fc1 / fm, 2 * fc2 / fm, Rp[i], Rs)
[Nc2[i], wn] = signal.cheb2ord(2 * fc1 / fm, 2 * fc2 / fm, Rp[i], Rs)
[Ne[i], wn] = signal.ellipord(2 * fc1 / fm, 2 * fc2 / fm, Rp[i], Rs)

plt.plot(Rp, Nb, Rp, Nc1, Rp, Nc2, Rp, Ne)

plt.legend(['butterwirth','chevishev II','Eliptico'])
plt.xlabel('rizado en la banda pasante db')
plt.ylabel('orden del filtro')
plt.grid('on')
plt.show()

plt.clf()

Rp = 2
Rs = np.arange(10, 100, 1)
Nb = np.arange(len(Rs))
Nc1 = np.arange(len(Rs))
Nc2 = np.arange(len(Rs))
Ne = np.arange(len(Rs))
for i in range(0, len(Rs)):
[Nb[i], wn] = signal.buttord(2 * fc1 / fm, 2 * fc2 / fm, Rp, Rs[i])
[Nc1[i], wn] = signal.cheb1ord(2 * fc1 / fm, 2 * fc2 / fm, Rp, Rs[i])
[Nc2[i], wn] = signal.cheb2ord(2 * fc1 / fm, 2 * fc2 / fm, Rp, Rs[i])
[Ne[i], wn] = signal.ellipord(2 * fc1 / fm, 2 * fc2 / fm, Rp, Rs[i])

plt.plot(Rs, Nb, Rs, Nc1, Rs, Nc2, Rs, Ne)

plt.legend(['butterwirth','chevishev II','Eliptico'])
plt.xlabel('rizado en la banda pasante db')
plt.ylabel('orden del filtro')
plt.grid('on')
plt.show()

RESULTADOS

Modificación del orden de varios filtros IIR diseñados mediante la transformación

bilineal la variar la atenuación:
 Modificación del orden de varios filtros IIR diseñados mediante la transformación
bilineal la variar el rizado de la banda pasante:

4) Resumen y programas de los enlaces adjuntos en classroom

a) Filtro Butterworth de paso bajo digital

En este punto vamos a ver como diseñar un filtro Butterworth. El filtro Butterworth
es un tipo de filtro de procesamiento de señal diseñado para tener una respuesta
de frecuencia lo más plana posible en la banda de paso. Se va a realizar el diseño
con las siguientes especificaciones:

• Frecuencia de muestreo de 40 kHz

• Frecuencia de borde de banda de paso de 4 kHz
• Frecuencia de borde de banda de parada de 8 kHz
• Ondulación de banda de paso de 0,5 dB
• Atenuación mínima de la banda de parada de 40 dB

Código en Python (sagnikmukherjee2, 2020):

# Importacion de librerias
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal
import math

# Especificaciones del filtro

# Frecuencia de muestreo
f_sample = 40000
# frecuencia de banda de paso
f_pass = 4000
# frecuencia de banda de parada
f_stop = 8000
# ondulación de la banda de paso
fs = 0.5
# pass band freq in radian
wp = f_pass / (f_sample / 2)
# stop band freq in radian
ws = f_stop / (f_sample / 2)

# Tiempo de muestreo
Td = 1
# ondulación de la banda de paso
g_pass = 0.5
# Atenuacion de la banda
g_stop = 40

# Conversión a frecuencia analógica envuelta previamente

omega_p = (2 / Td) * np.tan(wp / 2)
omega_s = (2 / Td) * np.tan(ws / 2)

# Diseño de filtro usando la función signal.buttord

N, Wn = signal.buttord(omega_p, omega_s, g_pass, g_stop, analog=True)
print("Order of the Filter=", N) # N is the order
# Wn es la frecuencia de corte del filtro
print("Cut-off frequency= {:.3f} rad/s ".format(Wn))

# Conversión en dominio Z

# b es el numerador del filtro & a es el denominador

b, a = signal.butter(N, Wn, 'low', True)
z, p = signal.bilinear(b, a, fs)
# w es la frecuencia en el dominio z & h es la magnitud en el dominio z
w, h = signal.freqz(z, p, 512)

# Respuesta de magnitud
plt.semilogx(w, 20*np.log10(abs(h)))
plt.xscale('log')
plt.title('Butterworth filter frequency response')
plt.xlabel('Frequency [Hz]')
plt.ylabel('Amplitude [dB]')
plt.margins(0, 0.1)
plt.grid(which='both', axis='both')
plt.axvline(100, color='green')
plt.show()

# Respuesta la impulso
imp = signal.unit_impulse(40)
c, d = signal.butter(N, 0.5)
response = signal.lfilter(c, d, imp)

plt.stem(np.arange(0, 40), imp, use_line_collection=True)

plt.stem(np.arange(0, 40), response, use_line_collection=True)
plt.margins(0, 0.1)

plt.xlabel('Time [samples]')
plt.ylabel('Amplitude')
plt.grid(True)
plt.show()

# Respuesta de fase
fig, ax1 = plt.subplots()
ax1.set_title('Digital filter frequency response')
ax1.set_ylabel('Angle(radians)', color='g')
ax1.set_xlabel('Frequency [Hz]')
angles = np.unwrap(np.angle(h))
ax1.plot(w / 2 * np.pi, angles, 'g')
ax1.grid()
ax1.axis('tight')
plt.show()
Resultados

Respuesta de frecuencia del filtro Butterworth (Magnitud):

Figura 1 Respuesta en frecuencia

Como se puede ver en la Figura 1, es casi igual al filtro ideal, deja pasar bajas
frecuencias con respecto a la frecuencia de corte.

En la siguiente figura 2, se puede observar el orden y la frecuencia de corte del

filtro:

Figura 2 Orden y frecuencia de corte

A continuación, en la Figura 3 se presenta la respuesta al impulso que nos genera

este filtro Butterworth de paso bajo digital.

Figura 3 Respuesta al impulso

 Una vez hallada la respuesta de magnitud, también se halla la respuesta en fase
del filtro.

Figura 4 Respuesta de fase del filtro

b) Diseñe el filtro Chebyshev Tipo 1 de paso de banda IIR utilizando Scipy

IIR Chebyshev es un filtro que es un filtro invariante de tiempo lineal al igual que
el Butterworth, sin embargo, tiene una caída más pronunciada en comparación
con el filtro Butterworth.

Chebyshev Type-I minimiza la diferencia absoluta entre la respuesta de frecuencia

ideal y real en toda la banda de paso incorporando una ondulación igual en la
banda de paso.

El filtro Chebyshev se clasifica además como Chebyshev Tipo-I y Chebyshev Tipo-

II de acuerdo con parámetros tales como ondulación de banda de paso y
ondulación de parada.

Código en Python (sagnikmukherjee2, 2020):

# import required library

import numpy as np
import scipy.signal as signal
import matplotlib.pyplot as plt

def mfreqz(b, a, Fs):

wz, hz = signal.freqz(b, a)

# Calculate Magnitude from hz in dB

Mag = 20 * np.log10(abs(hz))
# Calculate phase angle in degree from hz
Phase = np.unwrap(np.arctan2(np.imag(hz), np.real(hz))) * (180 / np.pi)
# Calculate frequency in Hz from wz
Freq = wz * Fs / (2 * np.pi)
# Plot filter magnitude and phase responses using subplot.
 fig = plt.figure(figsize=(10, 6))

# Plot Magnitude response

sub1 = plt.subplot(2, 1, 1)
sub1.plot(Freq, Mag, 'r', linewidth=2)
sub1.axis([1, Fs / 2, -100, 5])
sub1.set_title('Magnitute Response', fontsize=20)
sub1.set_xlabel('Frequency [Hz]', fontsize=20)
sub1.set_ylabel('Magnitude [dB]', fontsize=20)
sub1.grid()

# Plot phase angle

sub2 = plt.subplot(2, 1, 2)
sub2.plot(Freq, Phase, 'g', linewidth=2)
sub2.set_ylabel('Phase (degree)', fontsize=20)
sub2.set_xlabel(r'Frequency (Hz)', fontsize=20)
sub2.set_title(r'Phase response', fontsize=20)
sub2.grid()
plt.subplots_adjust(hspace=0.5)
fig.tight_layout()
plt.show()

def impz(b, a):

# Define the impulse sequence of length 60
impulse = np.repeat(0., 60)
impulse[0] = 1.
x = np.arange(0, 60)
# Compute the impulse response
response = signal.lfilter(b, a, impulse)

# Plot filter impulse and step response:

fig = plt.figure(figsize=(10, 6))
plt.subplot(211)
plt.stem(x, response, 'm', use_line_collection=True)
plt.ylabel('Amplitude', fontsize=15)
plt.xlabel(r'n (samples)', fontsize=15)
plt.title(r'Impulse response', fontsize=15)

plt.subplot(212)
step = np.cumsum(response) # Compute step response of the system
plt.stem(x, step, 'g', use_line_collection=True)
plt.ylabel('Amplitude', fontsize=15)
plt.xlabel(r'n (samples)', fontsize=15)
plt.title(r'Step response', fontsize=15)
plt.subplots_adjust(hspace=0.5)

fig.tight_layout()
plt.show()

# Given specification
Fs = 7000 # Sampling frequency in Hz
fp = np.array([1400, 2100]) # Pass band frequency in Hz
fs = np.array([1050, 2450]) # Stop band frequency in Hz
Ap = 0.4 # Pass band ripple in dB
As = 50 # stop band attenuation in dB

# Compute pass band and stop band edge frequencies

wp = fp / (Fs / 2) # Normalized passband edge frequencies w.r.t. Nyquist
rate
ws = fs / (Fs / 2) # Normalized stopband edge frequencies
N, wc = signal.cheb1ord(wp, ws, Ap, As)

# Print the order of the filter and cutoff frequencies

print('Order of the filter=', N)
print('Cut-off frequency=', wc)
z, p = signal.cheby1(N, Ap, wc, 'bandpass')

# Print numerator and denomerator coefficients of the filter

print('Numerator Coefficients:', z)
print('Denominator Coefficients:', p)

mfreqz(z, p, Fs)
impz(z, p)

Resultados

Como primera grafica la respuesta de magnitud y fase, las cuales responden a las
especificaciones planteadas al principio del diseño del filtro.

Figura 5 Respuesta de Magnitud y Fase

Esto se puede comprobar con el programa, imprimiendo el orden y la frecuencia

de corte del filtro.

Como se puede notar existe 2 frecuencias de corte, debido a que es un filtro pasa
banda, por lo tanto, son las frecuencias de corte superior e inferior
respectivamente.
 Figura 6 Respuesta al impulso y escalón

Además, el filtro Chebyshev Tipo 1 en Python nos presenta la respuesta al impulso y

al escalón.

c) Diseñe un filtro Chebyshev tipo 2 de paso de banda IIR utilizando Scipy

IIR Chebyshev es un filtro invariante de tiempo lineal al igual que el Butterworth,

sin embargo, tiene una caída más pronunciada en comparación con el filtro
Butterworth.

Chebyshev Tipo 2 minimiza la diferencia absoluta entre la respuesta de frecuencia

ideal y real en toda la banda de supresión incorporando una ondulación igual en
la banda de supresión, en comparación del Chebyshev tipo 1

El diseño que se va a realizar en Python va a tener las siguientes especificaciones:

• Frecuencia de banda de paso: 1400-2100 Hz
• Frecuencia de banda de parada: 1050-24500 Hz
• Ondulación de la banda de paso: 0.4dB
• Detener la atenuación de la banda: 50 dB Frecuencia de muestreo: 7 kHz

Código en Python (sagnikmukherjee2, 2020):

# import required library
import numpy as np
import scipy.signal as signal
import matplotlib.pyplot as plt

def mfreqz(b, a, Fs):

wz, hz = signal.freqz(b, a)
# Calculate Magnitude from hz in dB
Mag = 20 * np.log10(abs(hz))
# Calculate phase angle in degree from hz
 Phase = np.unwrap(np.arctan2(np.imag(hz), np.real(hz))) * (180 / np.pi)
# Calculate frequency in Hz from wz
Freq = wz * Fs / (2 * np.pi)
# Plot filter magnitude and phase responses using subplot.
fig = plt.figure(figsize=(10, 6))
# Plot Magnitude response
sub1 = plt.subplot(2, 1, 1)
sub1.plot(Freq, Mag, 'r', linewidth=2)
sub1.axis([1, Fs / 2, -100, 5])
sub1.set_title('Magnitute Response', fontsize=20)
sub1.set_xlabel('Frequency [Hz]', fontsize=20)
sub1.set_ylabel('Magnitude [dB]', fontsize=20)
sub1.grid()
# Plot phase angle
sub2 = plt.subplot(2, 1, 2)
sub2.plot(Freq, Phase, 'g', linewidth=2)
sub2.set_ylabel('Phase (degree)', fontsize=20)
sub2.set_xlabel(r'Frequency (Hz)', fontsize=20)
sub2.set_title(r'Phase response', fontsize=20)
sub2.grid()
plt.subplots_adjust(hspace=0.5)
fig.tight_layout()
plt.show()

def impz(b, a):

# Define the impulse sequence of length 60
impulse = np.repeat(0., 60)
impulse[0] = 1.
x = np.arange(0, 60)

# Compute the impulse response

response = signal.lfilter(b, a, impulse)

# Plot filter impulse and step response:

fig = plt.figure(figsize=(10, 6))
plt.subplot(211)
plt.stem(x, response, 'm', use_line_collection=True)
plt.ylabel('Amplitude', fontsize=15)
plt.xlabel(r'n (samples)', fontsize=15)
plt.title(r'Impulse response', fontsize=15)
plt.subplot(212)
step = np.cumsum(response)

# Compute step response of the system

plt.stem(x, step, 'g', use_line_collection=True)
plt.ylabel('Amplitude', fontsize=15)
plt.xlabel(r'n (samples)', fontsize=15)
plt.title(r'Step response', fontsize=15)
plt.subplots_adjust(hspace=0.5)
fig.tight_layout()
plt.show()

# Given specification
# Sampling frequency in Hz
Fs = 7000
# Pass band frequency in Hz
fp = np.array([1400, 2100])
# Stop band frequency in Hz
fs = np.array([1050, 2450])
# Pass band ripple in dB
Ap = 0.4
# Stop band attenuation in dB
As = 50

# Normalized passband edge frequencies w.r.t. Nyquist rate

wp = fp / (Fs / 2)
# Normalized stopband edge frequencies
ws = fs / (Fs / 2)
# Compute order of the Chebyshev type-2
# digital filter using signal.cheb2ord
N, wc = signal.cheb2ord(wp, ws, Ap, As)

# Print the order of the filter and cutoff frequencies

print('Order of the filter=', N)
print('Cut-off frequency=', wc)

# Design digital Chebyshev type-2 bandpass

# filter using signal.cheby2 function
z, p = signal.cheby2(N, As, wc, 'bandpass')

# Print numerator and denomerator coefficients of the filter

print('Numerator Coefficients:', z)
print('Denominator Coefficients:', p)

mfreqz(z, p, Fs)
impz(z, p)

Resultados

Como primera grafica la respuesta de magnitud y fase, las cuales responden a las
especificaciones planteadas al principio del diseño del filtro.

Figura 5 Respuesta en frecuencia y fase respectivamente

Esto se puede comprobar con el programa, imprimiendo el orden y la frecuencia

de corte del filtro.
 Como se puede notar existe 2 frecuencias de corte, debido a que es un filtro pasa
banda, por lo tanto, son las frecuencias de corte superior e inferior
respectivamente.

Y al igual que el filtro Chebyshev tipo 1, este filtro Chebyshev tipo 2 nos presenta
la respuesta al escalón e impulso, como se ve en la Figura 6.

Figura 6 Respuesta al impulso y escalón

Conclusiones

• Mediante el estudio de los filtros digitales FIR e IIR y su verificación de funcionamiento

mediante programas como Matlab y Python, se puedo llegar a observar su
comportamiento ante una señal cualquiera, esto nos ayuda a fortalecer el
conocimiento adquirido en clase.
• A través de la realización de este trabajo, pudimos darnos cuenta la dificultad que
tiene el diseño de cada filtro, pero llegamos a una conclusión que es, que el filtro digital
IIR es mucho más complejo en su diseño, ya que este depende mucho de valores de
salida pasado, lo que hace que su diseño se complique un poco, pero con ventajas o
una mayor efectividad al rato de procesar una señal
Recomendación

Debemos tener en cuenta que los 2 programas utilizados en esta tarea que son Matlab
y Python tienen sus diferencia al rato de realizar los programas, ya que cada uno lleva
su sintaxis propia, y al rato de querer realizar un programa hecho en Matlab en Python,
tenemos que cambiar la forma de programación, para obtener similares resultados.

Bibliografía

• Python. (2001). Obtenido de Python: https://www.python.org/

• sagnikmukherjee2. (08 de 12 de 2020). geeksforgeeks. Obtenido de geeksforgeeks:
https://www.geeksforgeeks.org/digital-low-pass-butterworth-filter-in-python/
• TutoElectro. (05 de 03 de 2020). Youtube. Obtenido de Youtube:
https://www.youtube.com/watch?v=VuqkLfI-EFE