Paginas pds

http://www.tecnun.es/asignaturas/tratamiento%20digital/tds5.html
Prototipos Filtro Pasobajo
Butterworth
% Especificaciones en Hz
fp = [10000 20000]; fs = [2000 35000]; Ap = 1; As = 40;
% Frecuencia de muestreo
fm = 100e3;
% Convertir a rad/s
wp = 2*pi*fp;
ws = 2*pi*fs;
% Predistorsion
wp = 2*tan(wp/(2*fm));
ws = 2*tan(ws/(2*fm));
% Frecuencia Central
wx2 = wp(1)*wp(2); wx = sqrt(wx2);
% Mantengo las espec. de pasabanda y recalculo las de parabanda
if (ws(1)*ws(2) < wx2) ws(1) = wx2/ws(2); else ws(2) = wx2/ws(1); end
% Conversion a espec de prototipo filtro pasobajo
wp_p = wp(2)-wp(1);
ws_p = ws(2)-ws(1);
% Calculo e2
e2 = 1/(10^(0.1*As)-1)
% Calculo del orden del filtro de Chebyshev II
n = acosh(sqrt(1/((10^(0.1*Ap)-1)*e2)))/acosh(ws_p/wp_p);
n = ceil(n);
% Prototipo de filtro pasobajo Chebyshev II
[Z,P,K] = cheb2ap(n,As)
[B,A] = zp2tf(Z,P,K)
% Conversion a pasabanda
% En Bw se pone ws_p porque Cheb2 normaliza con respecto a parabanda
[Bbp, Abp] = lp2bp(B,A,wx,ws_p);
% Vector de frecuencias para calcular resp. freq. (en rad/s)
W = 0:999; W = W*2*pi*fs(2)*1.5/1000;
H = freqs(Bbp, Abp, W);
% En db
Hdb = 20*log10(abs(H));
figure; plot(W/(2*pi), Hdb, [fp fs], -[Ap Ap As As],'r*'); hold
% Transformacion Bilineal
[Bd, Ad] = bilinear(Bbp, Abp, 1);

% Resp freq del filtro digital
[Hd, f] = freqz(Bd,Ad,1000, fm);
Hd_db = 20*log10(abs(Hd));
plot(f, Hd_db,'r--');
Chebyshev-I:
%% Ejemplo de filtro pasobajo de Chebyshev-I analógico
clear all;
fp=20e3;wp=2*pi*fp;
Ap=0.5;
fs=90e3;ws=2*pi*fs;
As=50;
% Calculo de e2
e2 = 10^(0.1*Ap)-1;
% Orden del filtro
n = acosh(sqrt((10^(0.1*As)-1)/e2))/acosh(fs/fp);
n = ceil(n);
% Parámetros para el cálculo de los polos y ceros del filtro
theta = (1/n)*asinh(1/sqrt(e2));
k=1:n;
alpha = (2*k-1)*pi/(2*n);
% Determinacion de los polos en el prototipo
pk = -sinh(theta)*sin(alpha) +j*cosh(theta)*cos(alpha);
[B,A]=zp2tf([],pk,1);
% Ajustar ganancia para que |H(0)|=1
if rem(n,2)==0
K=A(length(A))*(1/sqrt(1+e2));
else
K=A(length(A));
end
[B1,A1] = lp2lp(K*B,A,wp);
N=500;
wf=2*pi*100e3;
W=0:wf/N:wf;
H=freqs(B1,A1,W);
subplot(1,2,1); plot(W/(2*pi),20*log10(abs(H)));grid;
ylabel(['|H(w)|']);
xlabel(['Frecuencia (Hz)']);
ylabel(['|H(w)|']);
axis([0 1*fp -Ap-0.1 0.1]);
print -depsc2 cheb1_ej
pause;close;

%% Calcular el retraso de grupo
dW=W(2)-W(1);
phase=unwrap(angle(H));
dphase = -diff(phase)/dW;
plot(W(1:length(W)-1)/(2*pi),dphase);grid;
ylabel(['Retraso de Grupo (s)']);
print -depsc2 cheb1_groupdelay_ej
pause;close;
plot(pk,'x');axis([-1.1 0 -1.1 1.1]);axis equal;
Chebyshev-II:
%% Ejemplo de filtro pasobajo de Chebyshev-II analógico
clear all;
fp=20e3;wp=2*pi*fp;
Ap=0.5;
fs=90e3;ws=2*pi*fs;
As=50;
% Cálculo de e2
e2 = 1/(10^(0.1*As)-1);
% Orden de filtro
n = acosh(sqrt(1/((10^(0.1*Ap)-1)*e2)))/acosh(fs/fp);
n = ceil(n);
% Parámetros para el cálculo de polo y ceros
k=1:n;
alpha = (2*k-1)*pi/(2*n);
% Determinacion de los polos y los ceros en el prototipo
pk = 1./(-sinh(theta)*sin(alpha) +j*cosh(theta)*cos(alpha));
k = 1:n/2;
phi = (2*k-1)*pi/(2*n);
zk = [j./cos(phi) -j./cos(phi)];
[B,A]=zp2tf(zk',pk',1);
K=A(length(A))/B(length(B));
[B1,A1] = lp2lp(K*B,A,ws);
N=500;
wf=2*pi*100e3;
W=0:wf/N:wf;
H=freqs(B1,A1,W);
ylabel(['|H(w)|']);
ylabel(['|H(w)|']);

axis([0 1.1*fp -Ap-0.1 0.1]);
print -depsc2 cheb2_ej
pause;
close;
% Retraso de grupo
dW=W(2)-W(1);
phase=unwrap(angle(H));
grpdelay = -diff(phase)/dW;
%% Eliminar valores negativos (discontinuadades)
idx = find(grpdelay<0);
grpdelay(idx) = grpdelay(idx-1);
plot(W(1:length(W)-1)/(2*pi),grpdelay);grid;
print -depsc2 cheb2_groupdelay_ej
pause;close;
plot(pk,'x');axis([-1.1 0 -1.1 1.1]);axis equal;
Filtro paso alto
Butterworth:
%% Ejemplo filtro pasoalto de butterworth analógico
clear all;
% Especif.
fp=90e3;
Ap=0.5;
fs=20e3;
As=50;
%% Convertir filtro a pasobajo
wp = 2*pi*fp;
ws = 2*pi*fs;
wlpp = 1/wp;
wlps = 1/ws;
e2 = 10^(0.1*Ap)-1;
n = log(sqrt((10^(0.1*As)-1)/e2))/log(wlps/wlpp);
n = ceil(n);
wc = 1/(wlpp/(e2^(1/(2*n))));
k=1:n;
alpha = (2*k-1)*pi/(2*n);
pk = -sin(alpha) +j*cos(alpha);
[B,A]=zp2tf([],pk,1);
% Conversión a pasoalto
[B1,A1] = lp2hp(B,A,wc);
N=500;
wf=2*pi*110e3;
% Respuesta Frecuencial
W=(5:N-1)*wf/N;

H1=freqs(B1,A1,W);
subplot(3,1,1); plot(W/(2*pi),20*log10(abs(H1)));grid;
ylabel(['|H(w)|']);
subplot(3,1,2); plot(W/(2*pi),unwrap(angle(H1)));grid;
ylabel(['Fase H(w) (rad)']);
% Retraso de grupo
dW=W(2)-W(1);
phase=unwrap(angle(H1));
subplot(3,1,3);plot(W(1:length(W)-1)/(2*pi),dphase);grid;
print -depsc2 hp_butter_ej
Chebyshev-I:
%% Ejemplo filtro pasoalto de chebyshev-I analógico
clear all;
% Especif.
fp=90e3;
Ap=0.5;
fs=20e3;
As=50;
wp = 2*pi*fp;
ws = 2*pi*fs;
wlpp = 1/wp;
wlps = 1/ws;
e2 = 10^(0.1*Ap)-1;
n = acosh(sqrt((10^(0.1*As)-1)/e2))/acosh(wlps/wlpp);
n = ceil(n);
wc = 1/wlpp;
theta=(1/n)*asinh(1/sqrt(e2));
k=1:n;
alpha = (2*k-1)*pi/(2*n);
pk = -sinh(theta)*sin(alpha) +j*cosh(theta)*cos(alpha);
[B,A]=zp2tf([],pk,1);
%% Ajustar ganancia
if (rem(n,2)==0)
K = A(length(A))/sqrt(1+e2);
else
K = A(length(A));
end

[B1,A1] = lp2hp(K*B,A,wc);
N=500;
wi=2*pi*5e3;
wf=2*pi*110e3;
W=wi:(wf-wi)/N:wf;
H1=freqs(B1,A1,W);
% Retraso de grupo
dW=(wf-wi)/N;
axis([0 wf/(2*pi) 0 inf]);
ylabel(['|H(w)|']);
print -depsc2 hp_cheb1_ej
Chebyshev-II:
%% Ejemplo filtro pasoalto de chebyshev-II analógico
clear all;
% Especif.
fp=90e3;
Ap=0.5;
fs=20e3;
As=50;
wp = 2*pi*fp;
ws = 2*pi*fs;
wlpp = 1/wp;
wlps = 1/ws;
e2 = 1/(10^(0.1*As)-1);
n = acosh(sqrt(1/(10^(0.1*Ap)-1)/e2))/acosh(wlps/wlpp);
n = ceil(n);
wc = 1/wlps;
theta=(1/n)*asinh(1/sqrt(e2));
k=1:n;
alpha = (2*k-1)*pi/(2*n);
pk = 1./(-sinh(theta)*sin(alpha) +j*cosh(theta)*cos(alpha));
k = 1:n/2;

phi = (2*k-1)*pi/(2*n);
%% Ajustar ganancia
K = A(length(A))/B(length(B));
[B1,A1] = lp2hp(K*B,A,wc);
N=500;
wi=2*pi*5e3;
wf=2*pi*110e3;
W=wi:(wf-wi)/N:wf;
H1=freqs(B1,A1,W);
% Retraso de grupo
dW=(wf-wi)/N;
ylabel(['|H(w)|']);
print -depsc2 hp_cheb2_ej
Filtro pasabanda
Butterworth:
%% Ejemplo filtro pasabanda de butterworth analógico
clear all;
% Especif.
fp1=45e3;fp2=90e3;
Ap=0.5;
fs1=20e3;fs2=150e3;
As=50;
wp1 = 2*pi*fp1;
wp2 = 2*pi*fp2;
ws1 = 2*pi*fs1;
ws2 = 2*pi*fs2;
%% Fijamos frecuencias de pasabanda
wx2 = wp1*wp2;
if (ws1*ws2 < wx2)
ws1 = wx2/ws2;

else
ws2 = wx2/ws1;
end
wlpp = wp2-wp1;
wlps = ws2-ws1;
%% Prototipo Pasobajo
% Calculo de e2
e2 = 10^(0.1*Ap)-1;
% Orden del filtro
n = ceil(n);
% Frecuencia de corte
wc = wlpp/(e2^(1/(2*n)));
k=1:n;
alpha = (2*k-1)*pi/(2*n);
[B,A]=zp2tf([],pk,1);
[B1,A1] = lp2bp(B,A,sqrt(wx2),wc);
N=500;
wf=2*pi*160e3;
W=(5:N-1)*wf/N;
H1=freqs(B1,A1,W);
ylabel(['|H(w)|']);
% Retraso de grupo
dW=W(2)-W(1);
print -depsc2 bp_butter_ej
Chebyshev-I:
%% Ejemplo filtro pasabanda de chebyshev-I analógico
clear all;
% Especif.
fp1=45e3;fp2=90e3;
Ap=0.5;
fs1=20e3;fs2=150e3;

As=50;
wp1 = 2*pi*fp1;
wp2 = 2*pi*fp2;
ws1 = 2*pi*fs1;
ws2 = 2*pi*fs2;
wx2 = wp1*wp2;
if (ws1*ws2 < wx2)
ws1 = wx2/ws2;
else
ws2 = wx2/ws1;
end
wlpp = wp2-wp1;
wlps = ws2-ws1;
% Calculo de e2
e2 = 10^(0.1*Ap)-1;
% Orden del filtro
n = ceil(n);
wc = wlpp;
k=1:n;
alpha = (2*k-1)*pi/(2*n);
pk = -sinh(theta)*sin(alpha) + j*cosh(theta)*cos(alpha);
[B,A]=zp2tf([],pk,1);
%% Determinacion de la ganancia K
if (rem(n,2)==0)
K=A(length(A))/sqrt(1+e2);
else
K=A(length(A));
end
[B1,A1] = lp2bp(K*B,A,sqrt(wx2),wc);
N=500;
wf=2*pi*160e3;
W=(5:N-1)*wf/N;
H1=freqs(B1,A1,W);

