Cours:Elen4 TNS TP FxTransfertStabilité

Retour à la page du cours

TP2 : Fonction de transfert et stabilité des filtres

Cette séance est consacrée à l'affichage des réponses d'un filtre numérique et à l'étude de sa stabilité. Vous travaillerez avec Python dans un notebook Jupyter, en suivant ce guide rapide : Travail avec Python et Pixi

Fonctions de transfert

Exercice 1

À l’aide de la fonction scipy.signal.dimpulse(), obtenir les premiers termes de la réponse impulsionnelle h(n) du SLIT causal dont la fonction de transfert est

H(z) =	1+2z-1+z-2
	1+0,5z-1+0,25z-2

Lister les valeurs obtenues et les confronter à celles obtenues en TD. Tracer le graphe de h(n).

Exercice 2

a) Calculer et afficher le module et le déphasage de la fonction transfert suivante :

H(z) =	3z6−0,0047z5+1,1739z4+0,0005z3−1,7220z2+0,0043z−2,4518
	z6 −0,0024z5 +1,4618z4 −0,0042z3 +1,3215z2 −0,0019z+0,7389

• Vous pourrez utiliser scipy.signal.freqz() pour obtenir le tableau des valeurs de la réponse en fréquences directement à partir des coefficients du filtre (pour des pulsations définies dans le tableau W).

b) Tracer le module en dB. Pour mémoire : |H_dB| = 20log(|H|). Le log se codant par numpy.log10()

Exercice 3

Soit un filtre exprimé sous la forme de facteurs composé de polynômes du premier degré, dont la fonction de transfert est

H(z) =	z+1
	(z + 0, 38)(z − 0, 46)

a) Calculer et représenter graphiquement le module et le déphasage du filtre défini par cette fonction de transfert.

b) Occasionnellement, il peut être intéressant de connaitre le temps de propagation de groupe τ(ω) défini par :

τ(ω) =	dφ
	dω

Le temps de propagation de groupe fait référence aux lignes de transmission, dans lesquelles les différentes fréquences d’un signal se propagent à des vitesses différentes, ce qui entraîne une dispersion dans le temps de l’énergie du signal.

De façon pratique et pour une période d’échantillonnage Ts, τ s’obtient par Ts*scipy.signal.group_delay(). Calculer et tracer τ(ω) pour Ts = 0,0001.

Exercice 4

Voici une collection de fonctions de transfert H_i(z) du second ordre :

Hi(z) =	Ni(z)
	z2 + 0,5z + 0,25

Calculer et tracer le module de ces fonctions de transferts pour

a) N₁(z) = (1+z)²

b) N₂(z) = (1-z)²

c) N₃(z) = (1-z²)

d) N₄(z) = (z² + 0,7z + 1)

e) N₅(z) = (0,25z² + 0,5z + 1)

Identifier chacun de ces filtres.

Stabilité de filtres

Exercice 1

Soit le polynôme D(z) = z⁷ + 0,5z⁶ + 0,4z⁵ + 2z⁴ + 0,75z³ + 0,8z² + 0,6z + 0,55

a) Saisir et exécuter le script suivant

import numpy as np
import matplotlib.pyplot as plt

# Données
D = np.array([1, 0.5, 0.4, 2, 0.75, 0.8, 0.6, 0.55])

# Racines
R = np.roots(D)
RR = np.real(R)
IR = np.imag(R)

# Plot des racines
plt.figure()
plt.plot(RR, IR, '*')
plt.axis('equal')
plt.grid(True)

# Cercle paramétrique
w = np.arange(0, np.pi, 0.01)
plt.plot(np.cos(2*w), np.sin(2*w))

plt.show()

# Affichage module et angle
print("Module   Angle (deg.)")
module = np.abs(R)
angle_deg = np.angle(R) * 180 / np.pi

for m, a in zip(module, angle_deg):
    print(f"{m:.6f}   {a:.6f}")

b) Indiquez les racines de D qui sont à l’intérieur du cercle unité et celles qui sont à l’extérieur.

Exercice 2

Déterminer si les racines du polynôme suivant sont à l’intérieur du cercle unité ou non (cf. TD pour comparer) :

D(z) = 2z⁴ + 3z³ + 4z² + z + 1

Exercice 3

Déterminer si le SLIT causal suivant est stable (cf. TD pour comparer) :

H(z) =	1
	5z4 + 3z3 + 6z2 + z + 2

Tracer sa réponse impulsionnelle pour contrôler.

Exercice 4

Déterminer si les fonctions de transfert suivantes caractérisent un SLIT causal stable ou non :

Ha(z) =	z+1
	z2 + 0,2z + 0,4

Hb(z) =	1+0,4z+0,3z2
	z2 + 0,4z + 1

Hc(z) =	z2(z+3)
	z2 + 0,8z + 0,5

Hd(z) =	z-1+1
	0,25z-2 + 0,4z-1 + 1

Tracer les réponses impulsionnelles pour contrôler.

Exercice 5

Lorsque des paramètres sont présents dans la fonction de transfert du système, il est possible de déterminer graphiquement les valeurs de ces paramètres qui entrainent un système stable. Par exemple pour un SLIT dont le dénominateur de la fonction de transfert est

D(z) = 2z³ + z² + c z + 1

Le script suivant met en place un slider permettant de régler les valeurs de c et d'afficher les pôles interactivement. Il sera nécessaire d'ajouter ipympl aux dépendances du projet.

%matplotlib widget
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.widgets import Slider

# Dénominateur
D = [2, 1, 0, 1]

# Création figure
fig, ax = plt.subplots(figsize=(6, 6))
plt.subplots_adjust(bottom=0.25)

# Fonction de tracé
def draw_roots(c):
    ax.clear()
    roots = np.roots([2, 1, c, 1])
    rr = np.real(roots)
    ir = np.imag(roots)

    # Affichage des racines
    ax.plot(rr, ir, 'x', markersize=10, label=f'c = {c:.2f}')

    # Cercle unité
    theta = np.linspace(0, 2*np.pi, 400)
    ax.plot(np.cos(theta), np.sin(theta), '--')

    ax.set_aspect('equal')
    ax.grid(True)
    ax.set_xlabel("Partie réelle")
    ax.set_ylabel("Partie imaginaire")
    ax.set_xlim(-2, 2)
    ax.set_ylim(-2, 2)
    ax.legend()

    fig.canvas.draw_idle()

# Tracé 
draw_roots(0)
# Slider
slider_ax = fig.add_axes([0.2, 0.1, 0.6, 0.03])
slider = Slider(
    ax=slider_ax,
    label='c',
    valmin=0,
    valmax=5,
    valinit=0,
    valstep=0.05
)

# Callback
slider.on_changed(draw_roots)

plt.show()