Conception d'un filtre par placement des zéros et des pôles

3.a. Intégrateur

Un intégrateur parfait est défini avec un pôle à fréquence nulle p₁=1 et un zéro à la fréquence de Nyquist q₁=-1 :

Figure pleine page$$H\left(z\right)=\frac{z+1}{z-1}=\frac{1+z^{-1}}{1-z^{-1}}\text{(10)}$$

La seconde écriture permet d'obtenir la relation de récurrence, sachant qu'au numérateur z^-1 correspond à un retard d'une unité pour l'entrée, au dénominateur un retard d'une unité pour la sortie :

$$y_n=y_{n-1}+x_n+x_{n-1}\text{(11)}$$

La réponse fréquentielle est :

$$H\left(\Omega \right)=\frac{e^{i\Omega }+1}{e^{i\Omega }-1}\text{(12)}$$

Le gain est infini à pulsation nulle, ce qui signifie que le filtre est instable si le signal d'entrée possède une fréquence nulle dans son spectre. L'instabilité vient de la présence d'un pôle sur le cercle unité. Voici le tracé du gain et du déphasage :

import numpy
import scipy.signal
from matplotlib.pyplot import *
b=[1,1]
a=[1,-1]
w,h=scipy.signal.freqz(b,a)

figure()
subplot(211)
plot(w/(2*numpy.pi),20*numpy.log10(numpy.absolute(h)))
xlabel("f/fe")
ylabel("GdB")
grid()
subplot(212)      
plot(w/(2*numpy.pi),numpy.angle(h)/numpy.pi)
xlabel("f/fe")
ylabel("phase/pi")
axis([0,0.5,-1,1])
grid()
                   

Figure pleine page

Pour ce filtre, il n'y a pas de gain maximal pour fixer la constante b₀. On fixera cette constante en fonction de l'objectif.

Supposons que l'on cherche à réaliser une intégration vraie, qui correspond à la relation en temps continu suivante :

$$y\left(t\right)={\int }_0^{t}x\left(t\right)dt\text{(13)}$$

Dans ce cas, la relation de récurrence est

$$y_n=y_{n-1}+\frac{T_e}{2}(x_n+x_{n-1})\text{(14)}$$

qui correspond à la méthode des trapèzes pour le calcul numérique d'une intégrale. Sa fonction de transfert est :

$$H\left(z\right)=\frac{T_e}{2}\frac{z+1}{z-1}=\frac{T_e}{2}\frac{1+z^{-1}}{1-z^{-1}}\text{(15)}$$

Le filtre intégrateur joue un rôle important dans la conception des filtres, car il sert de référence dans la méthode de transformation bilinéaire, expliquée dans Filtres à réponse impulsionnelle infinie.

3.b. Filtre passe-bas

En partant du filtre intégrateur précédent, on peut déplacer le pôle sur l'axe des réels pour lui donner un module r inférieur à 1, ce qui a pour effet de stabiliser le filtre.

Figure pleine page$$H\left(z\right)=b_0\frac{z+1}{z-r}\text{(16)}$$

Il s'agit d'un filtre passe-bas dont le gain dans la bande passante (z=1) est :

$$G=b_0\frac{2}{1-r}\text{(17)}$$

On peut par exemple choisir b₀ pour que G=1.

La relation de récurrence est :

$$y_n=r{y}_{n-1}+b_0(x_n+x_{n-1})\text{(18)}$$

Voici un exemple :

r=0.8
G=1
b0 = (1-r)*G/2
b=[b0,b0]
a=[1,-r]
w,h=scipy.signal.freqz(b,a)

figure()
subplot(211)
plot(w/(2*numpy.pi),20*numpy.log10(numpy.absolute(h)))
xlabel("f/fe")
ylabel("GdB")
grid()
subplot(212)      
plot(w/(2*numpy.pi),numpy.angle(h)/numpy.pi)
xlabel("f/fe")
ylabel("phase/pi")
axis([0,0.5,-1,1])
grid()
                 

Figure pleine page

Le filtre obtenu est similaire à une filtre du premier ordre calculé par transformation bilinéaire d'une fonction de transfert analogique. La méthode de placement des pôles et zéros permet d'obtenir facilement un filtre passe-bas ayant une très basse fréquence de coupure, par exemple :

