1

Université du Québec à Montréal MIC4220 Département d’Informatique Traitement numérique du signal

Laboratoire 1a : Utilisation d’une carte DSP

BUT Apprendre à utiliser Code Composer Studio (CCS) et la carte DSK de Texas Instrument ; se familiariser avec le développement un système DSP et l’exécution d’opérations de filtrage. INTRODUCTION Code Composer Studio (CCS) fournit plusieurs outils pour faciliter la construction et la mise au point des programmes de DSP. Il comprend un éditeur de code source, un compilateur de langage c/c++, un assembleur de code relocalisable, un éditeur de liens, et un environnement d’exécution qui permet de télécharger un programme exécutable sur une carte cible, de l’exécuter et de le déboguer au besoin. CCS comprend aussi des outils qui permettent l’analyse en temps réel d’un programme en cours d’exécution et des résultats produits. Finalement, il fournit un environnement de gestion de fichiers qui facilite la construction et la mise au point des programmes.

EXEMPLE D’UTILISATION L’exemple qui suit montre comment un algorithme multifilaire simple peut être compilé, assemblé et lié en utilisant CCS. D'abord, plusieurs valeurs de données sont écrites en mémoire. Ensuite un pointeur est assigné au début des données de sorte qu'elles puissent être traitées comme elles sont présentées. Finalement des fonctions simples sont ajoutées en C et en assembleur pour illustrer la façon dont celles-ci sont exécutées.

I. Créer un projet Le processus de développement de code de CCS commence par la création d'un fichier projet (extension .pjt) qui facilite l’intégration des fichiers requis pour produire un fichier exécutable. Le fichier projet contient des références aux fichiers source (.c, .asm, .sa), aux fichiers d’en-tête (.h), au fichier de commande pour l’éditeur de liens (.cmd), et aux fichiers de bibliothèque (.lib). Le fichier-projet permet aussi de spécifier les paramètres du compilateur, de l'assembleur et de l'éditeur de liens afin de produire le fichier exécutable.

2

Pour créer un projet, vous choisissez l'élément de menu « ProjectNew » de la barre d’outils du CCS. Cela fait apparaître la fenêtre de dialogue « Save New Project As » comme illustré ci-dessous.

Dans celle-ci, vous introduisez un nom de projet dans le champ « File name » (lab1, par exemple), après vous être assuré(e) d’être dans le répertoire désiré, identifié dans le champ « Save in ». Ensuite, vous cliquez sur « Save » pour que CCS crée un fichier-projet nommé lab1.pjt. Les fichiers nécessaires pour établir une application devront être ajoutés au projet par la suite.

II. Créer un fichier source CCS fournit un éditeur intégré qui permet la création des fichiers sources. Une fenêtre d'éditeur apparaît vers le haut en choisissant l'élément de menu « File NewSource » Pour notre exemple, écrivons le code suivant dans cette fenêtre d'éditeur :

.sect ``.mydata`` .short 0 .short 7 .short 10 .short 7 .short 0 .short -7 .short -10 .short -7 .short 0 .short 7

3

Ce code déclare 10 valeurs numériques en utilisant la directive .short. La directive .sect spécifie que les 10 valeurs doivent résider dans une section de la mémoire du DSP appelée .mydata ; les adresses physiques qui correspondent à cette section seront définies plus tard dans un fichier .cmd.

Vous sauvegardez le fichier source créé en choisissant l'élément de menu « FileSave » ce qui fait apparaître la fenêtre de dialogue « Save as »comme illustré ci-dessous. Dans cette fenêtre allez à la zone « Save as type » et choisissez « Assembly Source Files (*.asm) » à partir de la liste déroulante. Ensuite, allez à la zone « Filename » et écrivez le nom du programme : initmem.asm pour l’exemple. Finalement, en cliquant sur « Save », le code est sauvegardé dans le fichier source assembleur spécifié.

III. Créer un fichier de commande pour l’éditeur de liens

En plus des fichiers sources, un fichier de commande d'éditeur de liens doit être indiqué pour créer un fichier exécutable et pour se conformer aux spécifications de mémoire du DSP et de la cible sur laquelle le fichier exécutable va être compilé. Un fichier de commande d'éditeur de liens peut être créé en utilisant la même procédure que pour le

4

