Réalisé par : Encadrés par :

 AGHDOU YOUSSEF Mr A. KLILOU

 MEJDOUB MAROUANE
 GERRARD FRED ESSEY

Année Universitaire : 2018-2019

TP 1 :……………………………………………………………………….03
TP 2 : ………………………………………………………………………09
TP 3 : ………………………………………………………………………16
TP 4 : ………………………………………………………………………24
TP 5 : ………………………………………………………………………34

2
 Initiation à la programmation
D’un DSP par le logiciel Code Composer
Studio

3
1.1. Objectifs :
L’objectif principal de ce TP est de maitriser les étapes essentielles pour
développer une application de traitement numérique de signal sur la carte
DSK6713 en utilisant l’environnement de travail Code Composer Studio(CCS).

1.2. Travail à réaliser :

En guise de test ou de première application nous allons implémenter un
programme qui fait la somme de deux nombres de type float et qui affiche le
résultat sur la console du CCS. Les étapes à suivre sont les suivantes :
a. Création d’un nouveau projet :
Une fois le CCS ouvert il faut cliquer successivement sur « Project » puis
« New CCS Project » pour obtenir la fenêtre suivante afin de régler les
différents paramètres.

Une fois terminé on clique sur « finish ».

b. Ajout des bibliothèques :
b.1-Ajout de la bibliothèque include :
Cliquer sur Project → Properties → CCS Build → C6000 compiler → Include
options Click Add and select path "C:\C6xCSL\include"
Comme montre la figure suivante :

4
 b.2-Ajout de la bibliothèque csl6713.lib :
Cliquer sur Project →Properties → CCS Build → C6000 linker → File search
path → Include library file or ... Click Add and select path
"C:\C6xCSL\lib_3x\csl6713.lib"

b.3-Ajout de la bibliothèque CHIP_6713 :

Cliquer sur Project → Properties → CCSBuild → C6000 → Predefined Symbols.

5
Le projet étant créé et les bibliothèques ajoutées, il ne reste plus qu’à implémenter
le programme sur CCS :

Pour obtenir le résultat nous avons la possibilité de configurer la cible en

« Emulator » c’est-à-dire en utilisant la carte DSK6713 ou en simulation.

6
 c. Configuration de la cible en simulation :
Double click on Project → TMS320C6713.ccxml

 Select Texas Instruments Simulator from drop down list

 Select C6713 Device Cycle Accurate Simulator, Little Endian from the check
list
 Save

d. Configuration de la cible en Emulator :

Il faut bien sur veiller à connecter la carte DSK6713 et ensuite :
Double click on Project → TMS320C6713.ccxml

 Select Spectrum Digital DSK-EVM-eZdsp onboard USB Emulator from drop

down list
 Select DSK6713 from the check list
 Save

7
Puis en charge le programme vers le cible et en exécute le et le console de la CCS
nous affiche le résultat de la somme des deux nombres comme montre la figure
suivante :

8
Implémentation du filtre FIR sur la carte
DSK6713

9
2.1Objectifs :
Les objectifs de ce TP sont :
 Simulation sur Matlab d’un filtre à réponse impulsionnelle finie (RIF).
 Implanter ce filtre sur la carte DSK6713
 Mesure du temps d’exécution du programme
 Réduction du temps d’exécution en utilisant les options du compilateur
 Maitriser l’emplacement des données

2.2. Simulation Matlab d’un filtre FIR :

Il s’agit ici d’implémenter un filtre FIR et de créer un signal formé de différentes
fréquences afin de tester le filtre.
Nous allons donc créer un répertoire et implémenter un programme qui permet de
générer un filtre FIR d’ordre N=100 et 101 coefficients, ce sera un filtre passe
bande entre [200,400] :

Nous allons aussi implémenter les transformées de fourrier du signal initial et filtré
et les tracer. Nous allons aussi enregistrer les coefficients du filtre sous forme de
fichier « .dat » ainsi que les échantillons du signal à multiples fréquences afin de
les utiliser dans le CCS et comparer les deux résultats.

10
 On voit bien que le signal initial en bleu a été filtré pour donner le signal en