ylabel(['|H(w)|']);
% Retraso de grupo
dW=W(2)-W(1);
print -depsc2 bp_cheb1_ej
Chebyshev-I:
%% Ejemplo filtro pasabanda de chebyshev-II analógico
clear all;
% Especif.
fp1=45e3;fp2=90e3;
Ap=0.5;
fs1=20e3;fs2=150e3;
As=50;
wp1 = 2*pi*fp1;
wp2 = 2*pi*fp2;
ws1 = 2*pi*fs1;
ws2 = 2*pi*fs2;
%% Fijamos frecuencias de parabanda
wx2 = ws1*ws2;
if (wp1*wp2 > wx2)
wp1 = wx2/wp2;
else
wp2 = wx2/wp1;
end
wlpp = wp2-wp1;
wlps = ws2-ws1;
% Calculo de e2
e2 = 1/(10^(0.1*As)-1);
% Orden del filtro
n = ceil(n);
wc = wlps;
k=1:n;
alpha = (2*k-1)*pi/(2*n);

% Determinacion de los polos y ceros en el prototipo
pk = 1./(-sinh(theta)*sin(alpha) + j*cosh(theta)*cos(alpha));
zk = -j./cos(alpha);
%% Determinacion de la ganancia K
K=A(length(A))/B(length(B));
[B1,A1] = lp2bp(K*B,A,sqrt(wx2),wc);
N=500;
wf=2*pi*160e3;
W=(5:N-1)*wf/N;
H1=freqs(B1,A1,W);
axis([0 wf/(2*pi) -(As+20) inf]);
ylabel(['|H(w)|']);
axis([0 wf/(2*pi) -inf inf]);
% Retraso de grupo
dW=W(2)-W(1);
print -depsc2 bp_cheb2_ej
Filtro pasa banda
Butterworth:
%% Filtro de Parabanda analógico de Butterworth
clear all;
% Especif.
fs1=45e3;fs2=90e3;
Ap=0.5;
fp1=20e3;fp2=150e3;
As=50;
wp1 = 2*pi*fp1;
wp2 = 2*pi*fp2;
ws1 = 2*pi*fs1;
ws2 = 2*pi*fs2;
wx2 = wp1*wp2;

if (ws1*ws2 > wx2)
ws1 = wx2/ws2;
else
ws2 = wx2/ws1;
end
wlpp = 1/(wp2-wp1);
wlps = 1/(ws2-ws1);
e2 = 10^(0.1*Ap)-1;
n = ceil(n);
wc = 1/(wlpp/(e2^(1/(2*n))));
k=[1:n];
alpha = (2*k-1)*pi/(2*n);
pk = - sin(alpha) + j*cos(alpha);
K = 1;
[B,A]=zp2tf([],pk,K);
% Conversión de pasobajo a parabanda
[B1,A1] = lp2bs(K*B,A,sqrt(wx2),wc);
N=500;
wf=2*pi*160e3;
W=(5:N-1)*wf/N;
H1=freqs(B1,A1,W);
% Retraso de grupo
dW=W(2)-W(1);
axis([0 wf/(2*pi) -(As+10) inf]);
ylabel(['|H(w)|']);
print -depsc2 bs_butter_ej
Chebyshev I:
%% Filtro de Parabanda analógico de Chebyshev-I
clear all;
% Especif.

fs1=45e3;fs2=90e3;
Ap=0.5;
fp1=20e3;fp2=150e3;
As=50;
wp1 = 2*pi*fp1;
wp2 = 2*pi*fp2;
ws1 = 2*pi*fs1;
ws2 = 2*pi*fs2;
wx2 = ws1*ws2;
if (wp1*wp2 < wx2)
wp1 = wx2/wp2;
else
wp2 = wx2/wp1;
end
wlpp = 1/(wp2-wp1);
wlps = 1/(ws2-ws1);
e2 = (10^(0.1*Ap)-1);
n = ceil(n);
wc = 1/wlpp;
k=[1:n];
alpha = (2*k-1)*pi/(2*n);
pk = -sinh(theta)*sin(alpha) + j*cosh(theta)*cos(alpha);
[B,A]=zp2tf([],pk,1);
%% Ajustar ganancia
if (rem(n,2)==0)
K = A(length(A))/sqrt(1+e2);
else
K = A(length(A));
end
N=500;
wf=2*pi*160e3;
W=(5:N-1)*wf/N;
H1=freqs(B1,A1,W);

% Retraso de grupo
dW=W(2)-W(1);
ylabel(['|H(w)|']);
print -depsc2 bs_cheb1_ej
Chebyshev-II:
%% Filtro de Parabanda analógico de Chebyshev-II
clear all;
% Especif.
fs1=45e3;fs2=90e3;
Ap=0.5;
fp1=20e3;fp2=150e3;
As=50;
wp1 = 2*pi*fp1;
wp2 = 2*pi*fp2;
ws1 = 2*pi*fs1;
ws2 = 2*pi*fs2;
wx2 = ws1*ws2;
if (wp1*wp2 < wx2)
wp1 = wx2/wp2;
else
wp2 = wx2/wp1;
end
wlpp = 1/(wp2-wp1);
wlps = 1/(ws2-ws1);
e2 = 1/(10^(0.1*As)-1);
n = ceil(n);
wc = 1/wlps;
k=[1:n];
alpha = (2*k-1)*pi/(2*n);
pk = 1./(-sinh(theta)*sin(alpha) + j*cosh(theta)*cos(alpha));

k = 1:n/2;
phi = (2*k-1)*pi/(2*n);
%% Ajustar ganancia
K = A(length(A))/B(length(B));
N=500;
wf=2*pi*160e3;
W=(5:N-1)*wf/N;
H1=freqs(B1,A1,W);
% Retraso de grupo
dW=W(2)-W(1);
ylabel(['|H(w)|']);
print -depsc2 bs_cheb2_ej
Programas de diseño de filtros digitales IIR
Pre distorsión :
% Mostrar la realción entre frecuencias de los dominios analógico
% y discreto en la transformación bilineal
clear;close;
N=500;
w=(-N/2:N/2);
color = ['r' 'b' 'm' 'g'];
i=1;
for fm=[1 10 50 250]
W=2*atan(w/(2*fm));
plot(w,W,color(i));hold on;
gtext({['fm='num2str(fm) 'Hz']},'FontName','Lucida','Fontsize', ...
10);
i=i+1;
end
grid;
print -depsc2 warping;

Ejemplo Transformación bilineal:
% Ejemplo de una transformación bilineal
% H(s) = 1/(s+1)
% fm = 1 Hz => wm = 2*pi rad/s
% Imponemos que la respuesta freq. de H(s) en wc=1 sea igual a la
% respuesta freq. de H(z) en fdc=wc/(2*pi)
fm = 1;
wc = 1;
fdc = wc/(2*pi);
% Aplicamos la predistorsión para fdc
Wdc = 2*pi*fdc/fm;
wc1 = 2*fm*tan(Wdc/2);
% Filtro original
B=1; A=[1 1];
% Filtro normalizado por wc1
[B1,A1] = lp2lp(B,A,wc1);
% Aplico la tranformacion bilineal
[Bz,Az] = bilinear(B1,A1,fm);
N=500;
w=(0:N-1)*1.5/N;
[H] = freqs(B,A,w);
[Hz] = freqz(Bz,Az,w/(2*pi),fm);
plot(w,20*log10(abs(H)),'-',w,20*log10(abs(Hz)),'--');grid;zoom;
ylabel(['|H(f)|']);
xlabel(['Frecuencia (rad/s)']);
legend('Filtro analógico','Filtro Discreto');
print -depsc2 transf_bilineal_ej
close;
Filtro pasabanda Butterworth
%% Ejemplo filtro pasabanda de butterworth discreto
clear all;
% Especif.
fp1=45e3;fp2=90e3;
Ap=0.5;
fs1=20e3;fs2=150e3;
As=50;
fm = 500e3;
wp1 = 2*pi*fp1;
wp2 = 2*pi*fp2;
ws1 = 2*pi*fs1;
ws2 = 2*pi*fs2;
%% Predistorsionar
%% Obtenemos especs de filtro analógico
wap1 = 2*tan(wp1/2/fm);
wap2 = 2*tan(wp2/2/fm);

was1 = 2*tan(ws1/2/fm);
was2 = 2*tan(ws2/2/fm);
wax2 = wap1*wap2;
if (was1*was2 < wax2)
was1 = wax2/was2;
else
was2 = wax2/was1;
end
wlpp = wap2-wap1;
wlps = was2-was1;
% Calculo de e2
e2 = 10^(0.1*Ap)-1;
% Orden del filtro
n = ceil(n);
wac = wlpp/(e2^(1/(2*n)));
k=1:n;
alpha = (2*k-1)*pi/(2*n);
[B,A]=zp2tf([],pk,1);
[B1,A1] = lp2bp(B,A,sqrt(wax2),wac);
[Bz,Az] = bilinear(B1,A1,1);
N=500;
ff=160e3;
f=(5:N-1)*ff/N;
Hz=freqz(Bz,Az,f,fm);
subplot(3,1,1); plot(f,20*log10(abs(Hz)));grid;
ylabel(['|H(w)|']);
subplot(3,1,2); plot(f,unwrap(angle(Hz)));grid;
% Retraso de grupo
gd = grpdelay(Bz,Az,f,fm);
subplot(3,1,3);plot(f,gd);grid;
ylabel(['Retraso de Grupo (muestreos)']);
print -depsc2 bp_butter_discr_ej
Programas de diseño de filtros digitales FIR

Ventanas espectrales:
%% Ventanas espectrales
%% Rectangular (Boxcar)
clear all;close all;
N=[32 64];
M=500; %% Numero de punto a calcular
figure;
for i=1:length(N)
w=ones(1,N(i));
[H,F]=freqz(w,1,M,1);
H = H/N(i); %% Normalizar por N
subplot(2,1,i);plot(F,20*log10(abs(H)));grid;
xlabel(['Frecuencia discreta normalizada (f/fm)']);
ylabel(['Módulo normalizado |W(F)|/N']);
title(['Ventana rectangular N=' num2str(N(i))]);
axis([0 0.5 -50 1]);
end
pause;
print -depsc2 rect_window_rf;
close;
%% Bartlett (Triangular)
clear w wind;
wind = 'bartlett';
figure;
for i=1:length(N)
eval(['w=' wind '(N(i));']);
title(['Ventana ' wind ' N=' num2str(N(i))]);
axis([0 0.5 -90 1]);
end
pause;
eval(['print -depsc2 ' wind '_window_rf;']);
close;
%% Hanning
clear w wind;
wind = 'hanning';
figure;
for i=1:length(N)
eval(['w=' wind '(N(i));']);
axis([0 0.5 -110 1]);
end
pause;
close;
%% Hamming

clear w wind;
wind = 'hamming';
figure;
for i=1:length(N)
eval(['w=' wind '(N(i));']);
axis([0 0.5 -110 1]);
end
pause;
close;
%% Blackman
clear w wind;
wind = 'blackman';
figure;
for i=1:length(N)
eval(['w=' wind '(N(i));']);
axis([0 0.5 -110 1]);
end
pause;
close;
N=32;n=0:N-1;
linestyle=[' -r';' -b';' -k';' -m';'--r';'--b';'--k';'--m']; k=1;
plot(n,ones(1,N),linestyle(1,:),n,bartlett(N),linestyle(2,:),n,hanning
(N),linestyle(3,:),n,hamming(N),linestyle(4,:),n,blackman(N),linestyle
(5,:)); grid;
axis([-inf inf 0 1.2]);
legend('Rectangular', 'Bartlett','Hanning','Hamming','Blackman');
pause;print -depsc2 spec_window; close;
Coeficientes filtro ideal:
%% Gráficade la h ideal del filtro pasobajo
Fc = 1/6;
N = 25;
n=0:N-1;
h = 2*Fc*sinc(2*Fc*(n-(N-1)/2));
stem(n-(N-1)/2,h);
pause;
print -depsc2 h_ideal_Nimpar;close;
N = 26;
n=0:N-1;
h = 2*Fc*sinc(2*Fc*(n-(N-1)/2));
stem(n-(N-1)/2,h);

