TP de programmation DSP pour le traitement d`image IF4

TP de programmation DSP pour le traitement d'image
IF4-ARCH 2006-2007
1
Introduction .............................................................................................................................1
1.1
Objectifs ..........................................................................................................................1
1.2
Description de la plate-forme d'expérimentation IEK6711 .......................................2
1.3
Première séance : prise en main de code composer studio .........................................4
1.4
Préparation .....................................................................................................................4
2
Traitement d'images ................................................................................................................4
2.1
Chargement du projet....................................................................................................4
2.2
Compilation, exécution : ................................................................................................6
2.3
Traitement d'images ......................................................................................................6
2.3.1
Négatif :....................................................................................................................6
2.3.2
Seuillage : .................................................................................................................6
2.3.3
Convolutions ............................................................................................................6
2.4
Mesure des performances ..............................................................................................7
2.4.1
Outils de mesures .....................................................................................................8
2.4.2
Optimisation .............................................................................................................8
2.5
3
Comparaison avec des fonctions optimisées en assembleur .......................................8
Utilisations des DMAs .............................................................................................................8
1 Introduction
1.1 Objectifs
Le TP sur carte IEKC6x11 s'étend sur 3 séances de 2 heures, 3 heures et 3 heures. Vous aurez
l'occasion durant ces séances d'expérimenter :
•
•
•
l'utilisation d'une carte DSP pour le traitement d'image basée sur le processeur Texas
Instruments TMS320C6211 ou TMS320C6711,
d'implanter sur cette plate-forme différents algorithmes de traitement d'images,
de mesurer la durée d'exécution (profiling) et optimiser l'implantation,
IF4-ARCH /T. Grandpierre
1
•
d'étudier le contrôleur DMA du DSP C6211 afin d'effectuer des opérations mémoires
simples.
ATTENTION NE JAMAIS CONNECTER OU DÉCONNECTER L'ALIMENTATION OU LE CONNECTEUR
JTAG OU FAIRE UN RESET DE LA CARTE TANT QUE CODE COMPOSER EST LANCE :
IL Y A RISQUE DE DESTRUCTION DU DSP
AVANT CES MANIPULATIONS VOUS DEVEZ TOUJOURS VERIFIER DANS LE GESTIONNAIRE DE
PROGRAMME QUE CCS_APP.EXE N'EST PAS EN COURS D'EXECUTION
(le raccourcis KILL_CCS vous permet d'ouvrir un gestionnaire de programme)
1.2 Description de la plate-forme d'expérimentation IEK6711
La carte IEKC6711 peut être connectée à 4 sources vidéo analogiques en entrées et possède une
sortie vidéo analogique. Elle repose sur un DSP Texas Instruments TMS320C6711, un FPGA
50000 cellules et plusieurs bancs mémoires RAM (Cf. figure ci-dessous).
Cette carte peut fonctionner, selon la configuration du FPGA, soit en acquisition d'images, soit en
restitution (la votre sera dans cette configuration).
En mode acquisition (qui n'est donc pas le mode de votre carte) le signal d'une des 4 entrées
analogiques est convertit en un flot numérique par le convertisseur A/N correspondant. Ce flot est
ensuite stocké dans la RAM du FPGA par le FPGA. Une fois qu'une image entière est stockée
dans la RAM FPGA il faut la transférer dans celle du DSP pour qu'il puisse y faire des
traitements (filtrage, compression, etc). Pour cela le FPGA et le DSP sont connectés ensembles
par une mémoire RAM double ports (DPRAM) de 16Ko. Cette taille étant insuffisante pour
transférer une image entière en une fois ce sont des blocs de 8 lignes qui sont échangés. Côté
DSP, on utilise plutôt le DMA pour effectuer rapidement les copies des blocs de 8 lignes vers la
RAM du DSP sans gaspiller de puissance CPU.
En mode restitution, celui de votre carte, le processus est totalement symétrique : l'image à
afficher est supposée d'abord contenue dans la RAM du DSP ou sa RAM extérieure. Il s'agit donc
de la découper en blocs de 8 lignes pour la transférer dans la RAM du FPGA par le biais de la
petite DPRAM. Quand une image entière a été transférée, le FPGA la transmet à l'unique
convertisseur numérique-analogique qui est lui même connecté au moniteur vidéo.
Comme tous les processeurs récents, le DSP est équipé d'une interface JTAG qui permet, depuis
Code Composer Studio exécuté sur un PC, de contrôler très précisément le DSP : mis en place de
points d'arrêts, lecture-écriture des registres internes, accès en lecture-écriture à tous l'espace
mémoire. Cette dernière fonctionnalité sera d'ailleurs utilisée pour charger la mémoire du DSP
avec un programme et des données.
IF4-ARCH /T. Grandpierre
2
IF4-ARCH /T. Grandpierre
3
1.3 Première séance : prise en main de code composer studio
Il s'agit pour commencer de prendre en main l'outils de développement et d'explorer ses
capacités. Pour cela vous exécuterez la partie "Developing a Simple Program " du tutorial intégré
à code composer studio (menu "Help" "Tutorial" "Code Composer Studio IDE")
1.4 Préparation
Avant de commencer il faut récuperer le fichier compressé TP_I4_DSP_2006.zip que vous
trouverez sur http://www.esiee.fr/~grandpit/ pour le copier et le décompresser dans le répertoire
c:\temp de votre machine. Vous n'oublierez pas de nettoyer ce répertoire à la fin de chaque TP
après en avoir effectué une sauvegarde sur votre compte.
Note : il n'est pas possible à code composer d'accéder directement à votre compte c'est pourquoi
il faut toujours travailler sur le répertoire local temp.
Une fois décompresser vous obtiendrez les répertoires suivants :
•
•
•
•
•
•
2
Affiche_image : ce répertoire contient le projet "display" (faire menu "Project" "open")
vous donnant le programme de base permettant d'initialiser la carte et afficher une image
(voir description en §2),
Exemple_dma : ce répertoire contient le projet "dma-transfert" vous donnant un exemple
de base de programmation de l'EDMA à l'aide de la CSL (voir description en §3),
Exemple_dma_timer : idem précédent mais avec utilisation du timer pour chronométrage,
Test : ce répertoire contient des fichiers binaires déjà compilés (fichiers "afficheimage.out", "affiche-vidéo.out") afin de tester rapidement la carte quand vous avez un
doute sur son fonctionnement. Il suffit, après avoir correctement ré-initialisé la carte si
nécessaire, de charger (menu "File" "Load Program" ) puis exécuter ces programmes
(menu " Project" "run") en ayant préalablement connecté et allumé le téléviseur qui
doit être sur le mode A/V),
MaintenanceIEK67 : ne pas exécuter les programmes contenu dans ce répertoire. Ils
servent principalement à configurer le FPGA de la carte en mode acquisition ou
restitution,
docs : documents techniques sur la programmation du DSP C6x et de l'EDMA.
Traitement d'images
2.1 Chargement du projet
1. Lancer CCS. Pour s'exécuter CCS requière des privilèges spéciaux, il s'exécute
donc sous les droits d'un utilisateur différents : login=ccs, password=ccs
2. Si le logiciel ouvre la fenêtre suivante :
IF4-ARCH /T. Grandpierre
4
il faut alors sélectionner la cible "XDS510 emulator "
3. Charger le projet "display" se trouvant dans le répertoire
``c:/temp/affiche_image/display.pjt''
Ce projet contient les fichiers suivants :
définitions de fonctions
pour la communication
avec le FPGA
initialisation du tableau avec l'image
programme principal
configuration mémoire
Dans le cadre de ce TP nous nous intéresserons uniquement au fichier maindemo.c
Le cœur de ce module est la fonction C "main( )" dont le squelette est le suivant (ouvrir le source
du fichier maindemo.c à l'aide du navigateur dans la partie de gauche de Code Composer Studio)
:
../..
#define WIDTH 352
#define HEIGHT 280
IF4-ARCH /T. Grandpierre
5
const far unsigned char ImageRef[] = { #include "image.bmp.Y.txt"}; //init image
void main( void ) {
CSL_init(); //init de la librairie CSL utilisée pour faciliter la config. de l'EDMA
board_init(); // init la carte (déclaré dans init6211.c)
image_display(ImageRef); //envoie au FPGA le tableau donné en argument afin qu'il
}
// l'affiche sur la sortie vidéo/TV (déclaré dans Init6211.c)
Remarque : pour ce TP, nous n'utiliserons qu'une sous-partie des fonctionnalités de la carte
IEKC6211 : images CIF (352x288) en niveau de gris. La carte est toutefois capable de travailler
aussi en plein format vidéo (720x576) et en couleur (YUV422).
Le fichier ``image.bmp.Y.txt'' contient la séquence de tous les pixels qui forment l'image encodée
sous forme ASCII. Ce fichier est créé avec l'utilitaire de conversion rgbbmp_to-ytxt (dans le
même répertoire) qui prend en entrée sur la ligne de commande le nom d'un fichier BMP au
format RGB 24 bits et qui crée un fichier texte comportant la composante Y correspondante.
2.2 Compilation, exécution :
1. Recompiler le programme (menu "Project" "Rebuild all")
2. Avant chaque chargement il est conseillé de faire un "reset" logiciel de la carte : menu
"GEL" reset & clear breakpoint
3. Charger le programme : menu "File" "load program"
4. Exécuter le programme: menu "Debug" "run"
Il doit s'ensuivre l'affichage des messages (printf) suivants dans CCS :
• Load FPGA
• Load FPGA done
• Affichage de l'image
2.3 Traitement d'images
2.3.1 Négatif :
Les pixels sont représentés par des entiers codés sur un octet et donc compris entre 0 et 255. Il
s'agit d'écrire une fonction negatif( image_source, &image_destination ) qui "inverse" la valeur
des pixels de l'image_source de façon à avoir une image en négatif dans image_destination.
2.3.2 Seuillage :
Il s'agit d'écrire une fonction seuillage(seuil, & image_source, &image_destination) qui compare
chaque pixel à la valeur du seuil et qui remplace la valeur du pixel par 0 si sa valeur est inférieure
au seuil ou par 255 si supérieure ou égale. Les arguments image_source et image_destination
sont les adresses des images avant et après transformations.
2.3.3 Convolutions
Il s'agit d'implanter une convolution 3x3.
IF4-ARCH /T. Grandpierre
6
Rappel : la convolution d'une image source S de taille NxN avec une matrice MxM consiste à
calculer une nouvelle image D dont la valeur de chaque pixel Dij est une fonction de la valeur des
pixels voisins du pixel Sij.
Par exemple, si les coefficients de la matrice M sont (0,1,0) (1,0,1) (0,1,0), pour chaque pixel on
effectuera le traitement suivant :
Il faut penser à recadrer la valeur calculée pour chaque pixel afin qu'elle ne
dépasse pas la valeur maximum autorisée (255 dans notre cas).
Pour simplifier et ne pas ralentir le calcul lors de la gestion des bords de l'image, vous
n'appliquerez pas la matrice de convolution sur les pixels extérieur de l'image (1ere et dernière
lignes, 1ere et dernière colonne) et vous la coderez en "dur".
La fonction à écrire aura donc le prototype suivant :
void convol( unsigned char *pImageSource, unsigned char *pImageDest)
{
// coder la fonction
}
Après avoir testé le sobel horizontal seul (-1 0 1) (-2 0 2) (-1 0 1), vous implanterez le sobel
horizontal et le sobel vertical (-1 –2 –1) (0 0 0) (1 2 1) puis le calcul du module pour affichage
des contours de l'image.
2.4 Mesure des performances
IF4-ARCH /T. Grandpierre
7
2.4.1 Outils de mesures
Pour mesurer les performances, vous pouvez utiliser l'outil de profiling intégré à
CodeComposerStudio. Pour prendre rapidement en main cet outil vous pouvez utiliser le tutorial
en ligne que vous obtiendrez dans le menu "Help" "Tutorial" "Code composer IDE"
"Profiling code exécution".
Cependant, cette méthode à l'inconvénient de ralentir beaucoup l'application. Je vous propose
donc d'utiliser le timer matériel intégré au processeur. Pour cela vous utiliserez un exemple de
code qui configure, lance et lit le timer dans le projet fournit "DMA avec timer". Attention, le
timer est incrémenté tous les 4 cycles d'horloges.
2.4.2 Optimisation
Il s'agit maintenant d'optimiser l'exécution. A l'aide des méthodes étudiées
lors du TD Optimisation, optimiser cette fonction. Analysez l'amélioration en
étudiant le source assembleur généré par CCS. Mesurez les performances et
notez les résultats (ramenez en cycles par pixel et en pourcentage d'accélération)
A chaque étape d'optimisation, vérifiez par l'affichage que le résultat obtenu est toujours celui
attendu.
2.5 Comparaison avec des fonctions optimisées en assembleur
Le document [Spru400.pdf] ``TMS320C62x Image/Video Library Programmer's décrit
l'utilisation de la bibliothèque IMGLIB de fonctions de traitement d'images optimisées en
assembleur. Étudier la liste des fonctions fournies et plus particulièrement le sobel.
• Estimez le nombre de cycles qu'elle devrait prendre pour son exécution à
partir de la documentation,
• implémentez la fonction de traitement à l'aide de la bibliothèque de Texas Instruments,
• vérifiez que cela fonctionne et confirmez les performances estimées par la mesure,
• comparez avec votre implémentation du sobel (en cycles par pixel et en pourcentage
d'accélération).
3 Utilisations des DMAs
Comme cela a été abordé dans le cours de présentation de l'IEKC6211, les DMA sur DSP sont
très utilisées car leurs possibilités sont extrêmement puissantes.
Vous allez programmer le contrôleur EDMA du DSP TMS320C6711 pour effectuer des
opérations simples en créant des fonctions que vous pourrez intercaler dans la chaîne de
chargement et de visualisation.
Vous devrez implémenter les fonctions suivantes :
• recopie simple (identique à memcpy)
IF4-ARCH /T. Grandpierre
8
•
•
•
•
retournement horizontal de l'image
retournement vertical de l'image
rotation de 180° de l'image
rotation de 90° d'une portion d'image
Pour implémentez ces fonctions, vous utiliserez la bibliothèque CSL fournie
avec CodeComposerStudio afin de programmer le DMA. Un exemple de programmation EDMA
vous est donné dans le répertoire "c:\temp\exemple-dma.
void main() {
/* Structures utilisées pour transfert DMA */
EDMA_Handle hEdma;
EDMA_Config edmaCfg;
int tcc;
/*--------------fin des déclarations--------------------------*/
memset(&ImageTmp,0,IMAGE_WIDTH*IMAGE_HEIGHT); //mise à zéro de ImageTmp
/*Initialisation pour transfert DMA :*/
CSL_init();
EDMA_resetAll();
// initialize the board and configue to the right video format
board_init();
//Préparation d'un transfer DMA
hEdma=EDMA_open(EDMA_CHA_ANY,EDMA_OPEN_RESET);
tcc=EDMA_intAlloc(-1); //Transfert complete code, -1<=>choix automatique
/*configuration des structure pour le DMA*/
edmaCfg.src = (Uint32) &ImageRef; /* source address */
edmaCfg.cnt = IMAGE_WIDTH*IMAGE_HEIGHT/4; /* count */
edmaCfg.dst = (Uint32) &ImageTmp; /* destination address */
edmaCfg.idx = 1; /*idx */
edmaCfg.rld = 0x00000000 ; /* reload */
edmaCfg.opt=EDMA_OPT_RMK(EDMA_OPT_PRI_LOW,
EDMA_OPT_ESIZE_32BIT,
EDMA_OPT_2DS_YES,
EDMA_OPT_SUM_INC,
EDMA_OPT_2DD_YES,
EDMA_OPT_DUM_INC,
EDMA_OPT_TCINT_YES,
EDMA_OPT_TCC_OF(tcc),
EDMA_OPT_LINK_NO,
EDMA_OPT_FS_NO);
EDMA_config(hEdma,&edmaCfg); //Configuration du DMA
EDMA_setChannel(hEdma);
//Démarrage du transfert
while (!EDMA_intTest(tcc)) ; //attendre la fin du transfert=attendre valeur tcc)
/* Display Luminance only*/
image_display(ImageTmp); }
Pour déterminer les valeurs de configurations de l'EDMA vous pourrez utilisez les documents
suivants (accessibles depuis la rubrique Help de CCS ou dans le répertoire
c:\temp\TP_I4_DSP_2004\docs) :
• [Spru190.pdf] ``TMS320C6000 Peripherals Reference Guide'' : ce document décrit le
fonctionnement interne du DSP, notamment le contrôleur EDMA/QDMA (chap. 6 et
Annexe A),
• [Spru401.pdf] ``TMS320C6000 Chip Support Library API User's Guide''
IF4-ARCH /T. Grandpierre
9
Remarque importante : les erreurs de programmation de l'EDMA se traduisent systématiquement
par un plantage de la carte. En effet, l'EDMA étant une entité autonome du processeur, toute
perte de synchronisation entraîne la nécessité de faire un reset (n'oubliez pas de quitter CCS et de
vérifier que le processus n'existe plus avant de faire ce reset).
Question : pourquoi la valeur "cnt" du DMA est-elle égale à IMAGE_WIDTH*IMAGE_HEIGHT/4 ?
IF4-ARCH /T. Grandpierre
10