Cours:Elen4 TNS TP Implementations

Retour à la page du cours

TP3 : Implémentation des filtres numériques

Le travail de ce TP va consister à filtrer des signaux numériques avec divers filtres RIF, en exploitant trois implémentations différentes à partir du produit de convolution, de la réponse fréquentielle et de l'équation aux différences.

L'objectif est de filtrer le signal

x₁(n) = sin(n/10) + b(n)

b(t) étant du bruit gaussien.

Le filtre sera défini par sa fonction de transfert

H(z) =	1 + 2z-1 + z-2
	4

Implémentation hors-ligne

Il s'agit de traiter le signal après son acquisition.

Dans Python, Vous travaillerez avec le signal X₁ créé par le code suivant :

N = np.arange(1, 201)
X1 = np.sin(N / 10) + np.random.randn(len(N)) / 3

Avec filter

Il est évidemment possible de demander à Python de réaliser directement le filtrage, en utilisant la fonction y = scipy.signal.lfilter(b,a,x) qui traite le signal x avec le filtre défini par ses coefficients de sa fonction de transfert (b pour numérateur et a pour le dénominateur). Voir la documentation (https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.lfilter.html#scipy.signal.lfilter) pour le détail.

Cependant, pour éviter l'effet "boite noire", nous allons voir comment implémenter nous même un filtre.

Avec le produit de convolution

Avec le produit de convolution, Il s'agit d'une implémentation hors-ligne dans le domaine temporel. On nommera Y_c le signal de sortie obtenue avec cette implémentation.

a) Appliquez à X₁ le filtre RIF dont la fonction de transfert est H(z) par un produit de convolution (fonction scipy.signal.convolve()) avec la réponse impusionnelle h du filtre :

Y_c = X₁ ∗ h.

b) Tracer le graphe de l'entrée X₁ et de la sortie Y_c obtenue :

Avec la réponse fréquentielle

Avec la réponse fréquentielle, il s'agit d'une implémentation hors-ligne dans le domaine fréquentiel. On nommera Y_f le signal de sortie obtenue avec cette implémentation.

a) En exploitant le théorème de la convolution (le produit de convolution se transforme en produit simple fréquences à fréquences), filtrer le signal X₁. Voir les documentations de :

• numpy.fft.fft
• et scipy.signal.fftconvolve pour valider votre implémentation.

Fig : principe du filtrage dans le domaine fréquentiel.

b) Tracer le spectre d’amplitude de X₁, la réponse fréquentielle de H et le spectre d’amplitude de la sortie Y_f.

Comparaison des implémentations

Vérifier que le filtrage dans le domaine fréquentiel fourni une sortie identique à celle obtenue avec le produit de convolution. Vous pourrez faire

a) une vérification graphique en affichant les signaux Y_c et Y_f

b) ainsi qu'une vérification quantifiée en calculant une norme entre les deux signaux Y.

Implémentation en ligne

Une implémentation en ligne permet de traiter le signal pendant ou au cours de son acquisition. Il s'agit de calculer à la volée les valeurs du signal de sortie. Il faut pour cela s'appuyer sur l'équation au différence, qui permet d'exprimer y(n).

Avec un bloc FIR filter

Comme pour Python, il est possible d'utiliser un bloc implémentant directement un filtre FIR (Finite Impulse Response), il s'agit du bloc Frequency Xlating FIR filter.

Vous pourrez consulter la page Designing Filter Taps, en particulier la section Entering Filter Taps Manually.

À partir du schéma-bloc

a) Établir l'équation aux différence du filtre H

b) Donner le schéma-bloc équivalent à cette équation aux différences.

c) Dans GnuRadio, produire un schéma qui implémente ce filtre.

• La source sera un bloc Signal Source sinus. La fréquence du sinus sera obtenue à partir de la fréquence d'échantillonnage samp_rate et de la définition x(n)=sin(n/10). On rappelle que sin(wt) est un sinus de pulsation w.
• Le bruit sera obtenu par un bloc Noise Source
• Vous implémenterez le système à l'aide de Add pour les additionneurs, de Delay pour les retards et de Multiply Const pour les gains
• Vous afficherez les graphes de x₁ et de la sortie y avec 200 points (comme pour les implémentations dans Python)

c) Afin de comparer l'implémentation GnuRadio aux implémentation Python, il est nécessaire de travailler sur le même signal :

• Dans Python : écrire les valeurs du signal X1 dans un fichier :

with open("x.raw", "wb") as f:
    X1.tofile(f)

• Dans Gnuradio : utiliser les valeurs du fichier x.raw à l'aide d'un bloc File Source (attention à bien préciser une longueur de 200, des valeurs en 'float' et une non-répétition de la lecture).
• Vous pourrez ensuite utiliser un bloc File Sink (File Sink) pour écrire les valeurs de y dans un fichier, pour les relire dans Python afin de les comparer aux résultats précédents. Pour la lecture dans Python :

with open("data.bin", "rb") as f:
    y = np.fromfile(f, dtype=np.float64)

Notes :

• attention au type des données dans les tableaux numpy et des signaux dans gnuradio (https://wiki.gnuradio.org/index.php?title=Signal_Data_Types). Au besoin convertir (dans Python) : X1 = X1.astype(np.float32)

En écrivant du code

Dans ce cas, le travail consiste à calculer y(n) à partir de la valeur x(n) et de ses versions précédentes x(n-1) et x(n-2) qu'il est nécessaire de stocker.

Ceci sera mis en place dans un TP ultérieur (Implémentations temps-réel)

Comparaison

Discuter de l’intérêt de chacune des implémentations (convolution, en fréquence, et avec l’équation aux différences), en termes de complexité de calcul et contrainte d'utilisation (en ligne / hors ligne).