fichier précédant (en choisissant « FileNewSource »). Pour l’exemple en cours, nous allons considérer le fichier de commande suivant : MEMORY { VECS: org = 0h, len = 0x220 IRAM: org = 0x00000220, len = 0x0000FDC0 /*internal memory*/ SDRAM: org = 0x80000000, len = 0x00010000 /*external memory*/ MYDATA: org = 0x80010000, len = 0x00100000 /*external memory*/ FLASH: org = 0x90000000, len = 0x00020000 /*flash memory*/ } SECTIONS { vectors :> VECS .text :> IRAM .bss :> IRAM .cinit :> IRAM .stack :> IRAM .sysmem :> SDRAM .const :> IRAM .switch :> IRAM .far :> SDRAM .cio :> SDRAM .mydata :> MYDATA } Puisque notre intention est de placer les valeurs définies dans le fichier initmem.asm dans la mémoire, un espace qui ne sera pas recouvert par le compilateur devrait être choisi. Les espaces de donnés extérieures SDRAM ou MYDATA peuvent être utiliser à cette fin. Commençons par assembler les données à l'adresse de mémoire 0x08000000 (0x dénote l'hexadécimal), située au début de SDRAM. Pour faire ceci, assignez la section nommée .mydata à MYDATA en ajoutant «.mydata > MYDATA» dans la partie SECTIONS du fichier de commande, comme déjà indiqué dans le programme ci-haut. La fenêtre d'édition devrait être sauvegarder dans un fichier de commande d'éditeur de liens en choisissant « FileSave ». Ceci ouvre la fenêtre de dialogue « Save As ». Après cela allez à la zone « Save as type» et choisissez « TI Command Language Files (*.cmd) » à partir de la liste déroulante. Alors, écrivez « lab1.cmd » dans la zone « Filename » et cliquez sur Save.

5

IV. Ajout de nouveaux fichiers au projet Une fois que le fichier source initmem.asm et le fichier de commande d'éditeur de liens lab1.cmd sont créés, ils devraient être ajoutés au projet. Pour ce faire, choisissez l'élément de menu « ProjectAdd Files to Project » Cela évoque la fenêtre de dialogue « Add Files to Project ». Sélectionner les deux fichiers et cliquer sur « open ».

En plus des fichiers initmem.asm et lab1.cmd, le fichier objet d’une ou plusieurs bibliothèques de support devrait être ajouté au projet. Une bibliothèque de support contient des fonctions pré-assemblées qui permettent l’accomplissement de tâches diverses telles l’initialisation de la carte de DSP cible, la configuration des périphériques, la mise en oeuvre d’algorithmes de filtrage pré-définis, etc. Dans notre cas, nous voulons ajouter la librairie rts6701.lib au projet. Pour ce faire, choisissez « ProjectAdd Files to Project », allez à la chemise de bibliothèques du compilateur, et choisissez « Library Files (*.lib) », sélectionnez rts6701.lib et cliquez sur open.

V. La mise au point du projet Pour la mise au point, utilisons un programme interpréteur de commandes

interactif vide. Créez un fichier source en c qu’on appellera main.c, écrivez les lignes suivantes et ajoutez main.c au projet de la même manière que juste décrit. Main.c : #include <stdio.h> void main( ) { printf ( ``BEGIN\n``); printf ( ``END\n``); } Après avoir ajouté tous les fichiers sources, fichier de commande et fichier de bibliothèque au projet, vous pouvez construire le projet et créer un fichier exécutable pour le DSP-cible. Pour faire cela, choisissez l'élément de menu «ProjectBuild». Cette fonction permet au CCS de compiler, assembler, et joindre tous les fichiers dans le projet.

Si le processus de construction est complété sans erreur, le fichier exécutable lab1.out est produit. Il est également possible de compléter les constructions par incréments; c'est-à-dire en recompilant ou en assemblant seulement des fichiers changés depuis la dernière construction, en choisissant l'élément de menu « ProjectRebuild ».

6

Bien que CCS fournisse des options par défaut, ces options peuvent être changées en choisissant « Projectoptions ». Par exemple, pour changer le nom du fichier exécutable en test.out, choisissez « ProjectOptions », et cliquer sur « linker tab » parmi les options de construction ; taper alors test.out dans la zone «Output Filename ». Notez que le fichier de commande d'éditeur de liens inclura test.out qand vous cliquerez sur cette fenêtre. La figure ci-dessous illustre cette étape.

VI. Le niveau d’optimisation

Il faut accorder une attention particulière aux options de niveau d'optimisation. Il existe quatre niveaux d'optimisation, qui contrôlent le type et le degré d'optimisation. L'option d'optimisation du niveau 0 exécute le « control-flow-graph », commande et assigne des variables aux registres, élimine le code inutilisé, et simplifie les expressions. L'optimisation du niveau 1 exécute toutes les optimisations du niveau 0, retire l'assignement inutilisé et élimine les expressions communes locales. L'optimisation du niveau 2 exécute toutes les optimisations du niveau 1, plus la canalisation de logiciel, et

7

les optimisations de boucle. Elle élimine aussi les sous-expressions communes et les assignements inutilisés. L'optimisation du niveau 3 exécute toutes les optimisations du niveau 2, retire toutes les fonctions que le programme n’utilise pas, et simplifie les fonctions dont les valeurs de retour ne sont jamais utilisées.