rouge et ce même dans le domaine fréquentiel.
2.2. Implémentation d’un filtre FIR sur la Carte DSK6713 :

11
Il faut reprendre les mêmes étapes que dans les travaux pratiques 1 à savoir la
création du projet et l’ajout des différentes bibliothèques et importer également les
fichiers « .dat » générés par Matlab à savoir le fichier « coeff.dat » qui contient les
coefficients du filtre FIR et « input.dat » qui contient les échantillons du signal à
plusieurs fréquences.
Ceci s’effectue en suivant les étapes suivantes :
Sélectionner le projetfileheader filenom du fichier.h : ceci pour la
création des fichier.h dans le code composer au sein desquels nous allons copier les
données voulues.
Voilà nous avons créé les deux fichier.h comme montre la figure suivante :

12
Nous allons donc créer deux fichier.h (« coeff.h » et « input.h ») dans lesquels
nous allons copier les coefficients dans le premier et les échantillons dans le
deuxième comme il est indiqué dans les deux figures ci-dessous :
Ensuite nous allons créer un fichier « main.c » pour implémenter le programme
principal :
Sélectionner le projetfilesource filenom du fichier.h

13
Ensuite nous allons créer un fichier « main.c » pour implémenter le programme
principal
Puis dans cette étape il faut ajouter les fichiers.h que nous avons déjà créés suivant
ces étapes :
Sélectionner le projetfilesource file nom du fichier.h

Il faut ensuite configurer la cible en « Emulator » après avoir ajouté la carte

comme détaillé dans les travaux pratiques1 et faire :
ToolsGraphSingle timeconfiguration manuelle des paramètres comme suit :

14
Et également en « Simulator »
ToolsGraphSingle timeconfiguration manuelle des paramètres
Et voilà l’allure de sortie :

15
Optimisation du filtre FIR sur la carte
DSK6713

16
3.1-Objectifs :
Les objectifs de ce TP sont :
 Mesure le temps d’exécution du programme à l’aide du périphérique Timer.
 Calcul de l’efficacité du DSP en MAC/cycle.
 Réduction du temps d’exécution en utilisant les options du compilateur.
 Maitrise de l’emplacement des données.

3.2Travail à réaliser :
a-Mesure le temps d’exécution :
La mesure du temps d’exécution d’un programme faite à l’aide des deux Timers de
32 bits à usage général. Ces deux Timer sont utilisés pour faire le comptage des
cycles d’horloge du DSP.
Nous allons régler ce Timer afin qu’un cycle compté par ce Timer afin qu’un cycle
compté par ce Timer corresponds à 4 cycles CPU. C’est le temps minimum qu’un
Timer peut compter.
Et comme travail à faire on va mesurer le temps d’exécution du filtre FIR, en
suivant ces étapes :
- En sélectionnant notre projet puis en ajoutant la bibliothèque CSL.
- En inclure le fichier csl_timer.h
- En déclare les variables suivantes :
TIMER_Handle hTimer;
Unsigned long int start, stop, overhead, diff;
-En configure le Timer comme suivant :
HTimer=TIMER_open (TIMER_DEVANCY ,0) ;
TIMER_configArgs (hTimer, 0x000002C0 ,0xFFFFFFFF, 0x00000000) ;
-En calculant le temps de Timer par l’ajout des instructions suivant dans le
programme :
Start =TIMER_open (TIMER_DEVANCY, 0);
Stop =TIMER_getCount (hTimer);
Overhead=stop-start;
- En calculant la valeur du Timer avant et après le programme puis en calculant
la différence comme suivant :

17
 Start =TIMER_getCount (hTimer);

( Programme FIR)
Stop=TIMER_getCount(hTimer);
Diff=(stop-start)-overhead ;
En suivant toutes les étapes précédente afin de créé le programme final qui calcul
le temps d’exécution d’un filtre FIR comme illustre la figure suivante :

18
 b- Calcul de l’efficacité du DSP en MAC/cycle :

L’efficacité d’un DSP en MAC /cycle est le rapport entre le nombre de MAC que
nécessitent théoriquement l’algorithme et le nombre de cycle mesuré pratiquement
après l’exécution de l’algorithme.

