Introduction à Code Composer Studio 6.0.1

Contents
Introduction de la carte eZdsp5515 ..................................................................... 2
1.
Architecture générale du starter kit eZdsp5515 ........................................ 7
1.1 - Le circuit de traitement du signal ........................................................... 7
1.2 - Types de fichiers utilisés durant les sessions avec CCS ....................... 10
1.3 - Résumé des procédures de branchements ............................................. 11
2.
Expérimentation ...................................................................................... 17
2.1 - Validation de la carte eZdsp5515 ......................................................... 17
2.2 - Partie a) Breakpoint et exécution pas-à-pas .......................................... 21
2.3 - Partie b) Les entrées-sorties sous forme graphique .............................. 23
Figure 1 - Carte eZdsp5515 (Courtoisie de Texas Instrument)............................... 8
Figure 2 Endos de la carte eZdsp5515 (Courtoisie de Texas Instrument) .............. 8
Figure 3 Identification des connecteurs (Courtoisie de Texas Instrument) ............ 9
Figure 4 Bloc diagramme de la carte eZdsp5515 (Courtoisie de Texas Instrument)
........................................................................................................................................... 10
Figure 5 Configuration du DSP (mémoires, interfaces, registres...) (Courtoisie de
Texas Instrument) ............................................................................................................. 10
Figure 6- Reconfiguration des fenêtres dans le mode standard ............................ 13
Figure 7 - Définition de la configuration de la carte eZdsp5515. ......................... 13
Figure 8 -Création d'un fichier de configuration de la carte eZdsp5515 .............. 14
Figure 9 - Renommer le fichier par défaut par un autre nom................................ 14
Figure 10 - Choix du debug probe et du processeur ............................................. 15
Figure 11 - Test d'intégrité du branchement JTAG............................................... 15
Figure 12 - Launch target configuration (démarrage de la connection)................ 16
Figure 13 - Connection de la carte de développement .......................................... 16
Figure 14 - Importation d'un projet CCS .............................................................. 18
Figure 15 - Sélection du projet dans le dossier Projet_ezdsp5515\tests ............... 18
Figure 16 - Modification dans le fichier uled_test.c ............................................. 19
Figure 17 - Console donnant le résultat de la compilation et de la liaison (linkage)
........................................................................................................................................... 19
Figure 18 - Menu Project->Build All .................................................................... 20
Figure 19 - Chargement du programme binaire dans la carte eZdsp5515 ............ 21
Figure 20 - Fenêtre vous demandant le chemin du fichier à extension .out.......... 21
Figure 21 - Insertion d'un breakpoint .................................................................... 22
Figure 22 - Fenêtre du désassembleur au côté de la fenêtre du programme en C. 22
Figure 23 - Ouverture d'un graphe amplitude-temps ............................................ 23
Figure 24 - Fenêtre des propriétés du graphe ........................................................ 23
Figure 25 Propriétés pour la variable in_buffer .................................................... 24
Figure 26 - Graphique de la variable tableau in_buffer. ....................................... 24
Introduction de la carte eZdsp5515
Parmi la famille des processeurs spécialisés, une nouvelle branche est apparue
vers 1982 avec pour principale fonction de traiter numériquement et rapidement les
signaux issus de la parole. Le premier processeur ou calculateur spécialisé en traitement
du signal (TS ou SP pour Signal Processing), le "DSP" (Digital Signal Processor), était né
et depuis, cette famille n'a cessé de s'agrandir. Les processeurs DSP diffèrent des
microprocesseurs par le fait qu'ils ont été conçus spécialement pour effectuer de manière
très rapide, car étant câblé, les opérations de somme et de produit (unités MAC) qui sont
présentes dans tout algorithme de traitement du signal, en particulier dans la conception
des filtres FIR. Sur un DSP on peut, en un cycle, effectuer une multiplication et une
accumulation contrairement à un microcontrôleur qui fera la même chose en 30 ou 40
cycles horloges. Si au début ils effectuaient 5 millions d'instructions par seconde (MIPS)
sur des entiers de 16 bits pour un prix de 600$, ils peuvent aujourd'hui, en version
standard, effectuer plusieurs GFLOPS (Giga FLoating Operation Per Second) sur des
entiers ou des flottants de 32 bits pour un prix inférieur à 40$ (on parle ici du processeur
et non d'une carte de développement). Le DSP que nous retrouvons sur la carte SDK est
cadencé à 120 MHz, pour un cycle d’exécution de 8.33 ns, à un taux de calcul de 240
MIPS (millions d’instructions par seconde), peut effectuer jusqu’à 2 instructions par
cycle d’horloge, i.e, à toute les 8.33 ns.
La famille de processeur la plus répandue actuellement est sans conteste celle des
DSP de Texas Instruments qui détient environ 70 % du marché, les 30 % restant étant
partagés entre Motorola, Analog Devices, Lucent Technologies, Nec et Oki.
L'avantage des DSP tient :
 A leur faible prix par rapport aux circuits analogiques réalisant la même
fonction. On retrouve maintenant à 125.00$ un kit contenant un
microcontrôleur cadencé à 100 Mhz associé à une unité MAC de 16x16 bits
d’une capacité de 100 MIPS (c8051f12x)
 A leur facilité d'intégration sur des cartes numériques
 A leur possibilité de résoudre par la programmation toutes sortes de
problèmes linéaires ou non linéaires
 A leur robustesse, car ils sont insensibles aux variations de température, aux
dérives et au vieillissement.
 A leur flexibilité et leur souplesse de modification, car il suffit de changer le
programme sans modifications matérielles. Par exemple, si nous voulons
passer d'un décodeur jpeg à jpeg2000, nous changeons uniquement le
programme contrairement à un système analogique où nous aurions à
modifier le schéma électronique de la plaquette de montage.
On retrouve aujourd’hui une nouvelle avenue, soit la programmation d’un module
FPGA à partir des algorithmes de traitement de signal. Ce n’est applicable que pour des
projets demandant un échantillonnage dans les fréquences du Gigahertz et plus et un
traitement des données d’autant plus rapide mais difficile à implanter avec les outils
actuels. La voie DSP est encore moins onéreuse pour le moment mais cette voie sera
remplacée dans un proche avenir par des modules DSP câblés en FPGA avec SOC
(System On Chip) doté d’un processeur arm de type cortex M4F.
Les principales applications du DSP se retrouvent dans :
 Les télécommunications: téléphone filaire et cellulaire, modem, fax,
transcodeurs, interpolateurs, répondeurs, routeurs, codec …;
 Le traitement de la parole: reconnaissance, compression, synthèse;
 La commande de procédés: asservissement, contrôle flou, diagnostique
automatique, industrie automobile (ABS, antiroulis…);
 L'instrumentation: analyse spectrale, oscilloscope, générateur de signaux
…;
 Le traitement d'image: Image par Résonance Magnétique, image
ultrasonore, image radar, reconnaissance faciale, compression et
décompression, cryptage et décryptage, transmission, animation ...;
Les difficultés qui attendent les utilisateurs de ces processeurs sont au nombre de
trois : la première est liée à la structure du processeur DSP qui, tout en étant proche de
celle du microprocesseur, est fortement spécialisée pour les algorithmes de traitement du
signal; la deuxième difficulté, et ce n'est pas la moindre, concerne les techniques du
traitement numérique du signal laquelle nécessite la maîtrise d'outils mathématiques
adaptés; finalement, la dernière difficulté se rapporte à l'implémentation de l'algorithme
ou à la manière de programmer le DSP de manière à utiliser au mieux les ressources de
son architecture.
On parle de plus en plus souvent d'adéquation algorithme-architecture qui suppose
une relation très étroite dans le développement du logiciel et du matériel. Ces processeurs
sont programmés principalement en langage C (via un compilateur croisé ou « crosscompiler ») avec une phase d'optimisation si nécessaire en assembleur. On rappellera
qu'un compilateur croisé permet de concevoir un programme pour un autre processeur
dans un environnement autre que le dit processeur. Par exemple, on développe du code C
pour le processeur 8051 avec un logiciel qui fonctionne dans l'environnement Windows
(processeur Intel x86). Parallèlement aux DSP à usage général ou à spectre large, les
constructeurs commercialisent aussi des DSP réservés à des secteurs d'activités ciblés.
Ainsi, ces DSP sont optimisés pour un type d'application de par leur parfaite adéquation
entre leur architecture et l'algorithme utilisé. Par exemple, les séries DSP568xxx de
Motorola et TMS320C54x de Texas Instrument ont été développées spécifiquement pour
l'exécution rapide des algorithmes exploités dans les téléphones sans fil demandant des
taux d’échantillonnage de plusieurs GHz. C'est le cas également pour la famille de
processeur TMS320F/C240 de Texas Instruments qui est spécialisée dans le domaine de
la commande industrielle, en particulier pour le contrôle de la conversion d'énergie et la
commande de moteur électrique (commande vectorielle directe ou indirecte).
1. Architecture générale du starter kit eZdsp5515
1.1 - Le circuit de traitement du signal
Le TMS320C5515 est un processeur DSP 16 bits à virgule fixe principalement
dédié au traitement audio et quelques fois vidéo. C'est ce processeur que l'on retrouve sur
la carte ezDSP5515. Celui-ci a un temps de cycle de 8.33 ns (120 MHz). A titre
d'exemple, on donne la cadence maximale pour quelques applications classiques sur une
carte DSP TMS320C6713 cadencée à 225 MHz:
 - filtre numérique FIR avec 32 coefficients (~ 240 ns /ech)
 - filtre numérique IIR d’ordre 4 (~ 32 ns/ech)
 - FFT mémoire à mémoire sur 1024 points (~ 48 μs)
Dans la carte eZdsp5515, on retrouve une FFT câblée dont le temps d’exécution
est de 12 us pour une FFT à 1024 points, soit 4 fois plus rapide que la FFT programmée
sur TMS320C6713, il est évident que la fréquence de l'horloge du processeur n'est pas en
cause dans cette rapidité, qui est beaucoup plus une question d'architecture matérielle.
Lorsque vous sortez la carte de sa boite, celle-ci se présente comme sur la figure
1. Cette carte dispose d’un connecteur USB (USB emulation connector) que vous
branchez à l’ordinateur. La carte dispose également de 2 entrées (line in et mic in)
configurées sur la même entrée ainsi que 2 sorties (line out et hp out) également
configurées sur la même sortie.
Les entrées et sorties de la carte eZdsp5515 sont
présentées à la figure 1 et 2 tandis que l’on retrouve l’identification des connecteurs à la
figure 3. La figure 4 présente le bloc diagramme de la carte eZdsp5515. Vous trouverez
toutes les caractéristiques de cette carte dans le dossier "Documentation carte
eZdsp5515/Doc TMS320C5515 du cours de traitement des signaux II sur le site Moodle.
Figure 1 - Carte eZdsp5515 (Courtoisie de Texas Instrument)
Figure 2 Endos de la carte eZdsp5515 (Courtoisie de Texas Instrument)
Figure 3 Identification des connecteurs (Courtoisie de Texas Instrument)
Le DSP est implémenté sur une carte Starter Kit de Texas Instrument munis des
éléments suivants :
 Un processeur DSP 120 MHz TMS320C5515,
 Un convertisseur audio bidirectionnel 24 bits de haute qualité: « CODEC
AIC3204 »
 4 MB (32Mb) de mémoire NOR flash synchrone (pour le programme),
 K de mémoire DARAM (pour le programme en mode debugger
CCS),
 --128K de mémoire ROM (routine FFT, filtre FIR, filtre IIR
 Un contrôleur de bus JTAG pour l’émulation avec interface USB,
 Une interface USB pour communication externes
 --Interface MMC (Multimedia Card/SSD)
 Une alimentation externe de 5V.
La figure 4 présente le diagramme par blocs des différents modules composant la
carte DSK. On retrouve le codec AIC3204 (dont la fréquence d’échantillonnage varie de
8 kHz à 192 kHz), l’alimentation ainsi que les mémoires correspondantes.
Figure 4 Bloc diagramme de la carte eZdsp5515 (Courtoisie de Texas Instrument)
Figure 5 Configuration du DSP (mémoires, interfaces, registres...) (Courtoisie de
Texas Instrument)
1.2 - Types de fichiers utilisés durant les sessions avec CCS
On présente dans cette sous-section les types de fichiers avec extension que vous
serez amené à utiliser lors de la session. En voici une brève description :
1. nomfichier.pjt: Pour créer et construire un projet nommé nomfichier,
2. nomfichier.c: Code source en langage C
3. nomfichier.asm: Code source en assembleur crée par l’usager ou par le
compilateur C ou par l’optimiseur linéaire,
4. nomfichier.sa : code source en assembleur linéaire. L’optimiseur linéaire
utilise nomfichier.sa comme entrée pour produire le code assembleur
optimisé nomfichier.asm,
5. nomfichier.h : Fichier entête pour inclusion dans un code source
nomfichier.c,
6. nomfichier.lib : Fichier de librairie contenant des sous-programmes
compilés, par exemple rts5515.lib,
7. nomfichier.cmd : fichier de commande de l’éditeur de liens qui configure
les sections mémoires contenant votre code assembleur, vos données...
8. nomfichier.obj : fichier objet créé par l’assembleur,
9. nomfichier.out : fichier exécutable créé par l’éditeur de liens qui doit être
chargé dans la carte eZdsp5515 et qui sera exécuté par le processeur
TMS320C5515,
10. nomfichier.cdb : fichier de configuration lorsqu’on utilise le DSP/BIOS.
11. nomfichier.gel: fichier de type GEL qui permet d'ajouter une interface
graphique pouvant contrôler le contenu des variables du projet en temps
réel.
1.3 - Résumé des procédures de branchements
Déballer le contenu de la boîte contenant la carte SDK ainsi que tous ses
accessoires. Le kit est alimenté via le connecteur USB. Il vous faudra peut-être une
extension USB pour brancher votre carte sur un des ordinateurs du laboratoire. Le kit se
raccorde au PC par l’intermédiaire du câble USB qui est branché sur la carte via le
connecteur "USB Emulation Connector" (fig 1). Nous éviterons, dans la mesure du
possible, de brancher et débrancher inutilement ce câble car lors d’expériences
antérieures, il a été remarqué une perte de branchement de la liaison USB avec
l’ordinateur, dû possiblement à une interférence avec d’autres logiciels ouverts en même
temps que CCS. Pour remédier à ce problème, il suffit d’enregistrer votre code source, de
fermer CCS, de débrancher et rebrancher le câble USB de l’ordinateur et ensuite de
redémarrer le logiciel CCS. Vous devez refaire toutes les étapes ci-dessous pour vous
rebrancher à CCS.
Un résumé de la procédure de mise en opération du kit est donné ci-dessous sous
la forme d'étapes. On suppose que le logiciel CCS a été installé avec les pilotes et les
librairies adéquates.
1. Brancher la carte ezDSP5515 à votre ordinateur
2. Ouvrir le logiciel CCS
3. Lorsque CCS est ouvert, choisir le menu Windows/Reset perspective
4. Cliquez sur l'onglet CCS Edit.
5. Dans la fenêtre Target configuration, vous cliquez sur le bouton droit de la souris et
vous choisissez New Target Configuration.
6. Une fenêtre s'ouvre et vous tapez ezDSP5515 en conservant l’extension de fichier
.ccxml. Vous cliquez ensuite sur Finish. Sauvegardez le fichier dans le dossier
projet_ezdsp5515 sur le disque s:. Ne vous servez du disque z: uniquement comme
sauvegarde du dossier projet_ezdsp5515 à la fin de la session de laboratoire.
7. Une fenêtre apparaitra et dans la liste combo Connection, choisir "Texas Instrument
XDS100V2 USB debug probe" et cocher le processeur TMS320C5515 dans Board
and Devices. Cliquez sur Save et ensuite sur Test Connection. Une fenêtre apparait
indiquant si oui ou non la carte est reconnue.
8. Dans la fenêtre Target Configuration, cliquez sur ezDSP5515.ccxml avec le bouton
droit de la souris et choisir Launch Target Configuration. Cliquez ensuite sur l'item de
menu Run suivi de Connect. La carte cible est branchée à CCS.
9. Ouverture d’un projet CCS existant. Pour ouvrir un projet existant, vous allez dans
l’onglet « Project » et cliquez sur l’item de menu « Open ». Vous pouvez aussi
importer un projet ccs en choisissant l'item de menu Import du menu File.
10. Dans le navigateur de projet, on peut également choisir d’insérer un ou plusieurs
fichiers sources (écrit en langage C), de librairies ainsi que d’autres fichiers
nécessaires au bon fonctionnement de votre projet.
11. Une fois complétée la programmation, compilez le programme via le menu Project>rebuild All.
12. lorsque compilé, si vous effectuez des changements dans le fichier source, vous
n’aurez qu’à choisir l’item Project > build et seul le fichier source sera compilé (build
est un compilateur incrémentiel).
13. Vous devez ensuite « charger » le programme codé en machine dans le processeur
(DSP). Pour ce faire, vous cliquez sur le menu Run->Load program. Une fenêtre
s’ouvrira pour vous demander un fichier avec extension .out qui se trouve dans le
dossier Debug de votre projet.
14. Vous exécutez ensuite le programme via le menu >run de l’onglet Debug.
Voici les étapes en images.
Étape 3:
Figure 6- Reconfiguration des fenêtres dans le mode standard
Étape 4:
Figure 7 - Définition de la configuration de la carte eZdsp5515.
Étape 5:
Figure 8 -Création d'un fichier de configuration de la carte eZdsp5515
Étape 6:
Figure 9 - Renommer le fichier par défaut par un autre nom
Étape 7:
Figure 10 - Choix du debug probe et du processeur
Étape 7: Test Connection
Figure 11 - Test d'intégrité du branchement JTAG
Étape 8:
Figure 12 - Launch target configuration (démarrage de la connection)
Étape 8:
Figure 13 - Connection de la carte de développement
2. Expérimentation
2.1 - Validation de la carte eZdsp5515
Avant de débuter cette partie, vous devez avoir lu la partie intitulée Résumé des
procédures de branchements et programmation de la carte eZdsp5515. Pour valider
le bon fonctionnement de la carte de développement, vous démarrez un projet existant. Si
ce n'est déjà fait, vous allez copier le fichier Projet_eZdsp5515.zip et décompresser celuici sur le volume s: de l'ordinateur du laboratoire ou sur le volume c :. Ce volume
représentera votre espace de travail tout au long de la session. Toujours sauvegarder ce
dossier à la fin de la session de laboratoire pour le cas où ce dossier serait effacé par
erreur. Vous allez ouvrir CCS et charger ensuite un programme existant en utilisant la
commande de menu File >Import... Dans la fenêtre de dialogue, choisir C/C++->ccs
project, une fenêtre apparait et vous cliquez sur le bouton Browse et allez vers le dossier
s:\Projet_ezdsp5515\tests\uled et ensuite vous cliquez sur Finish. Vous pouvez également
charger un projet existant en cliquant sur le bouton droit de la souris sur la fenêtre Project
Explorer. Pour avoir cette fenêtre, allez au menu View->Project Explorer. Dans le menu
contextuel de Project Explorer, vous choisissez Import->CCS Project et vous suivez les
mêmes étapes qu'avec le menu File->Import.
Le projet uled allume les quatre leds de votre carte selon un ordre précis à une
cadence spécifiée. Vous devez modifier une valeur dans le fichier source uled_test.c et
ensuite recompiler le projet en cliquant sur le menu Projet->Build All. On montre dans
les pages suivantes les étapes qu'il faut faire avant que le programme soit copié sur la
carte de développement.
Figure 14 - Importation d'un projet CCS
Figure 15 - Sélection du projet dans le dossier Projet_ezdsp5515\tests
ÉTAPES DE VALIDATION DE LA CARTE E ZDSP5515 AVEC CCS
1. Vous allez dans la fenêtre d'exploration des projets (project explorer) en
cliquant dans le menu View->Project explorer. Vous allez ouvrir les fichiers main.c et
uled_test.c. Dans le fichier uled_test.c, vous allez modifier le chiffre 50000 pour 5000.
Vous sauvegardez le tout et vous cliquez sur le menu Project->Build All (fig.18). Vous
pouvez cocher l'item de menu Project->Build Automatically. Cette option permet de
recompiler le programme lors d'un changement quelconque. N'oubliez pas de
sauvegarder tout le projet. La figure 16 montre la modification effectuée dans le fichier
uled_test.c.
Figure 16 - Modification dans le fichier uled_test.c
Après compilation et liaisons en cliquant sur Build All, vous devriez voir la
fenêtre console avec production d'un fichier avec extension .out (fig.17).
Figure 17 - Console donnant le résultat de la compilation et de la liaison (linkage)
Figure 18 - Menu Project->Build All
Pous charger le fichier uled.out sur la carte de développement, vous sélectionnez
le menu Run->Load->Load Program et vous cliquez sur le bouton Browse Project. Vous
cliquez sur le project en cours et allez dans le dossier debug où se trouve le fichier .out.
Ce fichier est un fichier binaire englobant les instructions machines qui seront exécuté
par le processeur de la carte de développement. Après avoir testé la carte avec succès,
vous êtes maintenant en mesure de faire les parties suivantes de votre expérience de
laboratoire sur l'apprentissage de CCS.
Figure 19 - Chargement du programme binaire dans la carte eZdsp5515
Figure 20 - Fenêtre vous demandant le chemin du fichier à extension .out
2.2 - Partie a) Breakpoint et exécution pas-à-pas
Dans cette partie, vous allez ajouter un projet qui se nomme sinus1500 et qui se
trouve dans le dossier projet_ezdsp5515. Ce programme génère une onde sinusoïdale de
48 échantillons qui se répète sur une courte période. Les données sont transmises à la
sortie de la carte DSP que vous pourrez entendre avec un casque d'écoute. Le tone
provient d'une table en mémoire formé des données d'une sinusoïde de 48 échantillons.
1- Vous allez ajouter un "breakpoint" à la ligne 47 en double cliquant sur la
bordure bleu près du nombre 47 tel qu'indiqué sur la figure 21. Vous devriez voir
apparaitre un symbole circulaire avec un petit crochet sur le bas du symbole. L'utilité du
breakpoint est de pouvoir exécuter le programme ligne par ligne au lieu d'une exécution
du programme selon l'horloge du processeur. Cela nous donne un contrôle total sur les
valeurs que prennent les variables, ce qui aidera à déverminer le programme au cas où
des erreurs pourraient se produire. La touche F5 permet d'exécuter le programme en
mode "step by step". Lors du démarrage du programme, le compteur de programme
s'arrêtera à la ligne qui contiendra un breakpoint. À ce point, vous appuyez sur la touche
F5 qui fera repartir le programme ligne par ligne.
2- Vous allez ouvrir la fenêtre du désassembleur en cliquant sur le menu view>Disassembly. Lorsque vous tapez la touche F5, les lignes du code source apparaissent et
les lignes du programme compilé apparaissent au côté de la fenêtre source.
Figure 21 - Insertion d'un breakpoint
Figure 22 - Fenêtre du désassembleur au côté de la fenêtre du programme en C
3- Après avoir parcouru les 48 échantillons en pressant sur la touche F5,
expliquez en détail l'algorithme de ce programme.
2.3 - Partie b) Les entrées-sorties sous forme graphique
1- Vous pouvez visualiser les données en entrées et en sortie en utilisant un
graphique des échantillons. Vous sélectionnez le menu Tools->Graph->Single Time. Une
fenêtre de propriétés apparaitra afin de modifier la valeur de certaines propriétés. Insérez
les valeurs suivantes apparaissant à la figure 25 avant de mettre en marche la simulation.
Figure 23 - Ouverture d'un graphe amplitude-temps
Figure 24 - Fenêtre des propriétés du graphe
Figure 25 Propriétés pour la variable in_buffer
Vous devriez obtenir le graphique de la figure 26.
Figure 26 - Graphique de la variable tableau in_buffer.
2- Vous allez modifier la propriété Start Address pour remplacer in_buffer par
out_buffer. Visualiser le graphique en exécutant le programme ligne par ligne avec la
touche F5. Expliquez pourquoi on obtient ce graphique et faire les corrections nécessaires
au programme pour obtenir une sortie graphique ressemblant à celle de la variable
in_buffer mais avec un gain maximal de 0x20.