Rapport TP

Module : DSP
Filière : GSEII

Enseignant : Pr. A. ELBDOURI

Réalisé par:
Hamza NAEM
Samuel KUMA YAO

Année universitaire 2022/2023

 Lab-1 : Initiation au Code Composer
Studio (CCS)
Profilage du code

1-1- Objectifs du TP
L’objectif de ce TP est de se familiariser avec l’environnement de
développement CCS de Texas Instruments et le starter kit DSP (DSK) en plus
d’être capable d’estimer les performances du DSP C67, utiliser les capacités
de l’environnement de développement CCS, manipuler et afficher des données
ainsi que tester un traitement élémentaire.
1-2- Présentation de la plateforme DSP
La carte STN1 est un système didactique spécialement conçu pour permettre
à l’utilisateur d’acquérir une expérience pratique dans le traitement des
signaux, STN1 peut être utilisé :

 Soit avec une Plate-forme TMS320Cxxx DSK de TEXAS INSTRUMENTS

 Soit comme une carte autonome

La carte STN1 sert au :

 Filtrage numérique
 Corrélateurs
 Traitement sur le signal
 Traitement sur les données
 Calcul numérique
 Modulation
 Analyse spectrale
1-3- Mise en marche et diagnostique de la carte
Nous avons alimenté le kit, les LEDs commencent à clignoter puis restent
allumées. On branche le câble USB puis on lance DSK Diagnostics Utility pour
lancer diagnotiquer le kit.
Si tout va bien, on crée notre 1er projet.
On va suivre les étapes de création de répertoire, création de nouveau projet,
création de configuration CDB (Configuration Data Base) et l’ajout de script
C suivant :
#include <stdio.h>
#define TAILLE_MAX 256
short a[TAILLE_MAX], x[TAILLE_MAX];
volatile int y = 0;
int dotp(short *m, short *n, int count) ;
main()
{
int i;
for (i = 0; i < TAILLE_MAX; i++) {
a[i] = i;
x[i] = TAILLE MAX - i;
}
y = dotp (a, x, TAILLE_MAX) ;
y = dotp (a, x, TAILLE_MAX) ;
printf("y = %d\n", y);
}
int dotp(short *m, short *n, int count)
{
int i, sum = 0;
for (i = 0; i < count; i++)
sum = sum + m[i] * n[i];
return sum;
}

Après avoir compilé et linké le programme, on obtient un fichier projet1.out

En gardant la fenêtre de désassemblage en arrière-plan, on exécute le
programme en pas à pas :
- Debug : Go Main
- Sélectionne la variable « y » pour l’ajouter a « Watch Window »
- Après exécution on obtient le résultat : y = 2796160.
 Lab-2 : Manipulation de
l’environnement DSK avec (CCS) et les
modes d’acquisition/génération

2-1- Objectifs du TP
L’objectif de ce TP est de se familiariser avec l’environnement de
développement CCS de Texas Instruments et le starter kit DSP (DSK) en plus
d’être capable d’estimer les performances du DSP C67, utiliser les capacités
de l’environnement de développement CCS, manipuler et afficher des données
ainsi que tester un traitement élémentaire.
2-2- Création d’un projet sur starter kit DSP (DSK)
On crée un répertoire à notre nom dans D:\TP_2\Manip1 et puis on Lance le
setup de code composer studio (CCS) :

Nous devons supprimer la configuration existante en sélectionnant notre kit

DSK "C6713 DSK" dans Code Composer Studio, puis en sauvegardant et
quittant le logiciel. Nous devons également vérifier que la carte est
correctement alimentée. • Si tout va bien on crée notre premier projet.
On va commencer par un projet qui est fourni par le constructeur. Il permet
de clignoter la led_0 ainsi que commencer le clignotement de la led_3 par
interuption_3
1- On lance le « 6713 DSK CC Studio v3.3.exe ».
2- Après le lancement du CCS, on clique sur (debug ➔ Connect) afin
d’établir la connexion entre le logiciel et le kit
3- On ouvre le projet led.pjt qui existe déjà dans le dossier dont le chemin
est : (C:\CCstudio_v3.3\exemples\dsk6713\bsl\led)
4- Pour visualiser le code du programme on clique sur source ➔ led.c.
Pour compiler le projet on clique sur (project Build). Si on obtient (0 Errors,
0Warning, 0Remark) On comprend que tous se passe bien.