r=0.99
G=1
b0 = (1-r)*G/2
b=[b0,b0]
a=[1,-r]
w,h=scipy.signal.freqz(b,a)

figure()
subplot(211)
plot(w/(2*numpy.pi),20*numpy.log10(numpy.absolute(h)))
xlabel("f/fe")
ylabel("GdB")
grid()
subplot(212)      
plot(w/(2*numpy.pi),numpy.angle(h)/numpy.pi)
xlabel("f/fe")
ylabel("phase/pi")
axis([0,0.5,-1,1])
grid()
                 

Figure pleine page

On obtient ainsi un intégrateur stable, dont le gain à fréquence nulle est fini. Pour cette utilisation, il peut être utile d'ajuster la constante b₀ pour obtenir une intégration vraie du signal d'entrée. On doit alors avoir dans la plage de fréquence d'intégration :

$$b_0\frac{z+1}{z-r}=\frac{T_e}{2}\frac{z+1}{z-1}\text{(19)}$$

ce qui donne :

$$b_0=\frac{T_e}{2}\frac{z-r}{z-1}\text{(20)}$$

Si r est très proche de 1, et si z est différent de 1 (fréquence non nulle), la fraction est pratiquement égale à 1. Cela démontre le comportement intégrateur et indique le choix de la constante :

$$b_0=\frac{T_e}{2}\text{(21)}$$

On obtient finalement la relation de récurrence suivante pour une utilisation de ce filtre en tant qu'intégrateur :

$$y_n=r{y}_{n-1}+\frac{T_e}{2}(x_n+x_{n-1})\text{(22)}$$

La constante r est inférieure à 1 mais proche de 1, d'autant plus que l'on veut une fréquence de coupure basse. Pour r=1, on retrouve l'intégrateur parfait, instable à fréquence nulle.

Pour une utilisation en tant que filtre passe-bas avec un gain unité dans la bande passante, la relation de récurrence est :

$$y_n=r{y}_{n-1}+\frac{1-r}{2}(x_n+x_{n-1})\text{(23)}$$

On peut chercher à obtenir ce filtre passe-bas directement à partir de l'équation différentielle du système à temps continu. Pour une pulsation analogique de coupure ω_c et un gain dans la bande passante g, cette équation est :

$$\frac{dy\left(t\right)}{dt}+{\omega }_{c}y\left(t\right)={\omega }_{c}gx\left(t\right)\text{(24)}$$

La méthode d'intégration d'Euler s'écrit :

$$\begin{array}{ccc}\hfill y_n& =y_{n-1}+{\omega }_c\frac{T_e}{2}(g{x}_{n-1}-y_{n-1})\hfill & \hfill \text{(25)}\\ \hfill & =(1-{\omega }_c{T}_e)y_{n-1}+{\omega }_c{T}_{e}g{x}_{n-1}\hfill & \hfill \text{(26)}\\ \hfill & =r{y}_{n-1}+(1-r)g{x}_{n-1}\hfill & \hfill \text{(27)}\end{array}$$

Cette relation est différente de la relation $\mathrm{(23)}$ puisque la méthode d'Euler est une méthode à un pas. La fonction de transfert correspondante a l'inconvénient d'être démunie de zéro. Voyons sa réponse fréquentielle :

b=[0,1-r]
a=[1,-r]
w,h=scipy.signal.freqz(b,a)

figure()
subplot(211)
plot(w/(2*numpy.pi),20*numpy.log10(numpy.absolute(h)))
xlabel("f/fe")
ylabel("GdB")
grid()
subplot(212)      
plot(w/(2*numpy.pi),numpy.angle(h)/numpy.pi)
xlabel("f/fe")
ylabel("phase/pi")
axis([0,0.5,-1,1])
grid()
                 

Figure pleine page

Cette réponse est très différente de la réponse fréquentielle du filtre analogique. En particulier, on ne retrouve pas du tout le comportement intégrateur dans la bande atténuante. La solution consiste à appliquer une méthode numérique à deux pas, du type Adams-Moulton ([3]), comme on le fait pour l'intégrateur (méthode des trapèzes) :