Efficacité (MAC/cycle) = (Nombre de Mac théorique) / (Nombre de cycle mesuré)

Pour le cas du filtre FIR, nous avons :
 Nombre du coefficient du filtre N=101.
 Taille du signal d’entrée : 800.
Donc le nombre total de MAC théorique est égal à 800*101=80 800
Alors Efficacité = (80 000/3359916) =0.02381.
Alors sans intervention d’optimisation on a obtenu un’ efficacité de 0.0238.
Afin d’optimiser l’efficacité du DSP on va étudier dans la partie suivante réduction
du temps d’exécution en utilisant les options du compilateur.
C- Réduction du temps d’exécution en utilisant les options du
compilateur :
Le compilateur de l’environnement code composer studio offre 4 niveaux
d’optimisation pour réduire le temps d’exécution d’un programme. Voici l’effet de
chaque niveau d’optimisation :
 0
 1
 2
 3

19
Alors pour sélectionner un niveau d’optimisation il faut suivre les étapes
suivantes :
Sélectionner le projetproperties Build C6000 compiler Optimization

Alors dans notre travail on s’intéresse à calculer le nombre de cycle ainsi

l’efficacité pour chaque niveau d’optimisation :

20
Le niveau d’optimisation est réglé il nous reste que lancé l’exécution du
programme pour calculer le nombre de cycle comme montre la figure suivante :

Alors :
Efficacité = (80 000/3359916) = 0.03089918148
De la même manière pour les autres niveaux d’optimisation et en résume tout dans
le tableau suivant :
Niveau d’optimisation Nombre de cycles mesuré Efficacité en MAC/cycle
off 3358460 0.02405864598
0 2614956 0.03089918148
1 1719748 0.04698362783
2 173504 0.4656953154
3 173504 0.4656953154

d-maitrise de l’emplacement des données :

Le DSP C6713 possède plusieurs mémoires pour stocker les données :
 Mémoire interne SRAM.
 Mémoire externe DRAM.

Alors notre travail consiste à garder le niveau d’optimisation 3 et changer à chaque

fois l’emplacement des données dans la mémoire. Ainsi à chaque fois il faut
calculer l’efficacité afin de voir et de conclure le bon emplacement des données
dans la mémoire.

21
Pour le 1er essai on a stocké toute les variables et les données (Input, output,
coefficient, et le X-buffer) dans IRAM, puis on lance la simulation et la console
affiche le nombre de cycles correspondant à cet essai.

Efficacité = (80 000/173428) =0.461286528.

En effectuant plusieurs tests de la même manière on rédige un tableau qui donne
l’efficacité correspondante aux emplacements mémoires choisis :

22
 Stockage des donnés Cycle L’efficacité
Input et output : L1 174328 0.461286528.
Coefficients et le X-buffer :L1
Input et output : L2 174356 0.46183040
Coefficients et le X-buffer :L2
Input et output : DRAM 486783 0.018990
Coefficients et le X-
buffer :DRAM
Input et output : DRAM 259316 0.31158894
Coefficients et le X-buffer :L1
Input et output : L1 4167560 0.0193901
Coefficients et le X-
buffer :DRAM

Les meilleures performances sont obtenues lorsque tous les coeff, X-buffer, input
output sont stocker dans la mémoire interne L1 ou L2.
Sinon stocker en externe l’input et l’output et les coefficients et X-buffer en interne
parce qu’ils sont beaucoup utilisés.

23
Implémentation et Optimisation du filtre IIR
sur la carte DSK6713

24
4.1-Objectifs :
Les objectifs de ce TP sont :
 Simuler sur MATLAB un filtre à réponse impulsionnelle infinie RII.
 Implémenter ce filtre sur la carte DSK6713.
 Comparer les résultats obtenus par matlab et celles obtenus par la carte.
 Optimisation du temps d’exécution.

4.2-Simulation Matlab d’un filtre IIR :

En comparant les méthodes suivies dans le filtre FIR ; on remarque qu’elles sont
les mêmes adoptés pour simuler le filtre IIR.
En les suivants on aura :