Notez que dans certains cas, la simulation n'est pas possible à cause de l'optimisation. Donc il est recommandé de s’assurer que votre programme est bien mis au point pour s'assurer qu'il est logiquement correct avant d'exécuter n'importe quelle optimisation. VII. Le suivi de l’exécution

Une fois que le processus de construction est complété sans aucune erreur, le

programme peut être chargé et exécuté sur la cible du DSP. Pour charger le programme choisissez « FileLoad Program», et selectionnez le fichier lab1.out, et cliquez sur ouvrir. Pour exécuter le programme, choisissez l'élément « DebugRun » du menu. Vous devriez voir ``BEGIN`` et ``END `` apparaître dans le ``Stdout window`` ( La fenêtre en bas de l’écran ).

Maintenant, allons vérifier si l’ensemble des valeurs est assemblé dans l'emplacement de mémoire indiqué. CCS permet de visualiser le contenu de la mémoire à un emplacement spécifique. Pour visualiser le contenu de la mémoire à l’adresse 0x80010000, choisissez « ViewMemory » à partir du menu. La fenêtre de dialogue "Memory Window options " apparaîtra. Cette fenêtre de dialogue permet de spécifier divers attributs de la fenêtre « memory Window ». Allez à la zone « Adresse » et écrivez 0x80010000. Sélectionnez alors, « 16bit Signed Int » de la liste déroulante dans « Format field » comme illustré ci-dessous et cliquez ok.

8

Le contenu de l'unité centrale de traitement, du périphérique, de l'accès direct à l mémoire, et de la porte série peuvent aussi être visualisées en sélectionnant « ViewCPU», par exemple. VIII. Le chargement de données de/vers un PC

Il y a une autre façon de charger des données à partir d'un fichier du PC à la mémoire du DSP. CCS fournit une capacité de point de sonde (PROBE POINT CAPABILITY), de sorte qu'un ensemble de données puisse être déplacé à partir du fichier du PC au DSP ou vice versa. Afin d'utiliser cette capacité, un point de sonde (PROBE POINT) devrait être placé dans le programme en plaçant le curseur à la ligne où un ensemble de données doit être transféré et cliquer sur le bouton « Toggle Probe Point ». Puis, choisissez « FileFile I/O » pour appeler la fenêtre de dialogue « File I/O ». Ensuite cliquer sur le bouton « Add File » et choisissez le fichier de données à charger. Maintenant le fichier devrait être relié au point de sonde en cliquant le bouton «Add Probe Point ». À partir du tabulateur de point de sonde, choisissez le point de sonde qui devrait être reliés au fichier du PC par «File In : … ». Cliquez sur le bouton « Replace » et puis le bouton ok. Finalement, écrivez l'emplacement de mémoire dans « Address field » et le nombre de données dans «Lenght field ». Notez que, un nom variable peut être utilisé dans «Address field ».

IX. L’outil d’affichage graphique

Un affichage graphique des données fournit souvent un meilleur feedback au sujet du comportement d'un programme. CCS fournit une interface d'analyse de signal pour surveiller un signal ou ses données. Commençons par afficher le choix de valeurs à l’adresse 0x80010000 comme un signal ou un graphique de temps. Pour ce faire, choisissez « ViewGraphTime/Frequency » pour visualiser la fenêtre de propriété du graphique. Allez au «Start Address field », cliquez y, puis tapez 0x80010000. Ensuite allez à «Acquisition Buffer Size field », cliquez y et écrivez " 10``. Finalement, cliquez sur «DSP Data Type», choisissez «16-bit Signed Integer» à partir de la liste déroulante, et cliquez sur ok. Alors, une fenêtre du graphique apparaîtra avec les propriétés choisies comme illustré ci-dessous.

9

Vous pouvez changer n'importe lequel de ces paramètres à partir de la fenêtre

graphique en cliquant sur le bouton à droite de la souris, ensuite choisissez «Properties», et ajustez les propriétés comme voulu. Notez que les propriétés peuvent être mises à jour à tout moment pendant le procédé de mise au point.

X. L’usage d’un pointeur pour accéder aux données

Pour assigner un pointeur au début de l'espace mémoire assemblé, l'adresse de la

mémoire peut être saisie directement par ce pointeur. Le code suivant peut être employé pour assigner un pointeur au début des valeurs et parcourir celles-ci pour imprimer chacune d’elles sur le Stdout window :

#include <stdio.h> void main( ) { int i; short *point; point = (short *) 0x80010000; printf ( ``BEGIN\n``); for (i = 0; i < 10; i++) { printf (``[%d] %d\n``, i , point[i]); } printf ( ``END\n``); }

10

