Filtres à réponse impulsionnelle de

durée finie (RIF)

Objectifs de l’apprentissage

‹ Introduction à la théorie des filtres à

réponse impusionnelle de durée finie:
Š Propriétés
Š Détermination des coefficients
Š Architectures de mise en oeuvre.
‹ Mise en oeuvre en Matlab, C et
assembleur.

1
 Introduction

‹ Les filtres RIF sont caractérisés par une fonction de

transfert exprimée par un polynôme en z-1 :
N −1
H (z ) = ∑ h [ n ] z −n
n =0
(donc, pas de dénominateur dans H(z))
‹ Propriétés :
Š Réponse stable par défaut
Š Réponse en phase linéaire pour un filtre réalisable
Š Peuvent demander un temps de calcul très long

Introduction
‹ Utilité d’un système stable par défaut :
Š Pas besoin de s’assurer de la position des pôles
au bon endroit.
‹ Avantage d’une réponse en phase linéaire :
Š L’équation d’e/s d’un filtre idéal est, dans sa
bande passante :
y( t ) = x( t − τ )
ou, dans le domaine de Fourier :
Y ( ω ) = e − jωτ X ( ω )
Cela implique une fonction de transfert avec
H(ω ) = 1 et θ [H (ω )] = −ωτ

2
 Propriétés d’un filtre RIF
‹ Équation d’e/s :
N −1
y[n] = ∑ bk ⋅ x[n − k ]
k =0

x[n] représente les valeurs successives du

signal d’entrée,
bk représente les coefficients de la fonction
de transfert du filtres,
y[n] représente les valeurs successives du
signal de sortie,
N est le nombre de coefficients du filtre
(l’ordre).

Propriétés d’un filtre RIF

‹ Diagramme de flux
-1 -1 -1 -1
x(n) z z z z

b0 b1 b2 bN-1
x x x x

+ + + y(n)

‹ Deux filtres RIF différents se distinguent

uniquement par leur coefficients !
N −1
y[n] = ∑ b ⋅ x[n − k ]
k
k =0

3
 Origine du nom RIF
N −1
‹ On a : y [n ] = ∑ bk ⋅ x[n − k ]
k =0
‹ Si on remplace le signal d’entrée x[n] par une
impulsion δ[n], alors :
N −1
y [n ] = h [ n ] = ∑ bkδ [n − k ]
k =0

= b0δ [n ] + b1δ [n − 1] + L + bN −1δ [n − ( N − 1 )]

‹ Et puisque : b0 = h[0 ]

1 for n = k b1 = h[1]
δ [n − k ] = 
0 for n ≠ k M

On en déduit : h[k ] si k ≤ N − 1
bk = 
 0 autrement

Observations
‹ La réponse du filtre est égale aux valeurs
successives de ses coefficients.
‹ Pour un filtre d’ordre N :
 b si k < N
h[k ] =  k
 0 si k ≥ N
‹ Conséquences :
Š La connaissance des valeurs de h[n] donne
automatiquement les coefficients du filtre
Š La réponse du filtre est de durée finie et égale à
NTe.

4
Réponse en fréquence d’un filtre FIR
‹ La transformée Z de
N −1
y [n ] = ∑ bk ⋅ x[n − k ]
k =0
est : N −1
H (z ) = ∑ h[n ]z −n
n =0

‹ La fonction de réponse en fréquence du filtre

est obtenue en remplaçant z by ejωTe :
N −1
H (z ) z =e jωTe = H (ω ) = ∑ h[n ]e − jnωTe
n =0
‹ La similarité de l’expression de H(ω) avec
une série de Fourier suggère une méthode
pour trouver h[n] !

Réponse en fréquence d’un filtre FIR

‹ Puisque e-j2πk = 1, on a :
 2π 
 2π  N −1 − jn  ω +  Te N −1
H  ω +  = ∑ h[n ]e  Te  = ∑ h[n ]e − jnωTe
 Te  n =0 n =0

‹ Par conséquent :
 2 kπ 
H  ω +  = H (ω )
 Te 
La réponse en fréquence d’un filtre FIR est périodique avec
période 2π/Te dans le cercle de rayon unité.
‹ En particulier, si on normalise Te à 1, on a :
H (ω + 2kπ ) = H (ω )

5
 Réponse en fréquence d’un filtre FIR
 2π 
‹ Conséquences de Hω +  = H(ω)
 Te 
x[n]

y[n]
Fréq Fréq
Fe/2 Fe/2

‹ Il faut respecter le critère de Nyquist :

π
ωmax ≤ = π fe
Te
‹ Utiliser un filtre anti-alias.
x[n]
x(t) ADC FIR y[n]
Filtre anti-alias