Pour charger le programmer dans le DSP, on clique sur le file  load program
puis on choisit le fichier led.out.

Pour exécuter le programme on clique sur :Debug  run.

Debug  halt pour mettre fin à l’exécution.

2-3- Création d’un nouveau projet :
Dans cette partie on va créer notre propre projet intitulé Sin8_led, dont la
fonction est de générer en sortie un signal sinusoïdale puis allumer la led_0 si
l’interrupteur DIP_0 est actif (DIP_0=1).
1- On démarre CCS.
2- Puis sur project on clique sur new : project➔ new.

Dans cette phase on donne le nom du projet et on choisit la version DSP avec
lequel on veut travailler, Dans notre cas on choisit TMS320C67XX, et on
choisit aussi la location de notre projet.

3- Et pour écrire le code C on clique sur file New ➔Source File.

4- Et on tape le programme suivant :
#include "dsk6713_aic23.h"
Uint32 fs=DSK6713_AIC23_FREQ_8KHZ;
short loop=0;
short gain=10;
short sine_table[8]={0,707,1000,707,0,-707,-1000,-707};
void main()
{
comm_poll();
DSK6713_LED_init();
DSK6713_DIP_init();
while(1)
{
if(DSK6713_DIP_get(0)==0)
{
DSK6713_LED_on(0);
output_sample(sine_table[loop]*gain);
if(loop < 7)++loop;
else loop=0; } else DSK6713_LED_off(0); }}
5- On enregistre ce fichier dans le dossier de project sous le nom
sine8_LED.c
6- Puis on ajoute le fichier Sine8_LED. C Au project ➔add Files to Project.
7- Et pour assurer le bon fonctionnement du programme il faut ajouter le
fichier c6713dskinit.c ainsi que les librairies supports rts6700 .lib,
 dsk6713bsl.lib et csl6713.lib ainsi que le fichier de liaison c6713
c6713dsk.cmd, et le Vectors_poll.asm.

8- On règle les optoins de compilation : Projet → build option dans cette

phase on choisit
9- Target Version : C671X (mv 6710) 10- Advanced : Memory Models Far
(-mem_model : data=far)
10- Advanced : Memory Models Far (-mem_model : data=far)

11- Préprocesseur :pre –Defi ne Symbol=CHIP_6713

12- Include Search

Path=c:\CCStudio_v3.1\C6000\dsk6713\include

13- Library search Path=c:\CCStudio_v3.1\C6000\dsk6713\lib

14- On applique un scan des fichiers ajoutés : projectAll File
Dependencies.

15- Et en fin on exécute notre programme qui va générer la

sinusoïde.
 On fait de même pour le signal carré :

2-4- Echantillonnage/Reconstruction avec le mode Poll et Intr :