$$y_n=(1-{\omega }_c{T}_e)y_{n-1}+{\omega }_c{T}_e\frac{1}{2}g(x_n+x_{n-1})\text{(28)}$$

qui est bien de la forme $\mathrm{(23)}$ si l'on pose r=1-ω_cT_e et g=1. La relation réalisant une intégration vraie dans la bande atténuante s'obtient en posant :

$${\omega }_{c}g=1\text{(29)}$$

3.c. Filtre passe-haut

Un filtre passe-haut est obtenu avec un pôle p₁=-r pour la fréquence de Nyquist et un zéro q₁=1 pour la fréquence nulle.

Figure pleine page$$H\left(z\right)=b_0\frac{z-1}{z+r}\text{(30)}$$

La relation de récurrence est :

$$y_n=-r{y}_{n-1}+b_0(x_n-x_{n-1})\text{(31)}$$

Le gain dans la bande passante (z=-1) est :

$$G=b_0\frac{2}{1-r}\text{(32)}$$

qui est la même relation que pour le filtre passe-bas. Voici un exemple :

r=0.2
G=1
b0 = (1-r)*G/2
b=[b0,-b0]
a=[1,r]
w,h=scipy.signal.freqz(b,a)

figure()
subplot(211)
plot(w/(2*numpy.pi),20*numpy.log10(numpy.absolute(h)))
xlabel("f/fe")
ylabel("GdB")
grid()
subplot(212)      
plot(w/(2*numpy.pi),numpy.angle(h)/numpy.pi)
xlabel("f/fe")
ylabel("phase/pi")
axis([0,0.5,-1,1])
grid()
                 

Figure pleine page

Pour obtenir un filtre bloquant la composante continue, il faut abaisser la fréquence de coupure. Cela se fait en plaçant le pôle en p₁=r, avec r très proche de 1 :

Figure pleine page$$H\left(z\right)=b_0\frac{z-1}{z-r}\text{(33)}$$

Le gain dans la bande passante est :

$$G=b_0\frac{2}{1+r}\text{(34)}$$

La relation de récurrence est :

$$y_n=r{y}_{n-1}+b_0(x_n-x_{n-1})\text{(35)}$$

Voici un exemple. Si est r est très proche de 1, on a pratiquement b₀=1.

r=0.999
G=1
b0 = (1+r)*G/2
b=[b0,-b0]
a=[1,-r]
w,h=scipy.signal.freqz(b,a)

figure()
subplot(211)
plot(w/(2*numpy.pi),20*numpy.log10(numpy.absolute(h)))
xlabel("f/fe")
ylabel("GdB")
grid()
subplot(212)      
plot(w/(2*numpy.pi),numpy.angle(h)/numpy.pi)
xlabel("f/fe")
ylabel("phase/pi")
axis([0,0.5,-1,1])
grid()
                 

Figure pleine page

3.d. Filtre passe-bande

Un filtre passe-bande peut être obtenu en associant en série un filtre passe-bas et un filtre passe-haut :

Figure pleine page$$H\left(z\right)=b_0\frac{z-1}{z-r_1}\frac{z+1}{z-r_2}=b_0\frac{1-z^{-2}}{1-(r_1+r_2)z^{-1}+r_1{r}_2{z}^{-2}}\text{(36)}$$

r1=0.9
r2=0.95

b=[1,0,-1]
a=[1,-(r1+r2),r1*r2]
w,h=scipy.signal.freqz(b,a)

figure()
subplot(211)
plot(w/(2*numpy.pi),20*numpy.log10(numpy.absolute(h)))
xlabel("f/fe")
ylabel("GdB")
grid()
subplot(212)      
plot(w/(2*numpy.pi),numpy.angle(h)/numpy.pi)
xlabel("f/fe")
ylabel("phase/pi")
axis([0,0.5,-1,1])
grid()
                 

Figure pleine page

Une application de ce type de filtre est un intégrateur avec un gain nul à fréquence nulle, obtenu avec r₁ et r₂ très proches de 1.

r1=0.98
r2=0.99

b=[1,0,-1]
a=[1,-(r1+r2),r1*r2]
w,h=scipy.signal.freqz(b,a)