Réponse en phase d’un filtre RIF

‹ Un filtre réalisable possède un spectre de fréquences
symétrique (sinon h[n] aurait des valeurs complexes).
‹ Pour un filtre RIF, cela veut dire h[n] = h[N-1-n], puisque
bk= h[k].

h(n) h(n)
N = 2n + 2 N = 2n + 1

n n
0 1 n n+1 2n 2n+1 0 1 n-1 n n+1 2n-1 2n

Symétrie paire Symétrie impaire

6
 Réponse en phase d’un filtre RIF
‹ Si on suppose une symétrie impaire avec N=2n+1 :
N =2 n
H (z ) = ∑ h[i ]z −i
i =0

= h0 z −0 + h1 z −1 + ... + hn z −n + hn +1 z −( n +1 ) + ... + h2 n −1 z −( 2 n −1 ) + h2 n z − 2 n
= h0 z −0 + h1 z −1 + ... + hn z −n + hn z −( n +1 ) + ... + h1 z −( 2 n −1 ) + h0 z − 2 n
[
= z −n h0 (z n + z − n ) + h1 (z n −1 + z −( n −1 ) ) + ... + hn −1 (z 1 + z −1 ) + hn z −0 ]
‹ Pour un symétrie paire, avec N=2n+2
N = 2 n +1
H (z ) = ∑ h[i ]z
i =0
−i

= h0 z −0 + h1 z −1 + hn z −n + hn +1 z −( n +1 ) + h2 n z − 2 n + h2 n +1 z −( 2 n +1 )
= h0 z −0 + h1 z −1 + hn z −n + hn z −( n +1 ) + h1 z − 2 n + h0 z −( 2 n +1 )
−
2 n +1
  2 n2+1 −
2 n +1
  2 n + 1 −1 −
2 n +1
+1   2 n +1 − n −
2 n +1
+ n 
=z 2
h0  z + z 2  + h1  z 2 + z 2  + ... + hn  z 2 + z 2 
      

Réponse en phase d’un filtre RIF

‹ Dans les deux cas, on obtient une expression ou le terme

entre crochets est réel et où l’argument du z qui reste donne
la réponse en phase du filtre lorsque z=ejωTe .
‹ La réponse est soit -nωTe, soit –(n+0.5)ωTe

 N −1
Condition Phase  k = −  Phase Property Filter Type
 2 

h[n ] = h[N − n − 1] Odd Symmetry – Type 1

kω Linear phase
Positive Symmetry Even Symmetry – Type 2

7
 Conception d’un filtre RIF

‹ Cinq étapes sont requises :

1. Spécification du filtre
2. Calcul des coefficients.
3. Choix d’une architecture de mise en
oeuvre.
4. Simulation (option).
5. Implémentation.

Conception d’un filtre RIF

‹ Trois sous-étapes :
Š Conception d’un filtre passe bas normalisé
équivalent
Š Adaptation au type désiré
Š Passe Haut
Š Passe bande
Š Coupe bande

8
 Étape 1 : spécification du filtre
|H(f)| pass-band stop-band

fc : cut-off frequency fs/2 f(norm)

(a)

|H(f)| pass-band transition band stop-band |H(f)|

(dB) (linear)
∆p 1 + δ p

0 1
1 − δ p

pass-band
-3
ripple

stop-band
ripple
∆s δ s

fs/2 f(norm)
fsb : stop-band frequency
fc : cut-off frequency
fpb : pass-band frequency
(b)

Étape 2 : calcul des coefficients

‹ Il existe plusieurs méthodes dont :

Š La technique de la moyenne ajustée
Š La méthode des fenêtres d’approximation
(approximation par série de Fourier tronquée).
Š La méthode de Parks-McClellan.
Š Etc…

9
 La méthode des fenêtres
1. Comme bk=h[k], le calcul des coefficients revient à
trouver la réponse impulsionnelle du filtre.
On part de la transformée de Fourier inverse d’un
filtre idéal. Pour un filtre passe bas avec Te
normalisé à 1 :
π
1
hd (n ) = ∫π H (ω )e
jωn
dω
2π −
ωc
1
∫ω 1 ⋅ e
jωn
= dω
2π − c

2 f c sin (nωc )
= , n = 0,1, 2...
nωc

La méthode des fenêtres

‹ Si on limite le nombre de valeurs de n à N, cela

revient à multiplier hd(n) par une fenêtre
rectangulaire de largeur N.
‹ L’effet est de multiplier H(ω) par la transformée de
Fourier de la fenêtre rectangulaire, modifiant ainsi
la réponse en fréquence du filtre.
‹ On peut minimiser cet effet en utilisant une fenêtre
non rectangulaire