• Première Partie : Mode Poll :
On Crée ensemble un nouveau projet en ajoutant le fichier "victor_poll.asm".
Ensuite, copions le code C suivant (les fonctions appelées sont détaillées dans
l'annexe).
#include "DSK6713_AIC23.h"
Uint32 fs=DSK6713_AIC23_FREQ_8KHZ;
#define DSK6713_AIC23_INPUT_LINE 0x0011
Uint16 inputsource=DSK6713_AIC23_INPUT_LINE;
void main()
{
short sample_data;
comm_poll();
while(1)
{
sample_data = input_left_sample();
output_left_sample(sample_data);
}

Q1-Pour que l'acquisition se fasse sur les deux canaux gauche et droit, et que
le signal soit dirigé vers le canal droit si SW3 est sélectionné et vers le canal
gauche si SW1 est sélectionné, nous devons effectuer les modifications
suivantes :
#include "DSK6713_AIC23.h"
Uint32 fs = DSK6713_AIC23_FREQ_8KHZ;
#define DSK6713_AIC23_INPUT_LINE 0x0011
Uint16 inputsource = DSK6713_AIC23_INPUT_LINE;
void main()
{
 short sample_data;
comm_poll();
while (1)
{
sample_data = input_sample(); // Acquisition des échantillons sur les deux
canaux
if ((SW3 == 1) && (SW1 == 0))
{
output_right_sample(sample_data); // Sortie sur le canal droit
}
else if ((SW3 == 0) && (SW1 == 1))
{
output_left_sample(sample_data); // Sortie sur le canal gauche }
else if ((SW3 == 1) && (SW1 == 1))
{
output_left_sample(sample_data); // Sortie sur les deux canaux
output_right_sample(sample_data);
}}}
Q2-Pour appliquer un signal sinusoïdal sur LINE INPUT et visualiser la sortie
sur LINE OUTPUT, vous devez vous assurer que l'amplitude du signal est
inférieure à 1V avant la connexion. Vous pouvez utiliser des fonctions
supplémentaires pour générer le signal sinusoïdal et le configurer comme
entrée. Voici un exemple de modification :
#include "DSK6713_AIC23.h"
#include Uint32 fs = DSK6713_AIC23_FREQ_8KHZ;
#define DSK6713_AIC23_INPUT_LINE 0x0011
Uint16 inputsource = DSK6713_AIC23_INPUT_LINE;
void main()
{
short sample_data;
float amplitude = 0.5; // Amplitude sinusoïdale (ajustez selon les besoins) float frequency =
1000; // Fréquence sinusoïdale (ajustez selon les besoins) float phase = 0; // Phase sinusoïdale
(ajustez selon les besoins)
comm_poll();
while (1)
{
// Génération du signal sinusoïdal
sample_data = (short)(amplitude * sin(2 * M_PI * frequency * phase));
input_sample(sample_data); // Appliquer le signal sinusoïdal sur LINE INPUT phase += 1.0 / fs;
// Mise à jour de la phase en fonction de la fs output_sample(sample_data); // Visualisation
du signal sur LINE OUTPUT
}}
Q4-Pour changer le signal sinusoïdal en un signal carré, vous pouvez utiliser
une fonction de génération de signal carré et l'appliquer de la même manière
que le signal sinusoïdal précédent. Voici un exemple de modification :
#include "DSK6713_AIC23.h"
Uint32 fs = DSK6713_AIC23_FREQ_8KHZ;
#define DSK6713_AIC23_INPUT_LINE 0x0011
Uint16 inputsource = DSK6713_AIC23_INPUT_LINE;
void main()
{
short sample_data;
float amplitude = 0.5; // Amplitude du signal carré (ajustez selon les besoins) float frequency
= 1000; // Fréquence du signal carré (ajustez selon les besoins)
float phase = 0; // Phase du signal carré (ajustez selon les besoins) comm_poll();
while (1)
{
if (phase < 0.5)
{
sample_data = (short)(amplitude);
}
else
{
sample_data = (short)(-amplitude);
}
input_sample(sample_data); // Appliquer le signal carré sur LINE INPUT phase += 1.0 / (2 *
frequency); // Mise à jour de la phase en fonction de fs
output_sample(sample_data); // Visualisation du signal sur LINE OUTPUT
}}
Q6-Pour changer DSK6713_AIC23_FREQ_8KHZ en
DSK6713_AIC23_FREQ_48KHZ, vous devez effectuer les modifications
suivantes dans le code :
#include "DSK6713_AIC23.h"
Uint32 fs = DSK6713_AIC23_FREQ_48KHZ; // Modifier la fs
#define DSK6713_AIC23_INPUT_LINE 0x0011
Uint16 inputsource = DSK6713_AIC23_INPUT_LINE;
// Reste du code inchangé
void main()
{
short sample_data;
float amplitude = 0.5; // Amplitude du signal carré (ajustez selon les besoins) float frequency
= 1000; // Fréquence du signal carré (ajustez selon les besoins)
float phase = 0; // Phase du signal carré (ajustez selon les besoins) comm_poll();
while (1)
{
if (phase < 0.5)
{
sample_data = (short)(amplitude);
}
else
{
sample_data = (short)(-amplitude);
}
input_sample(sample_data); // Appliquer le signal carré sur LINE INPUT phase += 1.0 / (2 *
frequency); // Mise à jour de la phase en fonction de fs
output_sample(sample_data); // Visualisation du signal sur LINE OUTPUT
}}
Q7-En conclusion, ce programme vous a permis d'explorer différentes
fonctionnalités et manipulations du signal à l'aide de la carte DSK6713 et de
la bibliothèque DSK6713_AIC23. Vous avez appris à acquérir et à traiter des
signaux audios, à générer des signaux sinusoïdaux et carrés, à contrôler les
canaux de sortie en fonction des commutateurs (SW1 et SW3), et à analyser
la réponse en fréquence du système. Vous avez également examiné l'impact
de la fréquence d'échantillonnage sur la qualité du signal de sortie. Ces
expérimentations vous ont donné une meilleure compréhension du traitement
du signal audio en utilisant le DSP et la carte DSK6713. 12
• Deuxième Partie : Mode Intr
On Supprime la bibliothèque victor_poll.asm (remove from project) et ajoutez
victor_intr.asm et changez comm_poll par comm_intr et on Modifiez le
programme, comme ci-dessous :
#include "DSK6713_AIC23.h" //support du codec
Uint32 fs=DSK6713_AIC23_FREQ_8KHZ;
#define DSK6713_AIC23_INPUT_LINE 0x0011
Uint16 inputsource=DSK6713_AIC23_INPUT_LINE;
interrupt void c_int11()
{
short sample_data;
sample_data = input_left_sample();
output_left_sample(sample_data);
return;
}
void main()
{
comm_intr();
while(1);
}
Q1-Pour faire le traitement sur le canal droit, vous pouvez modifier le code
comme suit :
 #include "DSK6713_AIC23.h"
Uint32 fs = DSK6713_AIC23_FREQ_8KHZ;
#define DSK6713_AIC23_INPUT_LINE 0x0011
Uint16 inputsource = DSK6713_AIC23_INPUT_LINE;
interrupt void c_int11()
{
short sample_data;
sample_data = input_right_sample(); // Traitement sur le canal droit
output_right_sample(sample_data);
return;
}
void main()
{
comm_intr();
while (1);
}
Q2-Pour faire le traitement sur les deux canaux simultanément, vous pouvez
utiliser les fonctions input_sample() pour acquérir les échantillons des deux
canaux et output_sample() pour les sortir simultanément. Voici un exemple
de modification :
#include "DSK6713_AIC23.h"
Uint32 fs = DSK6713_AIC23_FREQ_8KHZ;
#define DSK6713_AIC23_INPUT_LINE 0x0011
Uint16 inputsource = DSK6713_AIC23_INPUT_LINE;
interrupt void c_int11()
{
short sample_data;
// Traitement sur les deux canaux simultanément
sample_data = input_sample();
output_sample(sample_data);
return;
}
void main()
{
comm_intr();
while (1);
}
Q3-Le problème majeur de l'utilisation du mode poll est qu'il nécessite une
vérification constante de l'état des entrées/sorties. Cela peut entraîner une
utilisation intensive du processeur et une inefficacité énergétique, car le
processeur est constamment sollicité même lorsqu'il n'y a pas de changements
significatifs dans les données d'entrée. De plus, cela limite la capacité du
processeur à effectuer d'autres tâches pendant l'attente des données d'entrée.
• Troisième Partie : LookUpTable
- Cette partie permettra de générer un signal sinusoïdale sur le canal gauche
par la méthode LookUpTable afin d’observer le rôle du filtre de reconstruction.
- Le programme est le suivant :
#include "DSK6713_AIC23.h"
Uint32 fs=DSK6713_AIC23_FREQ_8KHZ;
#define DSK6713_AIC23_INPUT_LINE 0x0011
Uint16 inputsource=DSK6713_AIC23_INPUT_LINE;
#define LOOPLENGTH 8
short loopindex = 0; //table index
short gain = 10; //gain
short sine_table[LOOPLENGTH]= {0,707,1000,707,0,-707,-1000,-707};
interrupt void c_int11()
{
output_left_sample(sine_table[loopindex++]*gain);
if (loopindex >= LOOPLENGTH) loopindex = 0;
return;
}
void main()
{
comm_intr();
while(1);
}

Ce code génère un signal sinusoïdal à partir d'une table de sinusoïdes

prédéfinie et l'envoie à la sortie audio gauche avec un gain spécifié. Ce code
permet de générer des signaux audios de différentes fréquences et amplitudes
pour des applications de traitement audio ou de test.
 Lab-3 : Interfaces du CCS et traitement
du Son du DSP

3-1- Objectifs du TP
Les effets sonores sont les premières applications du DSP dans le monde du
son, ils exploitent le traitement en temps réel et quelques propriétés naturelles
de l’acoustique telle que le retard, l’écho ou le fading. L’objectif de ce TP est de
comprendre comment utiliser les options de débogage disponibles dans
l’environnement de développement CCS (Code Composer Studio), et d’exploiter
le DSP pour réaliser des traitements sur des signaux audio.
3-2- Interfaces CCS :
Pour manipuler cette interface on va commencer par le programme suivant :
#include "dsk6713_aic23.h" //codec support
Uint32 fs = DSK6713_AIC23_FREQ_8KHZ;
#define DSK6713_AIC23_INPUT_LINE 0x0011
Uint16 inputsource=DSK6713_AIC23_INPUT_LINE;
#define LOOPLENGTH 8
short loopindex = 0; //table index
short gain =10; //gain
short sine_table[LOOPLENGTH]= {0,707,1000,707,0,-707,-1000,-707}; //sine
interrupt void c_int11()
{
output_left_sample(sine_table[loopindex++]*gain);
if (loopindex >= LOOPLENGTH) loopindex = 0; //reset index
return;
}
void main()
{
comm_intr(); //init DSK,codec,McBSP
while(1);
}

Lors de l'exécution du programme, l'amplitude est presque de 1V et la

fréquence est d'environ 4 kHz. Pendant que le programme s'exécute, nous
ouvrons Quick Watch, saisissons notre gain, puis appuyons sur "Add to
Watch". En modifiant le gain, nous remarquons que la fréquence reste
inchangée tandis que l'amplitude augmente.
3-3- Méthode de création de GEL :
Le gel est un langage qui ressemble a C, il permet d’ajouter des fonctionnalités a CCS afin de rendre
l’interface plus convivial. Pour ce faire on appuis sur file → new→ Source→ file Et on tape le code
suivant :

//gain.gel GEL slider pour variation du gain

menuitem "Sine Gain"
slider Gain(0,30,4,1,gain_parameter) //incr
{ gain = gain_parameter; }
On enregistre ce fichier fileSave as → nom gain.gel Après le chargement par
loadGEl, on ouvre gain.gel puis GEL→SineGain→Gain et on charge la valeur
du gain.
3-4- Enregistrement du son :
Dans cette section, nous utilisons un tampon (ou buffer) situé dans la
mémoire externe pour stocker et restituer une séquence audio. Pour accomplir
cela, nous saisissons le code suivant :
D’aprés le programme on peut remarquer qu’on a commande l’enregistrement
par SW_3 comme il est indiqué dans le programme ci  dessus. Et la lecture
par SW_0.
3-5- Effet retard (Delay) et effet de l’écho ou le fading :
On peut obtenir des effets simples, mais frappants, par le retard des
échantillons lorsqu'ils passent de l'entrée à la sortie. Le code suivant permet
d’implémenter une ligne à retard en utilisant le buffer pour stocker les
échantillons lorsqu'ils sont lus à partir du codec.

En conclusion, ce programme utilise le DSP pour réaliser des traitements sur

des signaux audio. Il utilise un buffer pour stocker et restituer une séquence
audio, et exploite les fonctions de traitement en temps réel. Vous pouvez
exécuter le programme, contrôler la lecture du son, ajuster le gain et la durée
du délai à l'aide de curseurs, et observer les effets de ces modifications sur le
signal audio. • On diminue le du son puis on raccorde la sortie du lecteur MP3
à l’entrée LINE INPUT du DSK et on relie la sortie LINE OUT à un hautparleur.
Puis on lance notre programme on remarque qu’il y a un retard entre l’entrée
du son et sa sortie.
3-6- Conclusion :
Ce TP nous a permis de nous familiariser avec l’environnement du DSP, de
maîtriser l'utilisation de la carte DSK6713, d'expérimenter différents codes et
de tester divers phénomènes de traitement du signal

FIN.