TP2$:$Filtre$FIR$(réels$simple$précision).$Génération$des$
coefficients$sur$Matlab,$Options$de$compilation$
• Partie'1':$Généralités$sur$les$filtres$FIR$(Finite$Impulsional$Response$:$Filtre$à$réponse$
impulsionnelle$finie$RIF)$
• Partie'2':$Conception$d’un$filtre$passe$bas$et$génération$de$ces$coefficients$par$l’outil$
fdatool$sous$Matlab$$
• Partie'3':$Ecriture$du$code$en$C$sous$CCS,$mesure$de$l’efficacité$Nb_MAC/Cycles_CPU$
• Partie'4':'Code$critique$en$assembleur$
• Partie'5':'Optimisation$:$Options$du$compilateur.$
'
A- Partie'1':'Généralité'
Un$filtre$numérique$peut$être$défini$par$une$équation$aux$différences,$le$décrivant$dans$le$
domaine$temporel$(discret).$Un$filtre$numérique$est$défini$par$cette$formule$générale$
suivante$:$
$
$
Deux$grandes$familles$de$filtres$numériques$qui$existent$:$la$première$RII$(filtre$à$réponse$
impulsionnelle$infinie)$et$puis$les$filtres$RIF$ou$FIR(filtres$à$réponse$impulsionnelle$finie$-$
finite$impulse$réponse).$Ce$dernier$type$de$filtre$est$dit$fini,$car$sa$réponse$impulsionnelle$se$
stabilise$ultimement$à$zéro.$
$
Un$filtre$FIR$est$non$récursif,$c'est-à-dire$que$la$sortie$dépend$uniquement$de$l'entrée$du$
signal,$il$n'y$a$pas$de$contre-réaction.$Ainsi,$les$coefficients$ak$$de$la$forme$générale$des$
filtres$numériques$sont$tous$égaux$à$zéro.$
$
Une$propriété$importante$des$filtres$RIF$est$que$les$coefficients$du$filtre$sont$égaux$à$la$
réponse$impulsionnelle$h()$du$filtre.$D'autre$part,$la$forme$temporelle$du$filtre$est$tout$
simplement$la$convolution$du$signal$d'entrée$avec$les$coefficients$bk$ $
$
$
B- Partie'2':'Génération'des'coefficients'de'type'réel'simple'précision'
1) Lancer$Matlab,$puis$lancer$fdatool$à$partir$de$la$ligne$de$commande.$
Objectif : l’objectif de ce TP est de réaliser un filtre FIR pour filtrer un signal perturbé.
1 Introduction
1.1 FILTRE NUMERIQUE :
En électronique, un filtre numérique est un élément qui effectue un filtrage à l'aide d'une
succession d'opérations mathématiques sur un signal discret. C'est-à-dire qu'il modifie le
contenu spectral du signal d'entrée en atténuant ou éliminant certaines composantes spectrales
indésirées.
les filtres numériques sont réalisés soit par des circuits intégrés dédiés, des processeurs
programmables (FPGA, microprocesseur, DSP, microcontrôleur, etc.), soit par logiciel dans
un ordinateur.
Les deux principales limitations des filtres numériques sont la vitesse et le coût. La vitesse du
filtre est limitée par la vitesse (l'horloge, le « clock » en anglais) du processeur. Pour ce qui est
du coût, celui-ci dépend du type de processeur utilisé. Par contre, le prix des circuits intégrés
ne cesse de diminuer, et les filtres numériques se retrouvent partout dans notre
environnement, radio, téléphone cellulaire, télévision, lecteurs MP3, etc.
Un filtre numérique peut être défini par une équation aux différences, c'est-à-dire l'opération
mathématique du filtre dans le domaine temporel (discret).
La forme générale du filtre d'ordre M est la suivante :
1.2 FAMILLE DE FILTRE NUMERIQUE :
Il y a deux grandes familles de filtres numériques : la première RII (filtre à réponse
impulsionnelle infinie) et puis les filtres RIF (filtres à réponse impulsionnelle finie), en
anglais FIR(finite impulse réponse), Ce dernier type de filtre est dit fini, car sa réponse
impulsionnelle se stabilisera ultimement à zéro.
Un filtre FIR est non récursif, c'est-à-dire que la sortie dépend uniquement de l'entrée du
signal, il n'y a pas de contre-réaction. Ainsi, les coefficients de la forme générale des filtres
numériques sont tous égaux à zéro.
Une propriété importante des filtres RIF est que les coefficients du filtre sont égaux à
la réponse impulsionnelle du filtre. D'autre part, la forme temporelle du filtre est tout
simplement la convolution du signal d'entrée avec les coefficients (ou réponse
impulsionnelle) (ou ).
L’équation de récurrence du filtre FIR est :
1
0
)(
N
k
knXkHny
5
En traitement numérique du signal, le filtre à réponse impulsionnelle finie ou filtre RIF (en
anglais Finite Impulse Response filter ou FIR filter) est un filtre numérique qui est caractérisé
par une réponse uniquement basée sur un nombre fini de valeurs du signal d'entrée. Par
conséquent, quel que soit le filtre, sa réponse impulsionnelle sera stable et de durée finie
dépendante du nombre de coefficients du filtre.
De façon générale le filtre à réponse impulsionnelle finie est décrit par la combinaison
linéaire suivante :
2) Implémentation du filtre FIR sur Matlab :
On implémente le programme du filtre FIR sur Matlab et on obtient un vecteur qui contient
les échantillons de sortie. Ce vecteur sera la référence par la suite afin de comparer les
résultats avec ceux de la carte DSP pour évaluer ses performances.
Le code de filtre sur Matlab est présenté comme suit :
2$
$
2) Changer$les$fréquences$du$filtre$FIR$selon$votre$choix$puis$cliquer$sur$«$Design$
Filter$»$
$
3) Sur$cette$dernière$fenêtre$cliquer$sur$TargetsàGenrate$C$header$…$
Dans$la$fenêtre$ouverte$choisir$«$Single<precision<float<»$puis$Generate.$Enregistrer$
le$fichier$sous$le$nom$de$«$Coeff.h<»$dans$un$emplacement$bien$connu$pour$vous.$
Ce$fichier$contient$les$coefficients$du$filtre.$Il$faut$le$placer$avec$le$fichier$des$
données$fourni$«$Inputs.h<»$dans$le$dossier$du$projet$qui$sera$créé$par$la$suite.$
'
C- Partie'3':'Implémentation'en'C'
1) Créer$un$projet$sous$CCS$avec$le$nom$«$Filter_FIR_SP$».$$
Pour$implémenter$notre$filtre$FIR$en$utilisera$le$principe$de$la$pile$glissante$pour$les$
données$d’entrée$et$la$pile$fixe$pour$les$coefficients :
3$
$
Le$code$correspondant$est$le$suivant$:$
$
$
2) Ecrivez$ensuite$un$programme$complet$en$C$qui$calcule$et$affiche$pour$chaque$
entrée$xi$du$tableau$Entrees[]$(800$entrées)$$du$fichier$«$Inputs.h<»$la$réponse$yi$du$
filtre.$Ce$programme$fait$appel$à$la$fonction$FIR()$donnée$ci-dessus.$(Voir$TD1)$
3) Donnez$alors$le$rapport$de$l’efficacité$:$$
Eff_FIR_SP_C=<Nb_MAC/Cycles_CPU<
$
D- Partie'4':'Implémentation'en'Assembleur'C6000'
Créez$un$nouveau$fichier$où$vous$allez$placer$les$routines$en$assembleur.$
Les$données$et$les$coefficients$sont$des$réels$simple$précision,$on$donne$par$la$suite$
les$instructions$qui$seront$utilisées$pour$ce$type$:$
FADDSP$pour$l’addition$
MPYSP'pour$la$multiplication$
Cherchez<dans<le<tutoriel<des<instructions<(instruction<set<and<cpu<-<sprugh7.pdf)<pour<
voir<leurs<descriptions<<
1) Ecrivez$une$première$version$en$assembleur$de$la$fonction$FIR().$$On$l’appellera$
_FIR_SP_asm_1.$Utilisez$dans$cette$version$les$instructions$FADDSP$et$MPYSP$
2) Ecrivez$une$deuxième$version$en$utilisant$le$pipelining.$Pour$cela,$commencez$par$
la$table$de$programmation,$puis$écrivez$le$code$en$utilisant$SPLoop$Buffer.$
Pour$chaque$version,$donnez$le$rapport$d’efficacité.$
3) Présentez$dans$un$tableau$les$résultats$(cycles,$rapports).$Comparer$et$conclure.$
4$
$
E- Partie'5':'Options'du'compilateur.'
$
Le$compilateur$possède$plusieurs$niveaux$de$compilation$pour$optimiser$le$code.$
Pour$accéder$à$ces$options,$click$droit$sur$le$projet$puis$choisir$:<Properties->CCS<
Build->C6000<Compiler-><Optimization-><Optimization<level$$
- Niveau$0$:$pour$éliminer$le$code$inutilisé́$et$attribution$des$registres$aux$
variables$utilisées$
- Niveau$1$:$$suppression$des$variables$non$utilisées.$
- Niveau$2$:$software$pipelining$et$déroulage$de$boucle$(loop$unrolling)$
- Niveau$3$:$pour$supprimer$des$fonctions$non$utilisées,$réorganisation$des$
déclarations$des$fonctions$de$façon$à$ce$que$les$attributs$appelés$soient$alors$
connus.$
- $
- 1)$Comparer$le$code$en$C$et$le$code$en$assembleur$en$appliquant$les$4$niveaux.$Avec$des$
histogrammes,$représentez$les$résultats$obtenus$en$terme$de$performance.$Conclure$
$
$
Un$autre$moyen$d’optimisation$à$travers$le$compilateur$concernant$la$rapidité$du$code$:$
«$Optimize$for$speed$»$
5$
$
2) Comparer$le$code$en$C$et$les$codes$en$assembleur$en$appliquant$les$6$niveaux.$Avec$
des$histogrammes,$représentez$les$résultats$obtenus$en$terme$de$performance.$Quel$
niveau$a$le$plus$d’impact$?$Conclure.$
$
1
/
5
100%