10
 La méthode des fenêtres
2. Pour différentes fenêtres, la largeur de la bande de
transition et l’atténuation dans la bande d’arrêt
permettent de déterminer l’ordre du filtre.
Norm alised Transition Stopband Attenuation
W indow Type Passband Ripple(dB)
W idth (∆ f(H z)) (dB)

0 .9
Rectangular 0.7416 21
N

3 .1
Hanning 0.0546 44
N

3 .3
Hamming 0.0194 53
N

5 .5
Blackman 0.0017 74
N
2 .93
→ β = 4 . 54
N 0.0274 50
K aiser 5 .71
→ β = 8 . 96
N 0.000275 90

Ex. fenêtre de Hamming avec 3.3 3.3

f0=1.3 kHz ∆f=200 Hz, N= = ⋅ 8kHz = 132
∆f (1.2 − 1.4 )kHz
fe=8kHz)

La méthode des fenêtres

On calcule alors les coefficients du filtre tronqué :
h(n) = hd (n) ⋅W(n)
N −1 N −1
− ≤n≤ for N = odd
2 2
N N for N = even
− ≤n≤
2 2
Pour la fenêtre de Hamming :
 2π n 
W (n ) = 0 .54 + 0 .46 cos 
Dans l’exemple :

 N  −66 ≤ n ≤ 66
 2π n 
= 0 .54 + 0 .46 cos  
 133 

11
 La méthode des fenêtres
‹ Code Matlab pour calculer les coefficients :
close all;
clear all;

fc = 8000/44100; % cut-off frequency

N = 133; % number of taps
n = -((N-1)/2):((N-1)/2);
n = n+(n==0)*eps; % avoiding division by zero

[h] = sin(n*2*pi*fc)./(n*pi); % generate sequence of ideal coefficients

[w] = 0.54 + 0.46*cos(2*pi*n/N); % generate window function
d = h.*w; % window the ideal coefficients

figure(1);
stem(d); % plot coefficient values
xlabel('Coefficient number');
ylabel ('Value');
title('Truncated Impulse Response');

figure(2)
freqz(d,1,512,44100); % use freqz to plot magnitude and phase response
axis([0 2*10^4 -70 10]);

La méthode des fenêtres

Truncated Impulse Response
0.4

0.3

0.2
Value

0.1

-0.1
0 20 40 60 80 100 120 140
Coefficient number

0
Magnitude (dB)

-20

-40

-60

0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2

Frequency (Hz) 4
x 10
0
Phase (degrees)

-2000

-4000

-6000
0 0.5 1 1.5 2
Frequency (Hz) 4
x 10

12
Étape 3 : choix d’une architecture de mise en oeuvre

3. Forme directe d’un filtre FIR :

N −1
H (z ) = ∑b z k
−k

k =0

Y (z ) = H (z ) ⋅ X (z ) y(n) = b0 x(n) + b1 x(n −1) + ....+ bN −1 x(n − N +1)

-1 -1 -1
x(n) z z z

b b b b
0 1 2 N-1

+ + + y(n)

Étape 3 : choix d’une architecture de mise en oeuvre

‹ Forme directe d’un filtre FIR :

N −1
H (z ) = ∑b z k
−k

k =0

‹ Variante à réponse en phase linéaire :

N
−1

( )
2
Š N pair : H (z ) = ∑ bk z − k + z N − k −1
k =0

N −1
N −1

∑b (z )+ b
2
Š N impair : H (z ) = −k
+z N −k −1
z
−
2
k N −1
k =0 2

13
Étape 3 : choix d’une architecture de mise en oeuvre

(a) Diagramme
-1 -1 -1 -1 -1
z z z z z
b0
+
de flux pour +
b1
+

N pair +
b2
+

b N/2-1
+ +
y(n)
(a)

(b) Diagramme x(n)

z
-1
z
-1
z
-1
z
-1
z
-1
z
-1

de flux pour +
b0

N impair
b1
+ +
b2
+ +
b(N-1)/2

b(N-3)/2
+ +

y(n) +

(b)

Étape 3 : choix d’une architecture de mise en oeuvre

‹ Forme en cascade :
N −1
H (z ) = ∑ b z = b + b z k
−k
0 1
−1
+ b 2 z − 2 + ... + b N − 1 z − ( N −1 )
k =0

 b b b 
= b 0 1 + 1 z − 1 + 2 z − 2 + ... + N − 1 z − ( N −1 ) 
 b 0 b 0 b 0 

∏ (1 + b z + b z )
M
−1 −2
= b0 k ,1 k ,2
k =1