Au lieu de créer un nouveau fichier source, nous pouvons modifier le fichier main.c existant en double cliquant sur le fichier main.c dans le panneau de configuration du projet. Cette action apportera vers le haut de l’écran le fichier source main.c, et alors vous pouvez le modifier à partir de cette fenêtre et reconstruisez-le après. Avant d'exécuter le fichier exécutable, assurez-vous d’avoir rechargez le fichier lab1.out. En exécutant ce fichier, vous devriez pouvoir voir les valeurs dans le Stdout Window.

XI. Les points d’arrêt

Durant le développement ou le test des programmes, en doit souvent contrôler la valeur d'une variable pendant l'exécution du programme. Ceci peut être réalisé en utilisant des points d'arrêt (BREAKPOINT) et des ``Watch Windows``. Pour visualiser les valeurs du pointeur dans main.c avant et après l'assignement de celui-ci, choisissez «FileReload Program » pour recharger le programme. Puis, double cliquez sur main.c dans le panneau de configuration du projet. Ensuite, mettez votre curseur sur la ligne qui indique «point = (short *) 0x80010000 » et cliquez sur F9 pour placer un point d'arrêt. Ensuite, pour ouvrir un « Watch Window », choisissez «ViewWatch Window» à partir de la barre de menu. Pour ajouter une nouvelle expression dans cette fenêtre, appuyez sur le bouton droit de la souris par-dessus cette fenêtre et sélectionnez « Insert New Expression ». Dans le domaine d'expression, tapez « point » (ou toute expression que vous voulez examiner) et cliquez sur ok. Ensuite choisissez « DebugRun ». le programme s'arrête au point d'arrêt et la valeur du pointeur apparaît sur le « Watch Window ». Ceci est la valeur avant que le pointeur ne soit placé à 0x80010000. En appuyant sur F10, vous faite un pas au-dessus de la ligne, vous devriez pouvoir voir la valeur 0x80010000 dans le «Watch Window ». XII. Les fonctions

Pour ajouter une simple fonction en C qui fait la somme des valeurs, nous pouvons simplement passer le pointeur par l'alignement de valeur et avoir un retour de nombre entier. Pour l'instant, considérant que nous n'utilisons pas l'assembleur, ce qui nous concerne n'est pas comment les variables sont additionnes, mais plutôt combien de temps prend –t- il pour exécuter l'opération. la fonction simple suivante peut être employée pour additionner les valeurs et pour renvoyer le résultat :

11

#include <stdio.h> void main( ) { int i , ret;

short *point; point = (short *) 0x80010000; printf ( ``BEGIN\n``); for (i = 0; i < 10; i++) printf (``[%d] %d\n``, i , point[i]);

ret = ret_sum (point , 10); printf (``Sum = %d\n% , ret );

printf ( ``END\n``); } int ret_sum (const short* array , int N) { int count , sum ;

sum = 0; for (count = 0 ; count < N ; count++ ) sum += array [count]; return (sum); } XIII. La mesure de performance (Évaluation du temps d’exécution)

En tant qu'élément du procédé de mise au point, il est normalement nécessaire de chronométrer L'application du programme. Dans cet exemple, nous allons déterminer combien de temps prend la fonction ret_sum pour s’exécuter.

Alors, rechargez le programme et choisissez « ProfilerEnable Clock to count instructions cycles ». Puis, double cliquez sur le fichier main.c dans le panneau de configuration du projet et choisissez «ViewMixed Source/ASM» pour énumérer les instructions assembleurs après chaque ligne de programmation C. Un point de profil est placé à la ligne appelée en plaçant le curseur sur la ligne «ret = ret_sum (point , 10)», puis cliquez sur le bouton droit et choisissez «Toggle Profile Pt » à partir du menu. Un autre point de profil devrait être placé à la prochaine ligne comme montré sur la figure ci-dessous.

12

Une fois que les points de profil sont placés, choisissez «ProfilerView Statistics» pour apporter vers le haut la fenêtre qui affiche des statistiques au sujet du nombre de cycles d'instruction. Appuyez sur F5 pour exécuter le programme. Vous devriez obtenir environ 473 cycles (le nombre exact peut légèrement changer). Ceci est le nombre de cycles que la fonction ret_sum prend pour s’exécuter et avoir une valeur de retour.

13

TRAVAIL Programmation de base

1. Utiliser CCS pour écrire un programme qui multiplie deux vecteurs et affiche le résultat sur stdout.

2. Modifier le résultat de manière à ce que la fonction main et la fonction de multiplication résident dans des fichiers séparés.

3. Écrire un programme qui génère deux périodes d’un sinus à raison de 256 points par cycle et qui les emmagasine en mémoire ; utiliser l’utilitaire d’affichage graphique pour vérifier que le signal emmagasiné est bon. Reprendre l’affichage graphique en utilisant l’option Transformée de Fourier ; faire varier la taille du tampon et expliquer la courbe obtenue dans chaque cas.