pause;
print -depsc2 h_ideal_Npar;close;
Filtro paso bajo ideal:
%% Filtro FIR pasobajo ideal
%% Metodo series de fourier
N = [16 32 64];
for i=[1:length(N)]
n = 0:N(i)-1;
n=n-(N(i)-1)/2;
Fc = 0.25;
h = 2*Fc*sinc(2*Fc*n);
M=500;
[H,F] = freqz(h,1,M,1);
subplot(length(N),1,i);plot(F,abs(H));grid;
title(['Truncamiento: N = 'num2str(N(i))]);
xlabel(['Frecuencia Digital f/fs']);
ylabel(['|H(F)|']);
end
pause;
print -depsc2 fir_lp_ideal_trunc
close
Filtro pasobajo:
%% Diseño de un filtro fir pasobajo por el metodo de las series de
%Fourier
clear all; close all;
fc = 11e3;
fm = 44e3;
Fc = fc/fm;
windows=['boxcar ';'bartlett';'hamming ';'hanning ';'blackman'];
colors=['b ';'r ';'m ';'--b';'--r'];
%% Numero de puntos del filtro
%% N puede ser par o impar ya que se puede construir un filtro
pasobajo
%% siempre que h[n] sea par
N = 25;
n=0:N-1;
%% Filtro pasobajo ideal

hlpi = 2*Fc*sinc(2*Fc*(n-(N-1)/2));
%% Aplicamos ventanas espectrales a este filtro ideal
M=500; %% Nº de puntos para calcular la Resp Freq
for i=1:size(windows)
eval(['w=' windows(i,:) '(N);']);
hlp = hlpi.*w';
%% Normalizar de forma que |H(0)|=1
hlp = hlp/sum(hlp);
[H,f]=freqz(hlp,1,M,fm);
plot(f,abs(H),colors(i,:));
hold on;
end
grid;hold off;
legend('rect','bartlett','hamming','hanning','blackman');
ylabel(['|H(F|']);
title(['Filtro Pasobajo, fc=' num2str(Fc*fm/1000) 'KHz, fm=' ...
num2str(fm/1000) 'KHz, N=' num2str(N)]);
eval(['print -depsc2 fir_lp_wind_N' num2str(N)]);
pause;close
Filtro pasoalto:
%% Diseño de un filtro fir pasoalto por el metodo de las series de
%Fourier
fp = 11e3;
fs = 3e3;
fm = 44e3;
fc = (fp+fs)/2;
Fc = fc/fm;
colors=['b ';'r ';'m ';'--b';'--r'];
%% Numero de puntos del filtro: puede ser par o imar ya que la
% funcion (-1)^n se ajustaria a par o impar depemdiendo de N
N = 25;
n=0:N-1;
%% Al utilizar la expresión hhp[n] = (-1)^n hlp[n], tenemos que
%% cambiar la frecuencia de corte a
Fc = 1/2 - Fc;
% $$$ delta = zeros(1,N);

% $$$ delta((N+1)/2)=1;
hlp = hlpi.*w';
hlp = hlp/sum(hlp);
%%
%% if (rem(N,2)==0)
hhp = (-1).^n .* hlp;
%% else
%% hhp = delta - hlp;
%% end
[H,f]=freqz(hhp,1,M,fm);
hold on;
if (i==4)
figure;stem(n,hhp,'o');grid;pause;
eval(['print -depsc2 fir_hp_coef_N' num2str(N)]);
close;
figure;plot(f,20*log10(abs(H)));grid;
axis([-inf inf -60 0.5]);
ylabel(['|H(F|']);pause;
eval(['print -depsc2 fir_hp_rf_N' num2str(N)]);
close;
end
end
grid;hold off;
ylabel(['|H(F|']);
title(['Filtro Pasoalto, fc=' num2str((0.5-Fc)*fm/1000) ...
'KHz, fm=' num2str(fm/1000) 'KHz, N=' num2str(N)]);
eval(['print -depsc2 fir_hp_wind_N' num2str(N)]);
pause;close
Filtro pasabanda:
%% Diseño de un filtro fir pasabanda por el metodo de las series de
%Fourier
fs1 = 2e3;
fp1 = 10e3;
fp2 = 12e3;
fs2 = 16e3;
fm = 44e3;
%% Interesa que las especificaciones del filtro sean simétricas
%% por lo que calculo cual de las dos zonas de transición es menor
%% y modifico la frecuencia de parabanda

[mm,jj] = min([fp1-fs1 fs2-fp2]);
if jj==1
fs2 = fp2+mm;
else
fs1 = fp1-mm;
end
%% Calculo de los parámetros del filtro pasabanda Fc y F0
fc1 = (fp1+fs1)/2;
fc2 = (fp2+fs2)/2;
Fc1 = fc1/fm;
Fc2 = fc2/fm;
F0 = (Fc1+Fc2)/2;
Fc = (Fc2-Fc1)/2;
colors=['b ';'r ';'m ';'--b';'--r'];
%% N puede ser par o impar ya que se puede construir un filtro
pasobajo
%% siempre que h[n] sea par
N = 45;
n=0:N-1;
hlp = hlpi.*w';
hlp = hlp/sum(hlp);
hbp = 2*hlp.*cos(2*pi*F0*(n-(N-1)/2));
[H,f]=freqz(hbp,1,M,fm);
hold on;
if (i==3) %% ventana de hamming
figure;stem(n,hbp,'o');grid;pause;
eval(['print -depsc2 fir_bp_coef_N' num2str(N)]);
close;
axis([-inf inf -60 1]);
eval(['print -depsc2 fir_bp_rf_N' num2str(N)]);
close;
end
end
grid;hold off;

ylabel(['|H(F|']);
title(['Filtro Pasobanda, fc=' num2str(Fc*fm/1000) 'KHz, f0=' ...
num2str(F0*fm/1000) 'KHz, fm=' num2str(fm/1000) 'KHz,' ...
' N=' num2str(N)]);
eval(['print -depsc2 fir_bp_wind_N' num2str(N)]);
pause;close
Filtro parabanda:
%% Diseño de un filtro fir parabanda por el metodo de las series de
%Fourier
fp1 = 2e3;
fs1 = 10e3;
fs2 = 12e3;
fp2 = 16e3;
fm = 44e3;
%% Interesa que las especificaciones del filtro sean simétricas
%% por lo que calculo cual de las dos zonas de transición es menor
%% y modifico la frecuencia de parabanda
[mm,jj] = min([fs1-fp1 fp2-fs2]);
if jj==1
fs2 = fp2-mm;
else
fs1 = fp1+mm;
end
%% Calculo de los parámetros del filtro pasabanda Fc y F0
fc1 = (fp1+fs1)/2;
fc2 = (fp2+fs2)/2;
Fc1 = fc1/fm;
Fc2 = fc2/fm;
F0 = (Fc1+Fc2)/2;
Fc = (Fc2-Fc1)/2;
colors=['b ';'r ';'m ';'--b';'--r'];
%% N solo puede ser impar y la secuencia deber ser par ya que es la
%unica forma de diseñar un filtro FIR parabanda
N = 41;
n=0:N-1;
%% Calculo de delta
delta = zeros(1,N);
delta((N+1)/2) = 1;

hlp = hlpi.*w';
hlp = hlp/sum(hlp);
hbs = delta - 2*hlp.*cos(2*pi*F0*(n-(N-1)/2));
[H,f]=freqz(hbs,1,M,fm);
hold on;
if (i==5) %% ventana de blackman
figure;stem(n,hbs,'o');grid;pause;
eval(['print -depsc2 fir_bs_coef_N' num2str(N)]);
close;
axis([-inf inf -60 1]);
eval(['print -depsc2 fir_bs_rf_N' num2str(N)]);
close;
end
end
grid;hold off;
ylabel(['|H(F|']);
title(['Filtro Parabanda, fc=' num2str(Fc*fm/1000) 'KHz, f0=' ...
num2str(F0*fm/1000) 'KHz, fm=' num2str(fm/1000) 'KHz,' ...
' N=' num2str(N)]);
eval(['print -depsc2 fir_bs_wind_N' num2str(N)]);
pause;close
Diseño general de filtros FIR (metodo de las ventanas):
function [h,N,fc] = firdig(fp, fs, Ap, As, fm, window)
%
% function [B,A] = firdig(fp, fs, Ap As, fm, window)
%
% This function calculates an FIR digital filter with the window
specified by variable window
% type can be 'boxcar', 'hamming', 'hanning', 'blackman' or
'bartlett'
%
% fp is a vector of passband frequencies (Hz)
% fs is a vector of stopband frequencies (Hz)
% Ap is the attenuation in db at the passband frequencies
% As is the attenuation in db at the stopband frequencies
% fm is the sampling frequency (Hz)
%
% Check the parameters fp and fs
close all;