figure()
subplot(211)
plot(w/(2*numpy.pi),20*numpy.log10(numpy.absolute(h)))
xlabel("f/fe")
ylabel("GdB")
grid()
subplot(212)      
plot(w/(2*numpy.pi),numpy.angle(h)/numpy.pi)
xlabel("f/fe")
ylabel("phase/pi")
axis([0,0.5,-1,1])
grid()
                 

Figure pleine page

Voyons la réponse impulsionnelle de ce filtre :

x = numpy.zeros(1000)
x[0] = 1.0
zi = scipy.signal.lfiltic(b,a,y=[0,0],x=[0,0])
[y,zf] = scipy.signal.lfilter(b,a,x,zi=zi)

figure()
plot(y)
xlabel("n")
ylabel("y")
grid()
                   

Figure pleine page

Il faut environ 600 échantillons pour atteindre le régime stationnaire. Pour obtenir une réponse plus rapide, il faut augmenter la fréquence de la bande passante, en réduisant r₁ et r₂.

Pour obtenir une intégration vraie dans la bande atténuante, il faut choisir la constante b₀ pour que l'égalité suivante soit à peu près vérifiée dans la bande atténuant :

$$b_0\frac{z-1}{z-r_1}\frac{z+1}{z-r_2}=\frac{T_e}{2}\frac{z+1}{z-1}\text{(37)}$$

Lorsque r₁ et r₂ sont très proches de 1 et lorsque z est différent de 1 (fréquence non nulle), cette égalité est approximativement vérifiée si :

$$b_0=\frac{T_e}{2}\text{(38)}$$

Voici la relation de récurrence de cet intégrateur :

$$y_n=(r_1+r_2)y_{n-1}-r_1{r}_2{y}_{n-2}+\frac{T_e}{2}(x_n-x_{n-2})\text{(39)}$$

Si le signal d'entrée comporte une composante de fréquence nulle (composante continue), l'intégration se fait sans décalage en sortie. L'inconvénient est la lenteur de la réponse transitoire. En pratique, il faut ajuster la fréquence de la bande passante juste en dessous de la plus basse fréquence du signal.

4.a. Filtre passe-bande

Le filtre passe-bande précédent était défini avec deux pôles réels. Pour obtenir un résonateur, on définit deux pôles complexes conjugués à la pulsation de résonance, avec deux zéros q₁=1 et q₂=-1 qui permettent d'annuler le gain à fréquence nulle et à la fréquence de Nyquist :

Figure pleine page$$H\left(z\right)=b_0\frac{(z-1)(z+1)}{(z-r{e}^{i{\Omega }_a})(z-r{e}^{-i{\Omega }_a})}=b_0\frac{1-z^{-2}}{1-2rcos\left({\Omega }_a\right)z^{-1}+r^2{z}^{-2}}\text{(40)}$$

Voici un exemple, avec une fréquence de résonance égale à 1/5 ième de la fréquence de Nyquist :

omega_a=numpy.pi/5
r=0.95
b=[1,0,-1]
a=[1,-2*r*numpy.cos(omega_a),r*r]
w,h=scipy.signal.freqz(b,a)

figure()
subplot(211)
plot(w/(2*numpy.pi),20*numpy.log10(numpy.absolute(h)))
xlabel("f/fe")
ylabel("GdB")
grid()
subplot(212)      
plot(w/(2*numpy.pi),numpy.angle(h)/numpy.pi)
xlabel("f/fe")
ylabel("phase/pi")
axis([0,0.5,-1,1])
grid()

                  

Figure pleine page

Il faudra bien sûr choisir une constante b₀ adéquate pour obtenir un gain unité dans la bande passante.

Voyons la réponse impulsionnelle de ce filtre :

x = numpy.zeros(100)
x[0] = 1.0
zi = scipy.signal.lfiltic(b,a,y=[0,0],x=[0,0])
[y,zf] = scipy.signal.lfilter(b,a,x,zi=zi)

figure()
stem(y)
xlabel("n")
ylabel("y")
grid()
                   

Figure pleine page

Elle présente des oscillations à la fréquence de résonance, égale à un dixième de la fréquence d'échantillonnage. Elle tend bien vers zéro puisque ce filtre est stable (ses pôles ont un module strictement inférieur à 1).