Übung 10: Matlab-Entwurf von IIR

ZHAW, DSV1, FS2010, Rumc, 1
Übung 10: Matlab-Entwurf von IIR-Filtern
Aufgabe 1: Bilineare Transformation.
Entwerfen Sie (von Hand) ein digitales Butterworth-TP-Filter 1. Ordnung mit einer
3 dB Eckfrequenz von fdigital_DB = 1000 Hz. Die Abtastfrequenz betrage fs = 5000 Hz.
Gehen Sie vom analogen Prototyp-Filter
H(s) = 1 / (1+s/wDB)
aus, wobei wDB = 2π·fanalog_DB , das einen Pol bei s = -wDB und eine Nullstelle bei s=∞
aufweist.
a) Bestimmen Sie mit “prewarping” die analoge 3 dB Eckfrequenz fanalog_DB bzw. wDB.
b) Bestimmen Sie mit Hilfe der bilinearen sz-Transformation die z-UTF H(z).
c) Wie lauten die b,a-Filterkoeffizienten des Digitalfilters H(z)?
d) Bestimmen Sie den Pol und die Nullstelle von H(z).
Wohin bildet die bilineare Transformation den Pol und die Nullstelle von H(s) ab?
Aufgabe 2: IIR-Filterentwurf mit analogen Prototypen.
Die Spezifikation für ein digitales Tiefpassfilter lautet:
Abtastfrequenz:
fs = 8 kHz
Durchlassbereich: Eckfrequenz fDB = 1 kHz, max. Dämpfung Amax = Rp = 1.2 dB
Sperrbereich:
Eckfrequenz fSB = 2 kHz, min. Dämpfung Amin = Rs = 40 dB
Entwerfen Sie ein IIR-Filter mit kleinster Ordnung, das die obige Filterspezifikation
(gerade noch) erfüllt, und
a) Rippel im Durchlass- und im Sperrbereich aufweist.
b) einen monoton fallenden Durchlass- und Sperrbereich aufweist.
c) einen monoton fallenden Durchlassbereich und Rippel im Sperrbereich aufweist.
Geben Sie je den Filtertyp (z.B. Butterworth-Filter), die minimale Filterordnung N und
die (floating point) Filterkoeffizienten an und plotten Sie den Amplitudengang im Bereich
[0 Hz,..., 4 kHz] bzw. [-80 dB, ..., 3 dB]. Sie können dazu die Vorlage dsv1ueb102.m
verwenden.
ZHAW, DSV1, FS2010, Rumc, 2
Aufgabe 3: FIR-Filter und Skalierung.
Das FIR-BP-Filter mit den b-Koeffizienten
b = [0.0139 0.0419 -0.1219 -0.2272 0.3022 0.3022 -0.2272 -0.1219 0.0419 0.0139]
weist den folgenden Frequenzgang auf (fs = 8 kHz):
Nehmen Sie für das Folgende an, dass das Eingangssignal x[n] und das Ausgangssignal
y[n] im Q0.15-Format dargestellt werden.
a) Bestimmen Sie die Zeitverzögerung dieses FIR-Filters für Eingangsfrequenzen f < fs/2.
b) Bestimmen Sie die l∞-Norm und interpretieren Sie den gefundenen Wert.
c) Kann die FIR-Summe bzw. der Ausgang überlaufen bzw. grösser als 1 werden?
Wenn ja, geben Sie ein „kritisches“ Eingangssignal x[n] an?
d) Wie müssten Sie den Eingang bzw. die b-Koeffizienten skalieren, damit der Ausgang in
keinem Fall überläuft? Wie stark verschlechtert sich dann das SNR?
e) Bestimmen Sie die l2-Norm und zeigen Sie, dass l2 ≤ l∞ ≤ l1 gilt.
ZHAW, DSV1, FS2010, Rumc, 3
Aufgabe 4: Skalierung IIR-Biquad-Filter.
a) Entwerfen Sie mit Matlab ein elliptisches IIR-TP-Filter 2. Ordnung, das die folgende
Spezifikation erfüllt:
- Durchlassbereich: Eckfrequenz fDB = 100 Hz, Amax = 0.1 dB
- Sperrbereich: Amin = 25 dB
- Abtastfrequenz: fs = 8000 Hz
Wo liegt die Eckfrequenz fSB des Sperrbereichs?
Wie steil ist das Filter ungefähr in dB pro Oktave und Ordnung?
b) Das Filter soll in der Direktstruktur 2 realisiert werden.
Geben Sie die Differenzengleichungen zur Berechnung von w[n] und y[n] an.
x[n]
w[n]
gin=1
-a1
z-1
-a2
bo
gout=1
y[n]
b1
b2
w[n-2]
c) Eingang x[n] und Ausgang y[n] liegen im Q0.15-Wertebereich.
Skalieren Sie das IIR-Filter bzw. die betreffenden Differenzengleichungen so, dass
- alle a-Filterkoeffizienten so genau wie möglich im Q0.15-Format dargestellt werden,
-
alle b-Filterkoeffizienten so genau wie möglich im Q0.15-Format dargestellt werden
-
und die Summator-Ausgänge w[n] und y[n] zumindest für sinusförmige Eingangssignale x[n] nicht überlaufen.
Sie können die 3 Skalierungsschritte auch im Blockdiagramm oben einzeichnen. Eine
UTF eines Systems S ändert sich übrigens nicht, wenn alle einlaufenden Pfade in ein
Teilsystem T mit 1/g und alle aus dem Teilsystem T auslaufenden Pfade mit g skaliert
werden.
Wählen Sie nach der Skalierung die Ein- und die Ausgangsverstärkung gin und gout so,
dass Sie nur mit Schiebeoperationen implementiert werden können.
Geben Sie die skalierten Differenzengleichungen zur Berechnung von w[n] und y[n]
in Matlab-Notation an.
d) Filtern Sie mit dem skalierten IIR-Filter einen 75 Hz und einen 458 Hz Ton und
vergewissern Sie sich, dass es keine Überläufe gibt und dass die Amplitude bei der
Filterung des 458 Hz Tons um den Faktor 10 abnimmt.
Sie können die Matlab-Vorlage dsv1ueb104.m verwenden.
ZHAW, DSV1, FS2010, Rumc, 4
Musterlösung
Aufgabe 1
a) prewarping bzw. Vorverzerrung ergibt:
fanalog_DB = 1156.3 Hz
b) ersetzen von s =
bzw.
wDB = 2·fs·tan(π·fdigital_DB/fs) = 7265.4
2 z −1
⋅
gibt: H ( z ) =
Ts z + 1
1
z −1
1+ c ⋅
z +1
wobei c = 2fs/wDB = 1.3764
=> H ( z ) =
1 + z −1
z +1
z +1
=
=
z + 1 + c ⋅ ( z − 1) (1 + c) ⋅ z + (1 − c) (1 + c) + (1 − c) ⋅ z −1
=> H ( z ) =
1
⋅
1+ c
1 + z −1
1 − c −1
⋅z
1+
1+ c
c) b = [1 1] / (1+c) = [0.4208
0.4208] und a = [1 (1-c)/(1+c)] = [1 -0.1584]
Betragsspektrum IH(f)I des resultierenden Digitalfilters:
Die 3 dB Eckfrequenz liegt exakt bei fdigital = 1000 Hz. Das Butterworth-Filter weist einen
monoton fallenden Amplitudengang auf.
d) Die bilineare Transformation bildet die Nullstelle bei s = ∞ auf z = -1 und den Pol bei
s = - wDB auf z = -(1-c)/(1+c) = 0.1584 ab.
Die bilineare Transformation bildet die linke Halbebene der s-Ebene einmal ins Innere
des Einheitskreises der z-Ebene ab.
Jedes Butterworth-TP-Filter weist nur Nullstellen bei z = -1 auf (keine Rippel im Sperrbereich).
ZHAW, DSV1, FS2010, Rumc, 5
Aufgabe 2
a) Elliptisches TP-Filter mit Ordnung N=3
b = [0.03816301301598 0.04586583864283 0.04586583864283 0.03816301301598]
a = [1.00000000000000 -1.90361085926265 1.56176730013500 -0.49009873755473]
b) Butterworth TP-Filter mit Ordnung N=6
b = [0.00173758552778 0.01042551316669 0.02606378291673 0.03475171055564
0.02606378291673 0.01042551316669 0.00173758552778]
a = [1.00000000000000 -2.65904646691458 3.44650711546946 -2.56339653248472
1.13889925502283 -0.28194993197852 0.03019203466357]
ZHAW, DSV1, FS2010, Rumc, 6
c) Chebyscheff TP-Filter, Typ II, mit Ordnung N=4
b = [0.04581460157325 0.07545934376770 0.10240910939902 0.07545934376770
0.04581460157325]
a = [1.00000000000000 -1.52326248034477 1.25373904896926 -0.46024027012053
0.07472070157696]
Hinweis: Alle entworfenen Filter sollten mit Vorteil als Biquad-Kaskade realisiert werden.
Dazu müssen die Filterkoeffizienten noch mit der Funktion tf2sos umgerechnet werden.
Matlab-Code:
Clear; format long
% Parameter
% ===========================================================
fs=8000;
% Abtastfrequenz
fDB=1000;
% Eckfrequenz Durchlassbereich
fSB=2000;
% Eckfrequenz Sperrbereich
Rp=1.2;
% maximale Dämpfung im Durchlassbereich
Rs=40;
% minimale Dämpfung im Sperrbereich
% Filterentwurf
% ============================================================
% [N,w]=ellipord(fDB/(fs/2),fSB/(fs/2),Rp,Rs);
% [b,a]=ellip(N,Rp,Rs,w);
% [N,w]=buttord(fDB/(fs/2),fSB/(fs/2),Rp,Rs);
% [b,a]=butter(N,w);
[N,w]=cheb2ord(fDB/(fs/2),fSB/(fs/2),Rp,Rs);
[b,a]=cheby2(N,Rs,fSB/(fs/2));
%
%
N
b
a
Ausgabe
============================================================
% schreibt die Filterordnung auf den Bildschirm
% schreibt die Filterkoeffizienten auf den Bildschirm
% schreibt die Koeffizienten auf den Bildschirm
ZHAW, DSV1, FS2010, Rumc, 7
% Amplitudengang
% ============================================================
[H,w]=freqz(b,a);
plot((w/pi)*(fs/2),20*log10(abs(H)),'LineWidth',2.0); grid;
xlabel('Frequenz [Hz]');
ylabel('Amplitudengang [dB]');
axis([0 4000 -80 3]);
print -dpng tmp % generiert das png-File tmp.png des Plots
% das ins Word-Dokument importiert werden kann
Aufgabe 3
a) Das FIR-Filter hat Ordnung N=9 und ist linearphasig
=> Zeitverzögerung τ = 4.5·Ts = 0.5625 ms für alle Frequenzen f < fs/2.
Man kann die Zeitverzögerung der Frequenzkomponente f0 auch wie folgt bestimmen:
Δ0 =
− ϕ (f0 )
= (405/360)·2π / (2π·2000) = 0.5625 ms unabhängig von f0.
2π ⋅ f0
b) Die l∞-Norm = max IH(f)I = 1. Der Ausgang kann für sinusförmige Eingangssignale nicht
überlaufen. Es ist aber immer noch möglich, dass Zwischensummen überlaufen, wenn
der Akkumulator keine Guard-Bits aufweist.
c) Der Ausgang kann für nicht-sinusförmige Eingangssignale wie z.B.
x[n] = { … -1 -1 1-ε 1-ε -1 -1 … } , ε <<1, überlaufen! Dann erscheint nämlich die
Summe der Beträge der (grössten) b-Koeffizienten am Ausgang und die ist hier > 1.
d) Der Eingang bzw. die b-Koeffizienten müssten durch die l1-Norm dividiert werden,
wobei die l1-Norm = sum(abs(b)) = 1.4142 = √2.
Das SNR verschlechtert sich dann um 20·log10(√2) = 3 dB.
e) L2-Norm = 0.5653 < l∞-Norm = 1 < l1-Norm = √2.
Aufgabe 4
a) Matlab-Code:
[b,a]=ellip(2,0.1,25,fDB/(fs/2))
figure(1)
freqz(b,a,4096,fs);
Filterkoeffizienten:
b = [ 0.055976261401186 -0.093358806169603 0.055976261401186 ]
a = [ 1.000000000000000 -1.816100033932020 0.834909055656060 ]
Eckfrequenz des Sperrbereichs: fSB = 536.1 Hz
Filtersteilheit ≈ 6 dB pro Oktave und Ordnung
b) w[n] = gin·x[n] - a1·w[n-1] - a2·w[n-2]
y[n] = gout · ( b0·w[n] + b1·w[n-1] + b2·w[n-2] )
ZHAW, DSV1, FS2010, Rumc, 8
c) Schritt 1 (siehe auch Grafik unten): Die a-Filterkoeffizienten liegen teilweise ausserhalb
des Q0.15-Zahlenformats. Deshalb skalieren wir die w-Differenzengleichung mit 2, d.h.
w[n] = 2·( gin·x[n]/2 - a1/2·w[n-1] - a2/2·w[n-2] )
x[n]
w[n]
gin=1
1/gs bs
/2
2
-a1 /2
z-1
-a2/2
Schritt 1
bo /bs
gout=1
gs
y[n]
b1 /bs
b2 /bs
w[n-2]
Schritt 2
Schritt 3
Schritt 2 (siehe auch Grafik oben): Die b-Filterkoeffizienten liegen zwar im Q0.15-Wertebereich, sie sind aber so klein, dass sie bei der Q0.15-Quantisierung zu ungenau dargestellt werden (Verschiebung der Nullstellen!). Deshalb skalieren wir die b-Koeffizienten
mit 1/bs, wobei bs = abs(min(b)) bzw. bs = 0.093358806169603, und kompensieren die
Verstärkung 1/bs am Eingang mit bs.
Schritt 3 (siehe auch Grafik oben): Der Ausgang y[n] überläuft für stationäre Signale
nicht, siehe Filterspezifikation. Das Zwischenresultat w[n] überläuft hingegen schon. Wir
skalieren den Eingang deshalb mit 1/gs und kompensieren am Ausgang entsprechend
mit gs. Der Faktor gs = bs·max (IW(f)/X(f)I) = bs·max (1/IA(f)I) = 0.093358806169603 ·
54.389431813254888 = 5.077732422328502.
Wenn statt gin = bs / (2gs) = 0.009192962370277 der (nächst) kleinere Wert gin = 1/128
gewählt wird (leichte SNR-Verschlechterung), dann kann die Eingangsskalierung mit
einer Schiebe-Operation realisiert werden.
Wenn statt gout = gs = 5.0777 der (nächst) kleinere Wert gout = 4 gewählt wird (leichte
SNR-Verschlechterung), dann kann auch die Ausgangsskalierung mit einer SchiebeOperation realisiert werden.
Die resultierenden Differenzengleichungen in Matlab-Notation lauten:
w(n)=2*(gin*x(n)-ascal(2)*w(n-1)-ascal(3)*w(n-2));
ys(n)=gout*(bscal(1)*w(n)+bscal(2)*w(n-1)+bscal(3)*w(n-2));
wobei
gin=1/128, ascal(2)= -29755/32768, ascal(3)= 13679/32768, gout=4,
bscal(1)= 19647/32768 = bscal(3), bscal(2)= -32768/32768
ZHAW, DSV1, FS2010, Rumc, 9
d) Simulationsresultate:
Bei der Filterung des 458 Hz Tons resultiert eine 10 mal kleinere Amplitude.
% ============================================
% Biquad Skalierung
% ============================================
clear; close all;
% Parameter
% ============================================
fs=8000;
Ns=800;
f0=75;
fDB=100;
% IIR-Filter
% ============================================
[b,a]=ellip(2,0.1,25,fDB/(fs/2))
figure(1)
freqz(b,a,4096,fs);
% Input
% ============================================
x=cos(2*pi*f0*[0:Ns-1]/fs);
xs=round((2^15-1)*x)/2^15; % Q0.15 Format
% Filterung mit skaliertem IIR-Filter
% ============================================
bs=abs(min(b));
gs=bs*max(abs(freqz(1,a)));
gin=bs/(2*gs); gin=1/128;
gout=gs; gout=4;
bscal=b/bs;
ascal=a/2;
bscal=round(2^15*bscal)/2^15;
ascal=round(2^15*ascal)/2^15;
ZHAW, DSV1, FS2010, Rumc, 10
ys=zeros(1,Ns);
w=zeros(1,Ns);
for n=3:Ns,
w(n)=2*(gin*x(n)-ascal(2)*w(n-1)-ascal(3)*w(n-2));
ys(n)=gout*(bscal(1)*w(n)+bscal(2)*w(n-1)+bscal(3)*w(n-2));
end
% Plot
figure(2)
plot(1000*[0:Ns-1]/fs,ys,1000*[0:Ns-1]/fs,w,'--','LineWidth',2.0); grid;
xlabel('Zeit [ms]'); ylabel('ys[n] und w[n] gestr.');
title('Filterung 75 Hz Ton mit skaliertem IIR-Filter');
Bemerkung: In Matlab gibt es auch eine Fixed-Point-Toolbox!
c-Code mit TMS320C55x-Compiler-Intrinsics (nicht gefragt):
Int16
Int16
Int16
Int32
Int32
w[3]={0, 0, 0};
a[3]={0, 29755, -13679}; // a[0] not used
b[3]={19647, -32768, 19647};
y=0;
temp=0;
...
while (1) {
while (!DSK5510_AIC23_read16(hCodec, &sample_in_l)); // links in
while (!DSK5510_AIC23_read16(hCodec, &sample_in_r)); // rechts in
w[2] = w[1];
w[1] = w[0];
temp
temp
temp
temp
w[0]
y
y
y
y
=
=
=
=
=
=
=
=
=
// ohne Ring-Buffer
((Int32) sample_in_l)<<(16-7);
_smac(temp,a[1],w[1]);
_smac(temp,a[2],w[2]);
temp<<1;
(int) (temp>>16);
_smac(0,b[0],w[0]);
_smac(y,b[1],w[1]);
_smac(y,b[2],w[2]);
y<<2;
sample_out_l = (int) (y>>16);
sample_out_r = sample_out_l;
while (!DSK5510_AIC23_write16(hCodec, sample_out_l)); // links out
while (!DSK5510_AIC23_write16(hCodec, sample_out_r)); // rechts
}
Bemerkung: fs=8000 Hz, DSP-Codec unterdrückt DC.