np = size(fp);
ns = size(fs);
if (~isequal(np,ns))
fprintf(1,'Error: fp and fs are of different sizesn'); return;
elseif (min(np) == 1) % fp and fs are vectors of the same size
if (max(np) == 1) % fp and fs are scalars (filter must be either
a lowpass or highpass)
if fp < fs
filter = 'lp';
elseif fp > fs
filter = 'hp';
else
fprintf(1,'Error: fs and fp are equaln'); return;
end
elseif (max(np)==2) % fp and fs are vectors (filter must be a
bandpass or bandstop)
if (fs(1) < min(fp)) & (fs(2) > max(fp))
filter = 'bp';
elseif (fp(1) < min(fs)) & (fp(2) > max(fs))
filter = 'bs';
else
fprintf(1,'Error: Values of fp and fs does not correspond
to a known kind of filtern'); return;
end
else
fprintf(1,'Error: The length of fs or fp is bigger than 2n');
return;
end
else
fprintf(1,'Error: fp, fs or both are matricesn'); return;
end
% Ordering fp and fs from smaller to bigger frequencies
if filter=='bp' | filter=='bs'
x = min(fp); y = min(fs);
if (x==2) tmp = fp(1); fp(1) = fp(2); fp(2) = tmp; end
if (y==2) tmp = fs(1); fs(1) = fs(2); fs(2) = tmp; end
end
% Check the Attenuation parameters
ap = size(Ap);
as = size(As);
if (~isequal(ap,as))
fprintf(1,'Error: Ap and As are of different sizesn'); return;
elseif (ap ~= [1 1])
fprintf(1,'Error: Ap and As are not scalarsn');return;
elseif (Ap <= 0 | As <= 0)
fprintf(1,'Error: Ap or As or both are less or equal than 0n');
return;
end
%% Check the sampling frequency
maxfreq = max(max([fp fs]));
if fm < 2*maxfreq

fprintf(1,'Warning: fm < twice the maximum frequency specified in
in fp and fsn');
fprintf(1,' I suggest to increase the sampling
frequencyn');
return;
end
% Convert to normalized frequencies
%
Fp = fp/fm;
Fs = fs/fm;
%% Convert specs to lowpass
switch filter
case {'lp'}
Fp_lp = Fp;
Fs_lp = Fs;
Atp = Ap;
Ats = As;
Apfig = Ap;
Asfig = As;
case {'hp'}
Fp_lp = 0.5-Fp;
Fs_lp = 0.5-Fs;
Atp=Ap;% -20*log10(1-10^(-As/20));
Ats=As;% -20*log10(1-10^(-Ap/20));
Apfig = Ap;
Asfig = As;
case {'bp'}
[minimum,idx]=min([Fp(1)-Fs(1) Fs(2)-Fp(2)]);
if idx==1,
Fs(2)=Fp(2)+minimum;
else
Fs(1)=Fp(1)-minimum;
end
Fp_lp = (Fp(2)-Fp(1))/2;
Fs_lp = (Fs(2)-Fs(1))/2;
Fo = (Fp(1)+Fp(2))/2;
Atp = Ap;
Ats = As;
Apfig = [Ap Ap];
Asfig = [As As];
case {'bs'}
[minimum,idx]=min([Fs(1)-Fp(1) Fp(2)-Fs(2)]);
if idx==1
Fp(2)=Fs(2)+minimum;
else
Fp(1)=Fs(1)-minimum;
end
Fp_lp = (Fs(2)-Fs(1))/2;
Fs_lp = (Fp(2)-Fp(1))/2;
Fo = (Fp(2)+Fp(1))/2;
Atp=-20*log10(1-10^(-As/20));
Ats=-20*log10(1-10^(-Ap/20));
Apfig = [Ap Ap];
Asfig = [As As];
otherwise

fprintf(1,'Error: unknown window specified');
end
%% Check the filter window
bw = Fs_lp-Fp_lp;
lwindow = lower(window);
switch lwindow
case {'boxcar'}
N = round(0.81/bw);
case {'hamming'}
N = round(1.91/bw);
case {'hanning'}
N = round(1.97/bw);
case {'blackman'}
N = round(2.82/bw);
case {'bartlett'}
N = round(1.62/bw);
otherwise
fprintf(1,'Error: Unknown filter window'); return;
end
%% Design the Lowpass filter
%% Set Fc (cut frequency) to Fp_lp
Fc = Fp_lp;
run = 1;
t_steps=4;
while run==1
n = 0:N-1;
eval(['w = ' lwindow '(' num2str(N) ');']);
hlp = 2*Fc*sinc(2*Fc*(n-(N-1)/2)).* w';
At = freqz(hlp,1,[Fp_lp Fs_lp]*fm,fm);
Atdb = -20*log10(abs(At));
dFc = (Fs_lp-Fp_lp)/t_steps;
if (Atdb(1) > Atp) | (Atdb(2) < Ats)
if (Fc > Fs_lp)
N = N + 1;
if rem(N,2)==0 & filter=='bs' %% if filter is bandstop
%the order must be odd
N=N+1;
end
Fc = Fp_lp;
else
Fc = Fc + dFc;
end
elseif (t_steps<256)
% Go back to previous order. Just in case!!
if (filter=='bs')
N=N-2;
else
N=N-1;
end
Fc = Fc-dFc; %% Go back to previous freq
t_steps = t_steps*2;
else
run=0;
end

end
fc = Fc*fm;
[H,f] = freqz(hlp,1,500,1);
figure, subplot(2,1,1), plot(f, Hdb, [Fp_lp Fs_lp], -[Atp Ats], '*r');
%% Transform to aproppiate filter
switch filter
case {'hp'}
delta = zeros(1,N); delta((N+1)/2) = 1;
h = ((-1).^n).*hlp;
case {'bp'}
h = 2*cos(2*pi*Fo*(n-(N-1)/2)).*hlp;
case {'bs'}
delta = zeros(1,N); delta((N+1)/2) = 1;
h = delta - 2*cos(2*pi*Fo*(n-(N-1)/2)).*hlp;
case {'lp'}
h = hlp;
otherwise
end
[H,f] = freqz(h,1,500,fm);
subplot(2,1,2), plot(f, Hdb, [fp fs], -[Apfig Asfig], '*r');
axis([-inf inf -As-20 1]);
figure; stem(h);
fprintf(1,'The order of the resulting filter is %dn', N-1);
fprintf(1,'The cut frequency of the lowpass prototype is %f Hzn',fc);
return;
Transformada Discreta de Fourier (DFT).
Transformada Rápida de Fourier (FFT).
Ejemplos en Matlab:
function [] = fftej1(N,D)
% fftej1(N,D)
% Ejemplo de una FFT de una se¤al sinusoidal de 20Hz sumada una se¤al
% tipo chirp con un desplazamiento desde 5 hasta 40 Hz en un tiempo D.
% N es el n£mero de puntos de la funci¢n. Elegir preferiblemente
valores
% que sean potencias de 2
ts=D/N;
d=ts/2;
t=0:ts:D-d;
x=sin(2*pi*20*t)+chirp([5 40]*D/N,N);
X=fft(x);
%Reordenar X
M=N/2;
Xaux=X;X(M+1:N)=Xaux(1:M);
X(1:M)=Xaux(M+1:N);
Xm=abs(X)/N;

Xf=unwrap(angle(X))*180/pi;
%Reordenar los ¡ndices k
faux(M+1:N)=0:M-1;faux(1:M)=-M:-1;
f=faux/D;
figure;plot(t,x,'-g');zoom;
xlabel('Tiempo (s)');ylabel('x(t)');
title('x(t)=sin(2·Pi·20·t)+chirp(5-40)');
figure;lines(f,Xm,'oc5','-c5');zoom;
xlabel('Frecuencia (Hz)');ylabel('|X[k]|');
title('Módulo de Coeficientes Espectrales |X[k]|');
figure;lines(f,Xf,'xc3','-c3');zoom;
xlabel('Frecuencia (Hz)');ylabel('Fase (º)');
title('Fase de Coeficientes Espectrales X[k]');
% Reconstrucción de la señal a partir de los X[k]
% Utilizamos un mayor número de puntos fs=500 Hz
fs=500;
ts=1/fs;
d=ts/2;
t=0:ts:D-d;
Ns=length(t);
x=sin(2*pi*20*t)+chirp([5 40]*ts,Ns);
xr=zeros(1,Ns);
for i=1:Ns
for k=1:N
xr(i)=xr(i)+X(k)*exp(j*2*pi*f(k)*ts*(i-1))/N;
end
end
figure;plot(t,x,'g-');hold on;plot(t,xr,'r--');zoom;
title('Comparación entre x(t) y su reconstrucción a partir de X[k]');
xlabel('Tiempo (t)');ylabel('x(t)');
% Ejemplo de una FFT de una se¤al exponencial sumada a una señal
% tipo chirp con un desplazamiento desde 60 hasta 100 Hz en 1
segundos.
% N es el n£mero de puntos de la funci¢n. Elegir preferiblemente
valores
% que sean potencias de 2
ts=D/N;
d=ts/2;
t=0:ts:D-d;
df=100-60;
x=exp(-2*t)+0.2.*chirp([60 60+df*D]*ts,N);
X=fft(x);
%Reordenar Y
M=N/2;
Xaux=X;X(M+1:N)=Xaux(1:M);X(1:M)=Xaux(M+1:N);
Xm=abs(X)*ts;

faux(M+1:N)=0:M-1;faux(1:M)=-M:-1;
f=faux/D;
figure;plot(t,x,'-r');zoom;
title('x(t)=exp(-2t)+0.2·chirp(60-100)');
title('Módulo de los coeficientes espectrales |X[k]|');
figure;lines(f,Xf,'oc3','-c3');
xlabel('Frecuencia (Hz)');ylabel('Fase(X[k]) (º)');
title('Fase de los coeficientes espectrales X[k]');
% Reconstrucción de la señal a partir de los X[k]
% Utilizamos un mayor número de puntos fs=500 Hz
fs=500;
ts=1/fs;
d=ts/2;
t=0:ts:D-d;
Ns=length(t);
x=exp(-2*t)+0.2.*chirp([60 60+df*D]*ts,Ns);
xr=zeros(1,Ns);
for i=1:Ns
for k=1:N
end
end
function [X,f] = fftej3(N,D)
% fftej3(N,D)
% Ejemplo de una FFT de una se¤al exponencial modulada en amplitud
% con una frecuencia portadora de 200Hz.
% N es el n£mero de puntos de muestreo durante D seg. de señal.
% Elegir preferiblemente valores que sean potencias de 2
% Hacer notar que al ser la frecuencia portadora de 200Hz,
% necisitamos una frecuencia de muestreo de por lo menos
% 400Hz, por lo que N/D > 400
ts=D/N;
d=ts/2;
t=0:ts:D-d;
x=exp(-2*t).*sin(2*pi*200*t);
X=fft(x);
%Reordenar X
M=N/2;
Xm=abs(X)*ts;

faux(M+1:N)=0:M-1;faux(1:M)=-M:-1;
f=faux/D;
title('x(t)=exp(-2t)·sin(2·pi·200·t)');
title('Módulo de los coeficientes espectrales de x(t)');
figure;lines(f,Xf,'oc3','-c3');zoom;
xlabel('Frecuencia (Hz)');ylabel('Fase X[k]');
% fftej4(N,D)
% Ejemplo de una FFT de una se¤al sinusoidal de 2Hz modulada en
% frecuencia con una frecuencia portadora de 200Hz.
% N es el n£mero de puntos de muestreo durante D seg de señal.
ts=D/N;
d=ts/2;
t=0:ts:D-d;
x=sin(2*pi*200*t+5*sin(2*pi*2*t));
X=fft(x);
%Reordenar X
M=N/2;
X(1:M)=Xaux(M+1:N);
Xm=abs(X)*ts;
faux(M+1:N)=0:M-1;faux(1:M)=-M:-1;
f=faux/D;
title('x(t)=sin(2·pi·200·t+10·sin(2·pi·2·t)');
function [X,f] = fftej5(N,D)
% fftej5(N,D)
% Ejemplo de una FFT de una se¤al exponencial modulada en
% frecuecia con una frecuencia portadora de 200Hz.
% N es el n£mero de puntos de muestreo durante D s de señal.

ts=D/N;
d=ts/2;
t=0:ts:D-d;
x=sin(2*pi*200*t-5*exp(-2*t));
X=fft(x);
%Reordenar X
M=N/2;
X(1:M)=Xaux(M+1:N);
Xm=abs(X)*ts;
faux(M+1:N)=0:M-1;faux(1:M)=-M:-1;
f=faux/D;
title('x(t)=sin(2·pi·200·t-5·exp(-2t))');
function []=fftej7(N,D)
% fftej7(N,d)
% x(t)=exp(-2*t)*sin(2*pi*3*t)
%
ts=D/N;
d=ts/10;
t=0:ts:D-d;
x=exp(-2*t).*sin(2*pi*3*t);
X=fft(x);
% Reordenar
M=N/2;
% Separar Modulo y Fase de los coeficientes X(k)
Xm=abs(X)*ts;
Xf=unwrap(angle(X))*180/pi; %En grados
% Transformar Indices k en frecuencias
faux(M+1:N)=0:M-1;faux(1:M)=-M:-1;
f=faux/D;
% Reconstruir los muestreos originales a partir de los X(k)
xr=zeros(1,N);
for i=1:N

for k=1:N
xr(i)=xr(i)+X(k)*exp(j*2*pi*f(k)*ts*(i-1));
end
end
xr=xr/N;
%Plots
figure;lines(t,x,'oc5','-c5');hold on;lines(t,xr,'xc3','-c3');zoom;
title('Puntos de muestreo (o) y Reconstrucción a partir de X[k] (x)');
xlabel('Frecuencia (Hz)');
ylabel('|X[k]|');
ylabel('Fase X[k]');
%Reconstruccion de la señal original a partir de los X(k)
%Utilizamos un mayor número de puntos ts=ts/10
ts=1/64;
d=ts/2;
t=0:ts:2*D-d;
x=exp(-2*t).*sin(2*pi*3*t);
Ns=length(x);
xr=zeros(1,Ns);
for i=1:Ns
for k=1:N
end
end
%plots
xlabel('Tiempo (t)');
ylabel('x(t)');
% fftej8(N,D)
% N es el número de puntos de muestreo
% D es el periodo de tiempo sobre el que se muestrea
% Creamos una señal tipo chirp entre 0 y D con una transición de
% frecuencias desde 20Hz hasta 60Hz
% Figuras : Coeficientes espectrales
% Fase
% Reconstrucción
df=60-20;
ts=D/N;
d=ts/2;

t=0:ts:D-d;
% El tamaño de t es lógicamente N
% Creamos una señal tipo chirp entre 0 y D con una transición de
% frecuencias desde 20Hz hasta 60Hz
x1=chirp([20 20+df*D]*D/N,N);
% Señal exponencial
x2=0.5*(1-exp(-0.3.*t));
% Señal senoidal con ;
x3=(1+0.5*t.^2).*sin(2*pi*5*t);
%Señal x(t)
x=x3+x1*0.2;
X=fft(x);
% Reordenar
M=N/2;
% Separar Modulo y Fase de los coeficientes X(k)
Xm=abs(X)*ts;
Xf=unwrap(angle(X))*180/pi; %En radianes
% Transformar Indices k en frecuencias
faux(M+1:N)=0:M-1;faux(1:M)=-M:-1;
f=faux/D;
title('Módulo de los coeficientes espectrales de x(t) |X[k]|');
ylabel('|X[k]|');
ylabel('Fase X[k]');
% Reconstrucción de la señal
D=1.5*D;
ts=1/250;
d=ts/2;
t=0:ts:D-d;
Ns =length(t);
x1=chirp([20 20+df*D]*ts,Ns);
x2=0.5*(1-exp(-0.3.*t));
x3=(1+0.5*t.^2).*sin(2*pi*5*t);
x=x3+x1*0.2;
xr=zeros(1,Ns);
for i=1:Ns

for k=1:N
end
end
figure;plot(t,x,'g-',t,xr,'r--');zoom;
xlabel('Tiempo (t)');
ylabel('x(t)');
Capítulo 8: Diseño de Filtros Digitales - Filtros IIR
Filtros IIR.
Diseño de Filtros Analógicos (Butterworth, Chevyshev I y II, elípticos).
Métodos de Transformación del plano s al plano z.
Diseño de Filtros IIR con MATLAB
-Analógicos
Filtros Pasobajo
clear;
% Especificaciones
wp = 5000;
ws = 8000;
Ap = 1;As = 60;
% Paso a especificaciones de pasobajo
% Tablas 1 y 2
Wp = wp;
Ws = ws;
k1 = 10^(0.1*Ap)-1;
k2 = 10^(0.1*As)-1;
% Filtro de Butterworth
e2b = k1;
nb = ceil((log10(sqrt(k2/k1)))/log10(Ws/Wp));
v3 = (1/k1)^(1/(2*nb));
% Filtro de Chebyshev I
e2c1 = k1;
nc1 = ceil((acosh(sqrt(k2/k1)))/acosh(Ws/Wp));
% Filtro de Chebyshev II
e2c2 = 1/k2;
nc2 = ceil((acosh(sqrt(k2/k1)))/(acosh(Ws/Wp)));
%Filtro elíptico
[ne, Wn]=ellipord(wp, ws, Ap, As,'s');
% Diseño del prototipo de filtro filtro pasobajo
[Z,P,K] = buttap(nb);
[Bbp,Abp] = zp2tf(Z,P,K);
[Z,P,K] = cheb1ap(nc1,Ap);
[Bc1p,Ac1p] = zp2tf(Z,P,K);

[Z,P,K] = cheb2ap(nc2,As);
%Filtro elíptico
[Z,P,K] = ellipap(ne,Ap,As);
[Be,Ae] = zp2tf(Z,P,K);
% Convertir a Pasabajo
[Bb,Ab] = lp2lp(Bbp,Abp,Wp*v3);
[Bc1,Ac1] = lp2lp(Bc1p,Ac1p,Wp);
[Bc2,Ac2] = lp2lp(Bc2p,Ac2p,Ws);
%Filtro elíptico
[Be,Ae] = lp2lp(Be,Ae,Wp);
fprintf(1,'Orden del filtro de Butterworth = %dn',nb);
fprintf(1,'Orden del filtro de Chebyshev I = %dn',nc1);
fprintf(1,'Orden del filtro de Chebyshev II = %dn',nc2);
fprintf(1,'Orden del filtro elíptico = %dn',ne);
% Respuestas frecuenciales de los tres filtros obtenidos
W = 1:10:10000;
[Hb]=freqs(Bb,Ab,W);
Hb = 20*log10(abs(Hb));
[Hc1]=freqs(Bc1,Ac1,W);
Hc1 = 20*log10(abs(Hc1));
[He]=freqs(Be,Ae,W);
He = 20*log10(abs(He));
plot(W,Hb,'r',W,Hc1,'g',W,Hc2,'m',W,He,'b');hold;
plot([wp ws],-[Ap As],'*y');grid;zoom;
Filtros Pasoalto
clear;
% Especificaciones
wp = 8000;
ws = 5000;
Ap = 1;As = 60;
% Tablas 1 y 2
Wp = ws;
Ws = wp;
k1 = 10^(0.1*Ap)-1;
k2 = 10^(0.1*As)-1;
e2b = k1;
nb = ceil((log10(sqrt(k2/k1)))/log10(Ws/Wp));

v3 = (1/k1)^(1/(2*nb));
e2c1 = k1;
nc1 = ceil((acosh(sqrt(k2/k1)))/acosh(Ws/Wp));
e2c2 = 1/k2;
nc2 = ceil((acosh(sqrt(k2/k1)))/(acosh(Ws/Wp)));
%Filtro elíptico
[ne, Wn]=ellipord(Wp, Ws, Ap, As,'s');
% Diseño del prototipo de filtro filtro pasobajo
[Z,P,K] = buttap(nb);
[Bbp,Abp] = zp2tf(Z,P,K);
[Z,P,K] = cheb1ap(nc1,Ap);
[Z,P,K] = cheb2ap(nc2,As);
%Filtro elíptico
[Z,P,K] = ellipap(ne,Ap,As);
[Be,Ae] = zp2tf(Z,P,K);
% Convertir a Pasaalta
[Bb,Ab] = lp2hp(Bbp,Abp,Ws/v3);
[Bc1,Ac1] = lp2hp(Bc1p,Ac1p,Ws);
[Bc2,Ac2] = lp2hp(Bc2p,Ac2p,Wp);
%Filtro elíptico
[Be,Ae] = lp2hp(Be,Ae,Ws);
fprintf(1,'Orden del filtro de Butterworth = %dn',nb);
fprintf(1,'Orden del filtro de Chebyshev I = %dn',nc1);
fprintf(1,'Orden del filtro de Chebyshev II = %dn',nc2);
fprintf(1,'Orden del filtro elíptico = %dn',ne);
% Respuestas frecuenciales de los tres filtros obtenidos
W = 1:10:10000;
[Hb]=freqs(Bb,Ab,W);
Hb = 20*log10(abs(Hb));
[He]=freqs(Be,Ae,W);
He = 20*log10(abs(He));

plot(W,Hb,'r',W,Hc1,'g',W,Hc2,'m',W,He,'b');hold;
plot([wp ws],-[Ap As],'*y');grid;zoom;
Filtros Pasabanda
clear;
close all;
% Especificaciones del filtro digital
wp = [3000 5000];Rp = 1;
ws = [2000 7500];Rs = 60;
fm = 5000;
% Predistorsionar las especificaciones
wpx = 2*tan(wp/(2*fm));
wsx = 2*tan(ws/(2*fm));
% Tablas 1 y 2
Bw1 = wpx(2)-wpx(1);
% Fijamos las frecuencias de pasabanda
wx2 = wpx(1)*wpx(2);wx=sqrt(wx2);
if wsx(1)*wsx(2) < wx2,
wsx(2) = wx2/wsx(1);
else
wsx(1) = wx2/wsx(2);
end
Bw2 = wsx(2)-wsx(1);
% Criterio de MATLAB
% Bw1 = 1;
% Bw2 = (wsx.^2-wx2)/(wsx*(wpx(2)-wpx(1)));
% Bw2 = min(abs(Bw2));
% Especificiones de pasobajo
Wp = Bw1;
Ws = Bw2;
k1 = 10^(0.1*Rp)-1;
k2 = 10^(0.1*Rs)-1;
e2 = k1;
n = ceil((log10(sqrt(k2/k1)))/log10(Ws/Wp));
v3 = (1/k1)^(1/(2*n));
[Z,P,K] = buttap(n);
[Bp,Ap] = zp2tf(Z,P,K);
[Bs,As] = lp2bp(Bp,Ap,wx,Wp*v3);
[B,A] = bilinear(Bs,As,1);
F = [1:1000]/2000;
H = freqz(B,A,F*fm,fm);
H = 20*log10(abs(H));
Gd = grpdelay(B,A,F*fm,fm);
plot(F*fm,H,'r');hold;plot([wp ws]/(2*pi),-[Rp Rp Rs
Rs],'*k');grid;zoom;
figure;plot(F*fm,Gd);zoom;grid;

% Hacer el mismo filtro pero utilizando funciones de Matlab
% wpx = 2*tan(wp/(2*fm));
% wsx = 2*tan(ws/(2*fm));
% [N,Wn] = buttord(wpx,wsx,Rp,Rs,'s');
% [Bs,As] = butter(N,Wn,'s');
% [B,A] = bilinear(Bs,As,1);
% H = freqz(B,A,F*fm,fm);
% H = 20*log10(abs(H));
% plot(F*fm,H,'b');hold off;
Filtros Parabanda
clear all;
close all;
wp = [1000 3000];Rp = 3;
ws = [2000 2500];Rs = 40;
fm = 10000;
% Tablas 1 y 2
Bw1 = wsx(2)-wsx(1);
% Fijamos las frecuencias de parabanda
wx2 = wsx(1)*wsx(2);wx=sqrt(wx2);
if wpx(1)*wpx(2) < wx2,
wpx(1) = wx2/wpx(2);
else
wpx(2) = wx2/wpx(1);
end
Bw2 = wpx(2)-wpx(1);
% Criterio de MATLAB
% Bw1 = 1;
% Bw2 = (wsx*(wpx(2)-wpx(1)))./(wsx.^2-wx2);
% Bw2 = min(abs(Bw2));
% Especificiones de pasobajo
Wp = Bw1;
Ws = Bw2;
k1 = 10^(0.1*Rp)-1;
k2 = 10^(0.1*Rs)-1;
% Filtro de Cheby1
e2 = k1;
n = ceil((acosh(sqrt(k2/k1)))/acosh(Ws/Wp));
v3 = (1/k1)^(1/(2*n));

[Z,P,K] = cheb1ap(n,Rp);
[Bs,As] = lp2bs(Bp,Ap,wx,Ws);
F = [0:499];F= F*2*wp(2)/(2*pi*500);
H = freqz(B,A,F,fm);
H = 20*log10(abs(H));
figure;plot(F,H,'r',[wp ws]/(2*pi),-[Rp Rp Rs Rs],'*k');grid;zoom;
% Hacer el mismo filtro pero utilizando funciones de Matlab
[N,Wn] = cheb1ord(2*wp/(2*pi*fm),2*ws/(2*pi*fm),Rp,Rs);
[B,A] = cheby1(N,Rp,Wn,'stop');
H = freqz(B,A,F,fm);
hold;
plot(F,Hdb,'b',[wp ws]/(2*pi),-[Rp Rp Rs Rs],'*k');
Utilizando la transformada invariante a impulso
clear;
wp = 4000;Rp = 2;
ws = 7000;Rs = 40;
fm = 22000;
%Transformación bilineal
% Hacemos paso paso el filtro analógico
Wp = wpx;
Ws = wsx;
k1 = 10^(0.1*Rp)-1;
k2 = 10^(0.1*Rs)-1;
e2 = 1/k2;
n = ceil((acosh(sqrt(k2/k1)))/(acosh(Ws/Wp)));
[Z,P,K] = cheb2ap(n,Rs);
[Bs,As] = lp2lp(Bp,Ap,Ws);
%Transformación bilineal
[H F]= freqz(B,A,1000,1);
H = 20*log10(abs(H));
plot(F*fm,H,'r');hold on;plot([wp ws]/(2*pi),-[Rp Rs],'*k');grid;zoom;
title('Transformación bilineal');
%Retardo de grupo
F = [1:1000]/3000;
Gd = grpdelay(B,A,F*fm,fm);

figure;plot(F*fm,Gd,'b');zoom;
title('retardo de grupo');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%
%Transformación invariante a impulso
Wp = wp;
Ws = ws;
k1 = 10^(0.1*Rp)-1;
k2 = 10^(0.1*Rs)-1;
e2 = 1/k2;
n = ceil((acosh(sqrt(k2/k1)))/(acosh(Ws/Wp)));
[Z,P,K] = cheb2ap(n,Rs);
[Bs,As] = lp2lp(Bp,Ap,Ws);
%Transformación invariante a impulso
[Bz,Az]=impinvar(Bs,As, fm);
%Hay que normalizar para que H(0)=1
k=sum(real(Az))/sum(real(Bz));
Bz=k*Bz;
[Hz Fz]=freqz(Bz,Az,1000,fm);
Hz = 20*log10(abs(Hz));
figure;plot(Fz,Hz,'r');hold;plot([wp ws]/(2*pi),-[Rp
Rs],'*k');grid;zoom;
title('Transformación invariante a impulso');
Función de Matlab para el diseño de todo tipo de filtros IIR
Analógicos
function [B,A,n] = iirafilt(type,fp,fs,Ap,As)
% [B,A] = function iirdfilt(type,fp,fs,Ap,As)
%
% type es el tipo de filtro, 'butter', 'cheby1', 'cheby2'
% fp es la/las frecuencia/s de pasabanda en Hz
% fs es la/las frecuencia/s de parabanda en Hz
% Ap y As son las atenuaciones respectivas en decibelios
if length(fp) ~= length(fs)
disp('Error en dimensiones de fp y/o fs');
return
end
if Ap > As,
disp('Error en los valores de Ap y/o As');
return;
end
% Determinar el tipo de filtro: pasabajo, pasoalto, paabanda o
parabanda
if (length(fp) == 1)
if (fp < fs),
tipo = 'lp';
elseif (fp > fs)
tipo = 'hp';

else
disp('Frecuencia de pasabanda = Frecuencia de parabanda');
return;
end
elseif (length(fp) == 2)
aux = [fp fs];
[aux1,i]=sort(aux);
if (i==[3 1 2 4])
tipo = 'bp';
elseif (i==[1 3 4 2])
tipo = 'bs';
else
disp('Error: Compruebe que los valores de fp y fs están en el
orden correcto');
return;
end
end
wp = 2*pi*fp;
ws = 2*pi*fs;
switch tipo
case 'lp',
switch type
case 'butter',
e2 = 10^(0.1*Ap)-1;
aux = 10^(0.1*As)-1;
n = log10(sqrt(aux/e2))/log10(ws/wp); n = ceil(n);
wc = (1/e2)^(1/(2*n));
[Z,P,K]=buttap(n);
[Ban,Aan]=zp2tf(Z,P,K);
[Ban,Aan] = lp2lp(Ban,Aan,wc*wp);
case 'cheby1',
e2 = 10^(0.1*Ap)-1;
aux = 10^(0.1*As)-1;
n = acosh(sqrt(aux/e2))/acosh(ws/wp); n = ceil(n);
[Z,P,K]=cheb1ap(n,Ap);
[Ban,Aan] = lp2lp(Ban,Aan,wp);
case 'cheby2',
e2 = 1/(10^(0.1*As)-1);
aux = 10^(0.1*Ap)-1;
n = acosh(sqrt(1/(aux*e2)))/acosh(ws/wp); n = ceil(n);
[Z,P,K]=cheb2ap(n,As);
[Ban,Aan] = lp2lp(Ban,Aan,ws);
end
case 'hp',
wp = 1/wp;
ws = 1/ws;
switch type
case 'butter',
e2 = 10^(0.1*Ap)-1;
aux = 10^(0.1*As)-1;
wc = (1/e2)^(1/(2*n));
[Z,P,K]=buttap(n);
[Ban,Aan] = lp2hp(Ban,Aan,1/(wc*wp));
case 'cheby1',
e2 = 10^(0.1*Ap)-1;

aux = 10^(0.1*As)-1;
[Ban,Aan] = lp2hp(Ban,Aan,1/wp);
case 'cheby2',
e2 = 1/(10^(0.1*As)-1);
aux = 10^(0.1*Ap)-1;
[Ban,Aan] = lp2hp(Ban,Aan,1/ws);
end
case 'bp' % Hay que pasar a pasobajo las especificaciones
wx2 = wp(1)*wp(2);wx = sqrt(wx2);
if (ws(1)*ws(2) < wx2),
ws(1) = wx2/ws(2);
else
ws(2) = wx2/ws(1);
end
wp = wp(2)-wp(1);
ws = ws(2)-ws(1);
switch type
case 'butter',
e2 = 10^(0.1*Ap)-1;
aux = 10^(0.1*As)-1;
wc = (1/e2)^(1/(2*n));
[Z,P,K]=buttap(n);
[Ban,Aan] = lp2bp(Ban,Aan,wx,wp*wc);
case 'cheby1',
e2 = 10^(0.1*Ap)-1;
aux = 10^(0.1*As)-1;
[Ban,Aan] = lp2bp(Ban,Aan,wx,wp);
case 'cheby2',
e2 = 1/(10^(0.1*As)-1);
aux = 10^(0.1*Ap)-1;
[Ban,Aan] = lp2bp(Ban,Aan,wx,ws);
end
case 'bs',
wx2 = ws(1)*ws(2);wx = sqrt(wx2);
if (wp(1)*wp(2) < wx2),
wp(1) = wx2/wp(2);
else
wp(2) = wx2/wp(1);
end
wp = 1/(wp(2)-wp(1));
ws = 1/(ws(2)-ws(1));
switch type
case 'butter',
e2 = 10^(0.1*Ap)-1;

aux = 10^(0.1*As)-1;
wc = (1/e2)^(1/(2*n));
[Z,P,K]=buttap(n);
[Ban,Aan] = lp2bs(Ban,Aan,wx,1/(wp*wc));
case 'cheby1',
e2 = 10^(0.1*Ap)-1;
aux = 10^(0.1*As)-1;
[Ban,Aan] = lp2bs(Ban,Aan,wx,1/wp);
case 'cheby2',
e2 = 1/(10^(0.1*As)-1);
aux = 10^(0.1*Ap)-1;
[Ban,Aan] = lp2bs(Ban,Aan,wx,1/ws);
end
end
[H2,W]=freqs(Ban,Aan,500);
H2db = 20*log10(abs(H2));
figure;
plot(W/(2*pi),H2db,[fp fs],-[Ap As],'*');grid;zoom;
else
plot(W/(2*pi),H2db,[fp fs],-[Ap Ap As As],'*');grid;zoom;
end
A=Aan;
B=Ban;
return;
Digitales
function [Bd,Ad,n] = iirdfilt(type,fp,fs,Ap,As,fm)
% [B,A] = function iirdfilt(type,fp,fs,Ap,As,fm)
%
% type es el tipo de filtro, 'butter', 'cheby1', 'cheby2'
% fp es la/las frecuencia/s de pasabanda en Hz
% fs es la/las frecuencia/s de parabanda en Hz
% Ap y As son las atenuaciones respectivas en decibelios
% fm es la frecuencia de muestreo en Hz
if length(fp) ~= length(fs)
disp('Error en dimensiones de fp y/o fs');
return
end
if Ap > As,
disp('Error en los valores de Ap y/o As');
return;
end

% Determinar el tipo de filtro: pasabajo, pasoalto, paabanda o
parabanda
if (fp < fs),
tipo = 'lp';
elseif (fp > fs)
tipo = 'hp';
else
disp('Frecuencia de pasabanda = Frecuencia de parabanda');
return;
end
elseif (length(fp) == 2)
aux = [fp fs];
[aux1,i]=sort(aux);
if (i==[3 1 2 4])
tipo = 'bp';
elseif (i==[1 3 4 2])
tipo = 'bs';
else
disp('Error: Compruebe que los valores de fp y fs están en el
orden correcto');
return;
end
end
% Predistorsión para la Transformación bilineal
wp = 2*tan(2*pi*fp/(2*fm));
ws = 2*tan(2*pi*fs/(2*fm));
switch tipo
case 'lp',
switch type
case 'butter',
e2 = 10^(0.1*Ap)-1;
aux = 10^(0.1*As)-1;
wc = (1/e2)^(1/(2*n));
[Z,P,K]=buttap(n);
[Ban,Aan] = lp2lp(Ban,Aan,wc*wp);
[Bd,Ad]=bilinear(Ban,Aan,1);
case 'cheby1',
e2 = 10^(0.1*Ap)-1;
aux = 10^(0.1*As)-1;
[Ban,Aan] = lp2lp(Ban,Aan,wp);
case 'cheby2',
e2 = 1/(10^(0.1*As)-1);
aux = 10^(0.1*Ap)-1;
[Ban,Aan] = lp2lp(Ban,Aan,ws);
end
case 'hp',
wp = 1/wp;

ws = 1/ws;
switch type
case 'butter',
e2 = 10^(0.1*Ap)-1;
aux = 10^(0.1*As)-1;
wc = (1/e2)^(1/(2*n));
[Z,P,K]=buttap(n);
[Ban,Aan] = lp2hp(Ban,Aan,1/(wc*wp));
case 'cheby1',
e2 = 10^(0.1*Ap)-1;
aux = 10^(0.1*As)-1;
[Ban,Aan] = lp2hp(Ban,Aan,1/wp);
case 'cheby2',
e2 = 1/(10^(0.1*As)-1);
aux = 10^(0.1*Ap)-1;
[Ban,Aan] = lp2hp(Ban,Aan,1/ws);
end
case 'bp' % Hay que pasar a pasobajo las especificaciones
wx2 = wp(1)*wp(2);wx = sqrt(wx2);
if (ws(1)*ws(2) < wx2),
ws(1) = wx2/ws(2);
else
ws(2) = wx2/ws(1);
end
wp = wp(2)-wp(1);
ws = ws(2)-ws(1);
switch type
case 'butter',
e2 = 10^(0.1*Ap)-1;
aux = 10^(0.1*As)-1;
wc = (1/e2)^(1/(2*n));
[Z,P,K]=buttap(n);
[Ban,Aan] = lp2bp(Ban,Aan,wx,wp*wc);
case 'cheby1',
e2 = 10^(0.1*Ap)-1;
aux = 10^(0.1*As)-1;
[Ban,Aan] = lp2bp(Ban,Aan,wx,wp);
case 'cheby2',
e2 = 1/(10^(0.1*As)-1);
aux = 10^(0.1*Ap)-1;

[Ban,Aan] = lp2bp(Ban,Aan,wx,ws);
end
case 'bs',
wx2 = ws(1)*ws(2);wx = sqrt(wx2);
if (wp(1)*wp(2) < wx2),
wp(1) = wx2/wp(2);
else
wp(2) = wx2/wp(1);
end
wp = 1/(wp(2)-wp(1));
ws = 1/(ws(2)-ws(1));
switch type
case 'butter',
e2 = 10^(0.1*Ap)-1;
aux = 10^(0.1*As)-1;
wc = (1/e2)^(1/(2*n));
[Z,P,K]=buttap(n);
[Ban,Aan] = lp2bs(Ban,Aan,wx,1/(wp*wc));
case 'cheby1',
e2 = 10^(0.1*Ap)-1;
aux = 10^(0.1*As)-1;
[Ban,Aan] = lp2bs(Ban,Aan,wx,1/wp);
case 'cheby2',
e2 = 1/(10^(0.1*As)-1);
aux = 10^(0.1*Ap)-1;
[Ban,Aan] = lp2bs(Ban,Aan,wx,1/ws);
end
end
[H2,F]=freqz(Bd,Ad,500,fm);
H2db = 20*log10(abs(H2));
figure;plot(F,H2db,[fp fs],-[Ap As],'*');grid;zoom;
else
figure;plot(F,H2db,[fp fs],-[Ap Ap As As],'*');grid;zoom;
end
return;
Capítulo 9: Diseño de Filtros Digitales: Filtros FIR
Filtros FIR.
Secuencias Simétricas.

Técnicas de Diseño de Filtros FIR.
Método de las Series de Fourier.
Método del muestreo de frecuencia.
Métodos Iterativos basados en condiciones óptimas.
Diseño de Filtros FIR con MATLAB.
function [W,F] = specwin(w,M)
% w es el vector del que hay que calcular su DTFT
% M es el número de frecuencias en las que se quiere calcular la DTFT
% W es la DTFT de w
% F es el vector de frecuencias digitales 0 <= F <= 0.5
N=length(w);
W=zeros(1,M);
F=0:(M-1);F=F/(2*M);
for i=1:N,
W=W+w(i)*exp(-j*2*pi*i*F);
end
W=W/N;
Wlog=20*log10(abs(W));
plot(F,Wlog);grid;zoom;
return
function [B,Ap,As]=firfs1(N,fp,fs,fm,type,wtype)
% Determinar los coeficientes de la ventana
odd=rem(N+1,2);
wnd=wtype(1:4);
ft=type(1:2);
if (ft=='bs' | ft=='hp') & odd==0,
disp('Para los filtros parabanda y pasaalta el orden del filtro
debe ser par');
return
end
if wnd=='boxc',
w=boxcar(N+1)';
elseif wnd=='hamm',
w=hamming(N+1)';
elseif wnd=='hann',
w=hanning(N+1)';
elseif wnd=='blac',
w=blackman(N+1)';
else,
disp('Error. Ventana desconocida');return
end
% Transformar las frecuencias a frecuencias digitales
% de pasobajo
FFp=fp/fm;FFs=fs/fm;
if ft=='lp',
Fp=FFp;Fs=FFs;tipo=1; % Filtro Pasobajo

elseif ft=='bp' % Filtro
Pasabanda
% Hay que hacer que la pasabanda y la parabanda tenga la misma
frecuencia central
F0=(FFp(1)+FFp(2))/2;
% Habrá que modificar alguno de las especificaciones para obtener
una misma frecuencia
% con la menor banda de transición
[minimum,idx]=min([FFp(1)-FFs(1) FFs(2)-FFp(2)]);
if idx==1,
FFs(2)=FFp(2)+minimum;
else
FFs(1)=FFp(1)-minimum;
end
Fp=(FFp(2)-FFp(1))/2;Fs=(FFs(2)-FFs(1))/2;
elseif ft=='hp' % Filtro Pasoalto
Fp=FFs;Fs=FFp;
elseif ft=='bs' % Filtro Parabanda
% Lo mismo que en el caso de pasabanda
F0=(FFs(2)+FFs(1))/2;
[minimum,idx]=min([FFs(1)-FFp(1) FFp(2)-FFs(2)]);
if idx==1,
FFp(2)=FFs(2)+minimum;
else
FFp(1)=FFs(1)-minimum;
end
Fp=(FFs(2)-FFs(1))/2;Fs=(FFp(2)-FFp(1))/2;
else
disp('Error. Tipo de filtro desconocido');return
end
% Cálculo de coeficientes del filtro pasobajo ideal
% Tomamos una frecuencia de corte
% Fc=Fp+0.2(Fs-Fp)=0.8Fp+0.2Fs
Fc=0.8*Fp+0.2*Fs;
n=[-(N/2):N/2];
hLP=2*Fc*sinc(2*n*Fc);
% Pasar al filtro requerido con la ventana espectral especificada
unos=ones(1,N+1);
if ft=='lp', % Pasobajo
B=hLP.*w;
elseif ft=='bp', % Pasabanda
B=2*cos(2*pi*n*F0).*hLP.*w;
elseif ft=='hp', % Pasoalto
delta=zeros(1,N+1);delta((N+2)/2)=1;
B=(delta-hLP).*w;
elseif ft=='bs', % Parabanda
delta=zeros(1,N+1);delta((N+2)/2)=1;
B=(delta-2*cos(2*pi*n*F0).*hLP).*w;
end
[H,F]=freqz(B,1,500,fm);
Hdb=20*log10(abs(H));
plot(F,Hdb);grid;zoom;hold on;
A=freqz(B,1,[fp fs],fm);

A=-20*log10(abs(A));
if (ft=='lp' | ft=='hp'),
Ap=A(1);As=A(2);
plot([fp fs],-[Ap As],'r*');
else
Ap=A(1:2);As=A(3:4);
plot([fp fs],-[Ap As],'r*');
end
hold off;
return
function [B, h, H]=firmf(N,F,M,wtype)
% function [B]=firmf(N,F,M,wtype)
% N es el tamaño del filtro
% F es un vector de frecuencias 0<=F<=0.5 dadas en orden creciente
% El primer valor de F debe ser 0 y el ultimo 0.5
% M es un vector de magnitudes a las frecuencias especificadas por F
% wtype es el tipo de ventana espectral: boxcar, hamming, hanning o
blackman
type=wtype(1:4);
odd=rem(N,2);
Nn=512;
NF = length(F);
LF = Nn/2;
Fi=[0:LF];
df=1/Nn;
Fi=Fi*df;
DF=diff(F);
% Interpolar el vector M (N puntos) a 512 puntos
Ff=0;f=0;k=1;
for i=1:NF-1,
while f<=Ff+DF(i),
Mi(k)=M(i)+(f-F(i))*(M(i+1)-M(i))/(F(i+1)-F(i));
f=f+df;
k=k+1;
end
i=i+1;
Ff=F(i);
end
H=Mi.*exp(-sqrt(-1)*2*pi*Fi*(Nn-1)/2);
H = [H conj(H(LF:-1:2))];
h=real(ifft(H));
% Aplicar la ventana escogida
if type=='boxc',
w=boxcar(N)';
elseif type=='hamm',

w=hamming(N)';
elseif type=='hann',
w=hanning(N)';
elseif type=='blac',
w=blackman(N)';
else
disp(['El tipo de ventana especificado no existe']);
return
end
B = h(LF-N/2+1:LF+N/2).*w;
% Si N es impar, el punto medio de la serie de 512 puntos está en el
índice 257
% Si N es par, los puntos medio están en los índices 257 y 258
[Ht,Wt]=freqz(B,1,512);
Htdb=20*log10(abs(Ht));
plot(Wt/(2*pi),abs(Ht), F, M, 'or');zoom;grid;
return
Método de las Series de Fourier
Filtro Pasobajo
%Método de las series de Fourier
%Filtro pasobajo
%Especificaciones
fp=1500;
fs=3000;
fm=8000;
Ap=1;
As=45;
%Se calculan las frecuencias digitales
Fp=fp/fm;
Fs=fs/fm;
%Cálculo del orden del filtro
Ws=1.91;
%Se obtiene de la tabla 3 de los apuntes
%En este caso vamos a utilizar la ventana de Hamming
N=ceil(Ws/(Fs-Fp));
%Frecuencia de corte
Fc=1.1*Fp;
%Filtro pasobajo
n=[-(N-1)/2:(N-1)/2];
%Se aplica la ventana de Hamming
h=hLP.*hamming(N)';
[H,F]=freqz(h,1,1000,fm);
plot(F,20*log10(abs(H)));hold on;
plot([fp fs],[-Ap -As],'*r');

Filtro Pasoalto
%Método de las series de Fourier
%Filtro pasoalto%Especificaciones
fp=5000;
fs=4000;
fm=14000;
Ap=1;
As=45;
FpHP=fp/fm;
FsHP=fs/fm;
%Se calcula las especificaciones del filtro pasabajo
Fp=FsHP;
Fs=FpHP;
Ws=1.91; %Se
obtiene de la tabla 3 de los apuntes
N=ceil(Ws/(Fs-Fp)); %N es el número de puntos (el
orden es N-1)
Fc=1.1*Fp;
%Filtro pasobajo
n=[-(N-1)/2:(N-1)/2];
hLP=hLP.*hamming(N)';
%Se calcula el filtro pasaalto
delta=zeros(1,N);
delta((N)/2)=1;
hHP=delta-hLP;
%Calculamos el filtro pasoalto
[H,F]=freqz(hHP,1,1000,fm);
plot([fs fp],[-As -Ap],'*r');
Filtro Pasabanda
%Filtro pasabanda utilizando el método de las series de Fourier
%Especificaciones
fp=[2000 3000];
fs=[500 5000];
fm=12000;
Ap=1;
As=45;
ffp=fp/fm;
ffs=fs/fm;

%Se modifican las especificaciones para obtener una misma frecuencia
%con la menor banda de transición
[minimum, idx]=min([ffp(1)-ffs(1) ffs(2)-ffp(2)]);
if idx==1
ffs(2)=ffp(2)+minimum;
else
ffs(1)=ffp(1)-minimum;
end
%Por la tabla 2
Fp=(ffp(2)-ffp(1))/2;
Fs=(ffs(2)-ffs(1))/2;
Fo=(ffp(2)+ffp(1))/2;
Ws=1.91;
N=ceil(Ws/(Fs-Fp));
Fc=1.1*Fp;
%Filtro pasobajo
n=[-(N-1)/2:(N-1)/2];
%Filtro pasabanda
hBP=2*cos(2*pi*n*Fo).*hLP;
[H,F]=freqz(hBP,1,1000,fm);
plot([fp fs],[-[Ap Ap] -[As As]],'*r');
Filtros Parabanda
%Especificaciones
fs=[2000 4000];
fp=[500 5000];
fm=12000;
Ap=1;
As=30;
ffp=fp/fm;
ffs=fs/fm;
%Se modifican las especificaciones para obtener una misma frecuencia
%con la menor banda de transición
[minimum, idx]=min([ffs(1)-ffp(1) ffp(2)-ffs(2)]);
if idx==1
ffp(2)=ffs(2)+minimum;
else
ffp(1)=ffs(1)-minimum;
end
%Por la tabla 2

Fp=(ffs(2)-ffs(1))/2;
Fs=(ffp(2)-ffp(1))/2;
Fo=(ffs(2)+ffs(1))/2;
Ws=1.91;
N=ceil(Ws/(Fs-Fp));
Fc=1.5*Fp;
%Filtro pasobajo
n=[-(N-1)/2:(N-1)/2];
%Filtro parabanda
hBP=2*cos(2*pi*n*Fo).*hLP;
delta=zeros(1,N);
delta((N+1)/2)=1;
hSB=delta-hBP;
[H,F]=freqz(hSB,1,1000,fm);
plot([fp fs],[-[Ap Ap] -[As As]],'*r');
Método del muestreo de frecuencia
Filtro Pasobajo
clear;
j = sqrt(-1);
H=zeros(1,16);
H(1) = 1;
H(2) = exp(-j*pi*15/16);
H(3) = 0.7*exp(-j*pi*30/16);
% H(4) = exp(-j*pi*45/16);
% H(5) = exp(-j*pi*60/16);
% H(13) = conj(H(5));
% H(14) = conj(H(4));
H(15) = conj(H(3));
H(16) = conj(H(2));
h = real(ifft(H));
[Hf,Wf] = freqz(h,1,512);
Ff = Wf/(2*pi);
F=[0:8]/16;
plot(Ff,abs(Hf),F,abs(H(1:9)),'o');zoom;grid;
hold;
h = h.*hamming(16)';
Hf1 = freqz(h,1,512);
plot(Ff,abs(Hf1),'r');

% Usando la funcion fir2
B = fir2(15,[0 1 2 3 4 5 6 7 8]*2/16,[1 1 0.7 0 0 0 0 0
0],boxcar(16));
Hf2 = freqz(B,1,512);
plot(Ff,abs(Hf2),'m');
Filtro Pasabanda
clear;
j = sqrt(-1);
H=zeros(1,12);
H(1) = 0;
H(2) = 0;
H(3) = 0.7*exp(-j*pi*2*11/12);
H(4) = exp(-j*pi*3*11/12);
H(5) = 0.7*exp(-j*pi*4*11/12);
H(9) = conj(H(5));
H(10) = conj(H(4));
H(11) = conj(H(3));
h = real(ifft(H));
[Hf,Wf] = freqz(h,1,500);
Ff = Wf/(2*pi);
F=[0:6]/12;
plot(Ff,abs(Hf),F,abs(H(1:7)),'o');zoom;grid;
hold;
h = h.*hamming(12)';
Hf1 = freqz(h,1,500);
plot(Ff,abs(Hf1),'r');
% Usando la funcion fir2
B = fir2(11,[0 1 2 3 4 5 6]*2/12,[0 0 0.7 1 0.7 0 0],boxcar(12));
Hf2 = freqz(B,1,500);
plot(Ff,abs(Hf2),'m');
Capítulo 10: Implementación de Filtros Digitales
Realización de Filtros Digitales.
Efectos de cuantización.
Implementación Hardware de Filtros Digitales:
Hardware : Bit-Serial : use-bitserial.ps, imp-bitserial.pdf
FPGAs (dsp40k.pdf)
Programas en Matlab
function [Hq,SOSq] = quantsos(B,A,b)
% [Hq,SOSq] = quantsos(B,A,b)
% Genera la respuesta frecuencial Hq del filtro digital (B,A) al ser
% cuantizado con b bits utilizando secciones de 2º Orden
% SOS es una matriz que muestra los valores cuantizados de los
% coeficientes de las secciones de 2º Orden
if (A==1) % Filtro FIR
B = fliplr(B);
A = [1 zeros(1,length(B)-1)];

end
[H,F]=freqz(B,A,500); % Respuesta frecuencial del filtro con
coeficientes reales
Hdb=20*log10(abs(H));
BAmax = max([B;A]);
if (BAmax >1)
powof2 = floor(log(BAmax)/log(2));
else
powof2 = 0;
end
Bfixed = B/(2^powof2);Bq = round(Bfixed*(2^b))/(2^b);
Afixed = A/(2^powof2);Aq = round(Afixed*(2^b))/(2^b);
[Hq,F]=freqz(Bq,Aq,500); % Respuesta frecuencial del filtro con
coeficientes cuantizados (forma directa)
Hqdb = 20*log10(abs(Hq));
% Poner la función de transferencia como producto de secciones de 2º
Orden
[Z,P,K]=tf2zp(B,A);
SOS = zp2sos(Z,P,K);
SOSmax=ceil(max(max(abs(SOS)))); % Calcula el menor entero que es
mayor que el maximo de los
if (SOSmax > 1)
powof2 = floor(log(SOSmax)/log(2)); % coeficientes de 2º Orden
(ceil) y halla la potencia de 2
else
% cercana a ese número.
powof2 = 0;
end
SOSfixed=SOS/(2^powof2); % Escala todos los coeficientes de los
términos de 2º Orden por
% esa potencia de dos (dividir
por potencias de 2 es muy sencillo
% en un microprocesador, solo
hay que desplazar bits. Cualquier cosa
% antes que realmente dividir!!)
SOSq = round(SOSfixed*2^b)/(2^b); % Cuantización de los coeficientes
en punto fijo con b bits
[r,c]=size(SOSq); % r es el numero de
secciones de 2º Orden
Hq=ones(500,1); % Inicializar el vector de la respuesta del filtro
cuantizado
for i=1:r,
Bp=SOSq(i,1:3);Ap=SOSq(i,4:6); % Determinar los coeficientes del
numerador y denominador
Hp=freqz(Bp,Ap,500); % Respuesta frecuencial de la seccion de
2º Orden r
Hq=Hq.*Hp; % Configuración en cascada, asi que deben
multiplicarse sucesivamente
end
HSOSqdb=20*log10(abs(Hq));

plot(F,Hdb,'b',F,Hqdb,'r',F,HSOSqdb,'g');grid;zoom;
return
Capítulo 11: Aplicaciones de Filtros Digitales
PDF: tema11.pdf (275 KB)
Aplicaciones
Diferenciadores y Transformación de Hilbert.
Interpolación y Decimación.
Filtros Pasatodo, Peine y Notch.
Convolución : convolver.pdf
Detectción de Bordes : edge.pdf
Tratamiento Digital de
Señal
Profesor
Andoni Irizar Picón airizar@ceit.es
Resumen
Conceptualmente, el tratamiento digital de señal no difiere gran cosa del
control digital impartido en 4º Curso. Pondremos más enfásis en el concepto
de la Transformada Discreta de Fourier y su algoritmo correspondiente (FFT) y
estudiaremos los dos tipos principales de filtros digitales: IIR (Infinite Impulse
Response) y FIR (Finite Impulse Response). Finalmente, se estudiarán los
problemas que presentan los filtros digitales a la hora se su implementación
real (efectos de cuantización) y como solucionarlos.

Nuevo en esta página
4 de diciembre de 2001: script_clase.m
18 de diciembre de 2001:script_clase2.m
8 de enero de 2002: firdig.m iirdig.m
20 Noviembre de 2002:
Programas de diseño de filtros analógicos
Prototipos Filtro Pasobajo
Butterworth: butter_ana_ej.m
Chebyshev-I: cheb1_ana_ej.m
Chebyshev-II: cheb2_ana_ej.m
Filtro pasoalto
Butterworth: hp_butter_ej.m
Chebyshev-I: hp_cheb1_ej.m
Chebyshev-II: hp_cheb2_ej.m
Filtro pasabanda
Butterworth: bp_butter_ej.m
Chebyshev-I: bp_cheb1_ej.m
Chebyshev-I: bp_cheb2_ej.m
Filtro parabanda
Butterworth: bs_butter_ej.m
Chebyshev: bs_cheb1_ej.m
Chebyshev-I: bs_cheb2_ej.m
Programas de diseño de filtros digitales IIR
Predistorsión : warping.m
Ejemplo Transformación bilineal: transf_bilineal_ej.m
Filtro pasabanda Butterworth: bp_butter_discr_ej.m
Programas de diseño de filtros digitales FIR
Ventanas espectrales: spec_window.m
Coeficientes filtro ideal: h_ideal.m
Filtro pasobajo ideal: fir_lp_ideal.m
Filtro pasobajo: lp_fir.m
Filtro pasoalto: hp_fir.m
Filtro pasabanda: bp_fir.m
Filtro parabanda: bs_fir.m
Diseño general de filtros FIR (metodo de las ventanas): firdig.m
Programa de la Asignatura
Capítulo 1: Señales y Sistemas
Clasificación de Señales y Sistemas.
Respuesta a impulso de sistemas lineales invariantes en el
tiempo.

Capítulo 2: Convolución
Concepto y Definición de Convolución.
Propiedades.
Correlación y Autocorrelación.
Convolución Discreta.
Capitulo 3: Series y Transformada de Fourier
Capítulo 4: Transformada de Laplace
Capítulo 5: Muestreo y Cuantización
Convertidores Analógico-Digitales.
Capítulo 6: Transformada Discreta de Fourier
Transformada Discreta de Fourier (DFT).
Transformada Rápida de Fourier (FFT).
Ejemplos en Matlab: fftej1.m, fftej2.m, fftej3.m, fftej4.m,
fftej5.m, fftej7.m, fftej8.m
Tiempo de procesamiento de FFT para algunos micros y DSPs
µp FFT 256 puntos FFT 1024 puntos
Pentium 166 MHz 2.5 ms 11.6 ms
Pentium II 200 MHz 1.2 ms 5.4 ms
ADSP 2115 20 MHz 0.69 ms 1.86 ms
TMS320C52 30 MHz 0.73 ms 2.45 ms
TMS320C67 167 MHz 0.0257 ms 0.124 m
Capítulo 7: Transformada Z
Definición y Propiedades.
Transformada Inversa.

Función de Transferencia Discreta.
Análisis de Sistemas.
Capítulo 8: Diseño de Filtros Digitales - Filtros IIR
Terminología y Clasificación.
Filtros IIR.
Diseño de Filtros Analógicos (Butterworth, Chevyshev I y
II, elípticos).
Métodos de Transformación del plano s al plano z.
Diseño de Filtros IIR con MATLAB
-Analógicos
Filtros Pasobajo (lowfilt.m)
Filtros Pasoalto (highfilt.m)
Filtros Pasabanda (pasafilt.m)
Filtros Parabanda (parafilt.m)
- Digitales
Utilizando la transformada bilineal
Filtros Pasobajo ( lowdig.m)
Filtros Pasoalto (highdig.m)
Filtros Pasabanda (pasadig.m)
Filtros Parabanda (paradig.m)
Utilizando la transformada invariante a impulso
(invar_lp.m)
Función de Matlab para el diseño de todo tipo de filtros
IIR
Analógicos iirafilt.m
Digitales iirdfilt.m
Capítulo 9: Diseño de Filtros Digitales: Filtros FIR
Filtros FIR.
Secuencias Simétricas.
Técnicas de Diseño de Filtros FIR.
Método de las Series de Fourier.
Método del muestreo de frecuencia.
Métodos Iterativos basados en condiciones óptimas.
Diseño de Filtros FIR con MATLAB.
specwin.m
firfs1.m
firmf.m
Método de las Series de Fourier
Filtro Pasobajo (firsflp.m)

Filtro Pasoalto (firsfhp.m)
Filtro Pasabanda (firsfbp.m)
Filtros Parabanda (firsfsb.m)
Método del muestreo de frecuencia
Filtro Pasobajo (mf16.m, mf17.m)
Filtro Pasabanda (mfbp.m)
Capítulo 10: Implementación de Filtros Digitales
Realización de Filtros Digitales.
Efectos de cuantización.
Implementación Hardware de Filtros Digitales:
Hardware : Bit-Serial : use-bitserial.ps, imp-bitserial.pdf
FPGAs (dsp40k.pdf)
Programas en Matlab
quantsos.m
Capítulo 11: Aplicaciones de Filtros Digitales
Aplicaciones
Diferenciadores y Transformación de Hilbert.
Interpolación y Decimación.
Filtros Pasatodo, Peine y Notch.
Convolución : convolver.pdf
Detectción de Bordes : edge.pdf
Problemas
Aquí tienen una serie de problemas para practicar durante las vacaciones de
Navidad. Todos menos uno son para hacer en Matlab:
Problemas.doc. Los problemas resueltos los tienen aquí, aunque se
recomienda intentarlo antes de mirar (prob1.m, prob1b.m, prob1e.m,
prob2.m, prob2mf.m, prob2r.m, prob2ls.m, prob4c.m, prob5.m, prob6.m,
prob7.m, prob7a.m.)
Prácticas
Trabajo opcional
Implementar en C una FFT de 1024 puntos. Los datos de
entrada se encuentran en los ficheros:
- real.dat (parte real de la señal)

- imag.dat (parte imaginaria)
El programa deberá escribir los datos de salida en dos
ficheros (uno para la parte real y otro para la imaginaria).
Se deberá enviar los archivos .c y .h a la dirección de
correo airizar@ceit.es antes del 15 de diciembre.
Exámenes
El examen consta de dos partes: una teórica y otra práctica, esta última por
ordenador. Disponen de una copia del examen del año pasado en Word:
1998
Febrero Teórico
Febrero Práctico
Septiembre Teórico
Septiembre Práctico
1999
Febrero Teórico
Febrero Práctico
Septiembre Teórico
Septiembre Practico
2000
Febrero Teórico 1
Febrero Teórico 2
Febrero Práctico 1
Solución Problema 1
Febrero Práctico 2
Septiembre Teórico
2001
Febrero Teórico
Febrero Práctico
Septiembre Teórico

2002
Febrero Teórico 1
Febrero Práctico 1
Febrero Teórico 2
Febrero Práctico 2
2003
Febrero Teórico
Febrero Práctico
Septiembre Teórico
2004
Febrero Teórico
Febrero Práctico
Septiembre Teórico
2005
Febrero Teórico
Febrero Práctico
Septiembre Teórico
2006
Febrero Teórico
Febrero Práctico
Septiembre Teórico

2007
Febrero Teórico 1
Febrero Práctico 1
Febrero Teórico 2
Febrero Práctico 2
Septiembre Teórico
2008
Febrero Teórico 1
Febrero Práctico 1
Febrero Teórico 2
Febrero Práctico 2
Septiembre Teórico
2009
Febrero Teórico
Febrero Práctico
Septiembre Teórico
Curso 2009-2010
Diciembre 09 Teórico
Diciembre 09 Práctico

Bibliografía
• "Señales y Sistemas", Alan V. Oppenheim and Alan S. Willsky, Prentice-Hall
Hispanoamericana, 1983.
• "Introduction to Digital Signal Processing", John G. Proakis and Dimitris G. Manolakis,
Macmillan Publishing Company, 1988.
• "Analog and Digital Signal Processing", Ashok Ambardar", PWS Publishing Company,
1995.
• "Digital Signal Processing: A Computer-Based Approach", Sanjit K. Mitra, McGraw-Hill,
1998.
• "Digital Signal Processing using MATLAB", Vinay K. Ingle and John G. Proakis, PWS
Publishing Company, 1997.
• "Digital Filters and Signal Processing", Leland B. Jackson, Kluwer Academic Publishers,
1986.
• "Digital Audio Signal Processing", Udo Zölzer, John Wiley & Sons, 1995.
Links Interesantes
Estos links son externos. Para acceder a ellos debes utilizar los ordenadores de
la Sala B.
Texas Instruments DSP. Todo acerca de los DSP de Texas Instruments y
montones de aplicaciones de procesamiento de señal (en formato PDF).
Motorola DSP Lo mismo que el anterior, pero con los DSPs de Motorola.
Analog Devices DSP Más DSP, esta vez de Analog Devices.
SPIB-Signal Processing Information Base SPIB contiene información sobre
grupos, artículos, software, bibliografías etc, en procesamiento de señal.
Chaos Homepage Una página dedicada a los sistemas caóticos
Computer Vision Homepage : Links a grupos dedicados a Visión Artificial,
software, demos, publicaciones, imágenes de test, etc.
Otros Links
Forofos del Athletic y de Microsoft, abstenerse. Son también links externos.
The Linux Documentation Project : Linux es un sistema operativo para
PCs (y workstations) disponible gratuitamente. En esta página lo
encontarás todo sobre Linux.
Scientific Applications on Linux : Gran cantidad de software científico
para Linux. La gran mayoría son gratis y se obtienen con su código

fuente en C ó C++.
Sunsite Central Europe: Todo el software que quieras y más, todo gratis,
principalmente para Unix, Linux y Windows95.
Hamburg VHDL Archive : Standards en VHDL, manuales, tutoriales,
modelos etc.
Latex es un procesador de texto que no es WYSIWYG. También gratis.
Intel Secrets: Todo lo que Intel no quiere que sepas sobre sus micros.
The GIMP es un programa de procesamiento de imágenes (tipo Adobe
Photoshop) pero es gratis. Disponible en código fuente, por lo que los
usuarios pueden modificar el programa y añadir nuevos algoritmos de
tratamiento de imagen, por ejemplo. Para plataformas Unix o Linux.
Real Sociedad Pese a todo, este link no podía faltar.

Paginas pds

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (8)

Andere mochten auch

Andere mochten auch (20)

Ähnlich wie Paginas pds

Ähnlich wie Paginas pds (20)

Paginas pds