25
On recoure vers ccs :et après avoir obtenu les coefficients d’après MATLAB on
compare entre le traitement fait à base du simulator et le traitement fait à base de la
carte DSK6713.
On la programmer pour realiser cette tache :
#include <stdio.h>
#include "coef_IIR.h"
#include "input.h"
#include "math.h"
#include "output_ref.h"
#include "csl_timer.h"

float x_buffer [N+1];

float y_buffer [N+1] ;
float filtre_IIR (float xn);

float output[H];
TIMER_Handle hTimer;
unsigned long int start,stop,overhead,diff;

26
#pragma DATA_SECTION(input, ".input_DATA");
#pragma DATA_SECTION(output, ".output_DATA");
#pragma DATA_SECTION(coef_a, ".coef_a_DATA");
#pragma DATA_SECTION(coef_b, ".coef_b_DATA");
#pragma DATA_SECTION(x_buffer, ".x_buffer_DATA");
#pragma DATA_SECTION(y_buffer, ".y_buffer_DATA");

void main ()
{

hTimer=TIMER_open(TIMER_DEVANY,0);
TIMER_configArgs(hTimer,0x000002C0,0xFFFFFFFF,0X00000000);

start=TIMER_getCount(hTimer);
stop=TIMER_getCount(hTimer);
overhead=stop-start;

printf("Start prog");
int i;
for (i=0;i<N;i++) {
x_buffer[i]= 0;
y_buffer[i]= 0;
}

start = TIMER_getCount (hTimer);

for (i=0;i<H;i++)
output[i]=filtre_IIR(input[i]);

stop= TIMER_getCount(hTimer);

diff=(stop-start)-overhead;

printf("End prog");
printf("le nombre de cycle est %d : cycles \n",diff*4);
TIMER_close(hTimer);

27
 int compt=0;
float err;
for (i=0;i<H;i++)
{
err= abs(output[i]-output_ref[i]);
if(err> 0.0001)
{
compt++;
}

printf("compt = %f",compt);

float filtre_IIR(float xn)

{
int i;
float yn=0;
x_buffer[0]=xn;
for (i=N-1;i>=0;i--)
{
yn += coef_b[i]*x_buffer[i];
x_buffer[i+1]= x_buffer[i];
}

for (i=N-1;i>=1 ;i--)

{
yn -= coef_a[i]*y_buffer[i];
y_buffer[i+1]= y_buffer[i];
}

y_buffer[1]=yn;
return yn;
}

28
On aura les résultats suivants :

Le signal INPUT : simulation :

Le signal filtré :

29
Le signal de sortie de référence :

On remarque que les deux figures de sortie sont presque les mêmes.
Maintenant on essaye de faire la même chose mais en exécutant le programme
dans la carte :
Le signal INPUT dans la carte :

30
Le signal OUTPUT de la carte :

Le signal OUTPUT de référence :

31
Ces résultats là sont obtenus en fournissant les coefficients suivant obtenus par
Matlab au programme compilé par le CCS et la carte :

Maintenant on essaye d’optimiser le temps d’exécution. En suivant les mêmes

étapes suivis précédemment : on a eu les résultats suivants :

32
Niveau Nombre de cycle Efficacité Temps d’exécution
Off 3358148 0.003 14.9ms
0 2315740 0.0039 11.61ms
1 1720544 0.006 7.63ms
2 173376 0.069 0.769ms
3 173376 0.069 0.769ms

33
FILTRAGE EN TEMPS REEL D’UN SIGNAL
AUDIO PAR LE DSP TMS 320C6713

34
5.1-Objectifs :

Les objectifs de ce TP sont :

 Configurer le Codec Stereo AIC23 que contient la carte DSK6713.

 Filter le signal audio bruité par matlab.
 Filter le signal audio bruité en temps réel.

5.2-Filtrage d’un signal bruité par MATLAB :

On acquit un signal AUDIO bruité de l’Ordinateur sous format.wav , on le
représente sur MATLAB et on essaye de le filtrer en utilisant le filtre IIR qu’on a
déjà fait dans le TP précédent.
Après avoir faire le programme sur matlab on a eu les résultats suivants :
clear all
close all
clc
f1=50;
f2=300;
f3=2000;
fc1=900;
fc2=2000;
fc3=[9900 10100];
N=3;
Te=1/Fe;
M=length(x);
Tm=M*Te;
w1=fc3/(Fe/2);

t=0:Te:Tm-Te;
f=0:1/Tm:Fe-1/Tm;
X=fft(x);
X1=fft(x1);
[b,a]=butter(N,fc3/(Fe/2),'stop');
y=filter(b,a,x1);
figure(2);
subplot(3,2,1);
plot(t,x1); title('signal temporel x avant filtrage');
xlabel('le temps');
subplot(3,2,3);
plot(t,y,'r'); title('signal temporel x apres filtrage');
xlabel('le temps');
X=fft(x);
Y=fft(y);
subplot(3,2,2);
plot(f,X1,'b');
xlabel('fréquence');
title('signal x avant filtrage');

35
 subplot(3,2,4);
plot(f,Y,'r');
xlabel('fréquence');
title('signal x après filtrage');
subplot(3,2,5);
plot(t,x,'g');
title('signal original du son');
subplot(3,2,6);
plot(f,X,'g');
title('spectre du signal original');
p1= audioplayer (y, Fe);
play (p1);

fid1=fopen('coef_b.dat','w');
for i=1:2*N+1
fprintf(fid1,'%.10f,\n',b(i));
end
fclose(fid1);
fid2=fopen('coef_a.dat','w');
for i=1:2*N+1
fprintf(fid2,'%.10f,\n',a(i));
end
fclose(fid2);

imp=[1,zeros(1,M-1)];
h = filter(b,a,imp);
H=fft(h);

figure
subplot(2,1,1)
plot(t,h);
subplot(2,1,2)
plot(f,20*log10(H));

36
37
Après avoir lancé ce code on a eu :

Après on a essayé de faire la même chose mais cette fois avec le CCS :
On a saisi le code convenable pour cette opération :
#include <stdio.h>
#include "math.h"
#include "coef_IIR.h"
#include "csl_timer.h"

float x_buffer [N+1];

38
float y_buffer [N+1] ;
float filtre_IIR (float xn);

TIMER_Handle hTimer;
unsigned long int start,stop,overhead,diff;

#include "dsk6713.h"
#include "dsk6713_aic23.h"
DSK6713_AIC23_Config config = {
0x0017,
0x0017,
0x01f9,
0x01f9,
0x0011,
0x0000,
0x0000,
0x0043,
0x0081,
0x0001,

};

Uint32 buff;
Int16 buff2;
Int16 y;
float filtre_in;
float filtre_out;

void main() {

DSK6713_AIC23_CodecHandle hCodec;

DSK6713_init();
hCodec = DSK6713_AIC23_openCodec (0,&config);

hTimer=TIMER_open(TIMER_DEVANY,0);
TIMER_configArgs(hTimer,0x000002C0,0xFFFFFFFF,0X000
00000);

start=TIMER_getCount(hTimer);
stop=TIMER_getCount(hTimer);
overhead=stop-start;
39
 while(1)
{
while(!DSK6713_AIC23_read(hCodec,&buff));
start = TIMER_getCount (hTimer);

buff2=(Int16)buff;
filtre_in =(float)buff2;
filtre_out =filtre_IIR(filtre_in);
y=(Int16)filtre_out;

stop= TIMER_getCount(hTimer);
diff=(stop-start)-overhead;
while (!DSK6713_AIC23_write(hCodec, y));
while (!DSK6713_AIC23_write(hCodec, y));

float filtre_IIR(float xn)

{
int i;
float yn=0;
x_buffer[0]=xn;
for (i=N-1;i>=0;i--)
{
yn += coef_b[i]*x_buffer[i];
x_buffer[i+1]= x_buffer[i];
}

for (i=N-1;i>=1 ;i--)

{
yn -= coef_a[i]*y_buffer[i];
y_buffer[i+1]= y_buffer[i];
}

y_buffer[1]=yn;
return yn;
}
40
Cela est faites avec les coefficients obtenus par Matlab : qui sont comme c’est de
suit :

41