‹ Diagramme de flux pour la forme en cascade :

x(n) b0 y(n)
+ + +

z -1 z -1 z -1
b 1,1 b 2,1 b M,1
+ + +
z -1 z -1 z -1
b 1,2 b 2,2 b M,2

14
 Étape 5 : mise en oeuvre
N −1
1. Transformer y[n] = ∑bk x[n − k ] en code c,
k =0
assembleur or assembleur linéaire ;
2. Initialiser le codec ;
3. Configurer le temporisateur du DSP pour
générer une interuption à une fréquence de fe ;
4. Écrire un programme principal qui accomplit
les étapes 2 et 3, et un sous programme de
service aux interruptions qui exécute le code de
l’étape 1.

Étape 5 : mise en oeuvre

N −1
Détails de l’adressage circulaire : y[n] = ∑bk x[n − k ]
k =0
*B5 b0 *A5 x-3
*B5 b1 *A5 x-2
*B5 b2 *A5 x-1
*B5 b3 *A5 x0
y0 = b0*x-3 + b1*x-2 + b2*x-1 + b3*x0
y[n]

temps
0 1 2

15
 Étape 5 : mise en oeuvre

*B5 b0 *A5 x1
*B5 b1 *A5 x-2
*B5 b2 *A5 x-1
*B5 b3 *A5 x0

y0 = b0*x-3 + b1*x-2 + b2*x-1 + b3*x0

y1 = b0*x-2 + b1*x-1 + b2*x0 + b3*x1
y[n]

time
0 1 2

Étape 5 : mise en oeuvre

*B5 b0 *A5 x1
*B5 b1 *A5 x2
*B5 b2 *A5 x-1
*B5 b3 *A5 x0

y0 = b0*x-3 + b1*x-2 + b2*x-1 + b3*x0

y1 = b0*x-2 + b1*x-1 + b2*x0 + b3*x1
y2 = b0*x-1 + b1*x0 + b2*x1 + b3*x2
y[n]

time
0 1 2

16
 Code
//C6xdskinit.c
//Initialisation du DSK,AD535,McBSP et fonction d’e/s en mode IRQ

#include ...

// initilisation du système (ports McBSP, codec, temporisateurs, etc.)

Void c6x_dsk_init() {
/* ... */
}

// e/s par interruption

void comm_intr() {
c6x_dsk_init(); // init DSK (McBSP en mode IRQ)
config_IRQ(11, XINT0); //utiliser l’IRQ 11 sur XINT0
enableGlobalINT(); //partir les IRQ
}

// Écriture au convertisseur NA à travers le port sériel McBSP0 suite à un IRQ

void output_sample(int out_data) {
*(unsigned volatile int *)McBSP0_DXR
=out_data & 0xfffe; // & pour communication primaire
}

// Lecture du convertisseur AN à travers le port sériel McBSP0 Suite à un IRQ

int input_sample() {
return *(unsigned volatile int *)McBSP0_DRR;
}

Code
//Fir.c FIR filter.

#include "[Link]" // contient h[]et définit N

int yn; // Sortie du filtre
short xin[N]; // Données d’entrée

void main()
{
comm_intr(); //initialisation du système en mode IRQ
while(1); //boucle infinie
}

interrupt void c_int11() //ISR (code du filtre)

{
short i;

xin[0] = input_sample(); //lire la dernière valeur

yn = 0;
for (i = 0; i< N; i++)
yn += (h[i] * xin[i]); //calculer y(n) += h(i)* x(n-i)
for (i = N-1; i > 0; i--) //décaler les valeurs de y[]
xin[i] = xin[i-1];

output_sample(yn >> 15); //tronquer les 15 BMS

return;
}

17
 Un code plus efficace
/* Un version plus obscure, mais beaucoup plus rapide *
* le nombre de points doit être une puissance de 2 */

interrupt void c_int11() //ISR (code du filtre)

int i,iCircularBuf;
int * ph;
int yn = 0;
static int endBuf= N-1;

xin[endBuf] = input_sample(); // La donnée courante va à la fin du tampon

iCircularBuf=endBuf++ + 1; // Le début du tampon circulaire vient après
endBuf &=N_MASK; // endBuf=(endBUf+1)%N pour la prochaine donnée

// Dans la boucle, les indices de h diminuent et ceux de xin augmentent

ph=&h[N-1];
for (i=N; i>0; i--){
iCircularBuf &= N_MASK;
yn += (long)(*ph--) * xin[iCircularBuf++]; // calculs sur 32 bits
}

output_sample(yn >> 15); // on normalise le résultat à 16 bits

return
}

18